Java 基础,java基础【4887王中王鉄算盘奖结果】

来源:http://www.smjxgs.com 作者:王中王鉄算盘 人气:198 发布时间:2019-08-10
摘要:Java 基础,java基础 安排把 Java基础的某些部分重新看贰次,加强一下,下边以及随后就能够分享本人再也学习的少数笔记!不是有关题指标有着知识点,只是自个儿以为模糊的有的知识

Java 基础,java基础

安排把 Java 基础的某些部分重新看贰次,加强一下,下边以及随后就能够分享本人再也学习的少数笔记!不是有关题指标有着知识点,只是自个儿以为模糊的有的知识点。

1.  对于泛型类来说,你若未有指明其品种,默以为Object;

2.  在后续泛型类以及接口的时候能够指明泛型的项目,也足以不指明;

  1.   泛型也数据库中的应用:

      写三个 DAO 类对数据库中的数据进行增加和删除改查其项目证明为 <T> 。每张表对应三个类,对应每一张表完结三个类承袭该 DAO 类并指明 DAO 泛型为该数据表对应的类,再落到实处三个与该表相称的 DAO 操作类,那样就无须在每三个数据表的操作达成类中去落到实处增加和删除改查的主干情势。比如(实际使用中山大学约就是那理念,下边包车型客车比方并不完全):

4887王中王鉄算盘奖结果 1

 1 //数据表对应的类
 2 public class Customer{
 3     private int id;
 4     private String name;
 5     ...
 6 }
 7 
 8 //所有数据表的操作类都要实现的 DAO 基类
 9 public class DAO<T> {
10     //增
11     public void add(T t) {
12     …
13     }
14 }
15 
16 public T get(int index) {
17     //查
18     return null;
19 }
20 
21 public void delete() {
22     //删
23     …
24 }
25 
26 public List<T> getForList(int index) {
27     //查
28     return null;
29 }
30 
31 //数据表操作对应的实现类
32 public class CustomerDao extends DAO<Customer> {
33                 
34 }
35 
36 //测试类
37 public class Test {
38     public static void mian(String[] args) {
39     CustomerDao cus = new CustomerDao;
40     Cus.add(new Customer);
41     }
42 }

View Code

 

  1.   静态方法中不得以应用泛型(static)

      因为static 证明的方式大概类以及变量都是在类初阶化的时候初始化,而泛型是在运作的时候才回到开端化的,所以就出现了难点(后出现的调用了先出现的)。

4887王中王鉄算盘奖结果 2

public T t;
    //Error
    public static void show() {
        System.out.println(t);
}

View Code

 

5.  通配符

      能够读取证明为通配符的聚众,但不得往里写入成分(读的时候能够把成分都感到是 Object,但写的时候其声称为 ?,不是 Object,也正是说写什么项目都以错的,但可以存 null),举例

4887王中王鉄算盘奖结果 3

Public void testList() {
    List<String> strList = new ArrayList<>();
    strList.add(“Hello”);
    strList.add(“World”);

    //correct
    List<?> list = strList;

    //error
    list.add(“hi”);
    list.add(123);
    //correct
    list.add(null);
}

View Code

 

6.  集合Map 的遍历

4887王中王鉄算盘奖结果 4

package com.java.map.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapEntry {

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        // 得到 map 所有键的集合
        Set<Integer> keys = map.keySet();

        for (Integer key : map.keySet()) {
            System.out.println(map.get(key));
        }

        // 利用迭代器 遍历
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            System.out.println(entry.getKey()   " -> "   entry.getValue());
        }

        // 第三种
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }

        // 遍历所有的 value 值
        Collection<String> values = map.values();

        for (String val : values) {
            System.out.println(val   ">>-");
        }

        Iterator<String> i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next()   "-->");
        }

        List<String> lists = new ArrayList<>();
        lists.add("1");
        lists.add("2");
        lists.add("3");
        lists.add("4");

        Iterator<String> it2 = lists.iterator();

        while (it2.hasNext()) {
            System.out.println(it2.next());
        }

        Collections.reverse(lists);
        Iterator<String> it3 = lists.iterator();
//        Comparator comparator = new 


        while (it3.hasNext()) {
            System.out.println(it3.next()   "<->");
        }
    }
}

View Code

 

7.  利用反射获取方法名和属性名,利用反射还足以拿走构造器等任何消息

4887王中王鉄算盘奖结果 5

package com.java.reflct.test;

//实体类
public class Person {

    private String id;

    private String name;

    public int phone;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }

    public int getPhone() {
        return phone;
    }

    private void print() {
        System.out.println("your id is "   id   ", your name is "   name   ", your phone is "   phone   "!");
    }

    @Override
    public String toString() {
        return "Person [id="   id   ", name="   name   ", phone="   phone   "]";
    }
}

package com.java.reflct.test;
//测试类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) {
        try {
//            通过 Class.forName("全类名"); 获取 Class,还以利用  对象名.getClass()  类名.class(); 获取Class
            Class cla = Class.forName("com.java.reflct.test.Person");
            Class cla2 = Person.class;

//            获取所有的 变量,返回数组,包括私有变量
            Field[] fields = cla2.getDeclaredFields();
//            遍历变量数组
            for (Field fie : fields) {
                System.out.println(fie "-..-");
            }

//            获取所有的方法,返回数组,包括私有方法
            Method[] methods = cla.getDeclaredMethods();

            for (Method met : methods) {
                System.out.println(met);
            }

            try {
//                获取单个私有属性
                Field field = cla.getDeclaredField("id");
//                打破封装
                field.setAccessible(true);
                System.out.println(field   "<<>>");
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Method method = null;

            try {
//                获取单个私有方法
                method = cla.getDeclaredMethod("print");
//                打破封装
                method.setAccessible(true);
                System.out.println(method   ">><<");
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
//                通过cla.newInstance(); 获取类的对象
                Person person = (Person) cla.newInstance();
                person.setId("1");
                person.setName("yinyin");
                person.setPhone(110);

                System.out.println(person   "__>>__");
                try {
//                    执行 person 对象的中 method 所对应的方法
                    method.invoke(person);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InstantiationException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }


        } catch(ClassNotFoundException e) {
            System.out.println("There is no class "   e);
        }
    }
}

View Code

 

8.  Comparator  类的利用(利用  Comparator  实现集结的自定义排序)

      注意区分 Collections (集结的处理类)和 Collection (集结基类)

4887王中王鉄算盘奖结果 6

package com.java.collection.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/*
 * Collections 是 Collection 的操作类
 */

public class CollectionComparator {

    public static void main(String[] args) {

        Comparator<Customer> com = new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,使得 id 相等时有其他的处理方法
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
//                    给 return 添加一个 - 号可以实现 “从大到小”
                    return o1.getName().compareTo(o2.getName());
                }
//                                    Id 不相等时返回其值        
                                   return i;
            }
        };

        List<Customer> lists = new ArrayList<>();
        lists.add(new Customer("yinyin", "110", 1001));
        lists.add(new Customer("zhao", "10086", 1002));
        lists.add(new Customer("ls", "10010", 1001));;

        Collections.sort(lists, com);

//        利用匿名类实现自定义排序
        /*
        Collections.sort(lists, new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,避免 id 相等没有其值
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
                    return o1.getName().compareTo(o2.getName());
                }
                return i;
            }
        });
        */
 //利用迭代器遍历集合
        Iterator<Customer> it = lists.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }

    }
}

View Code

 

9.  IO

      读取指标文本文件的字节数

4887王中王鉄算盘奖结果 7

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class MyIoTest {

    public static void main(String[] args) {

//        在 IO 中出现的异常最好都使用 try-catch 包裹起来,不要 throw,因为这样可以保证流的关闭在任何时候都可以正常执行
        InputStream fileStream = null;
        int count = 0;
        try {
            fileStream = new FileInputStream(new File("hello.txt"));
//            读取文件的下一个字节
            while (fileStream.read() != -1) {
                count  ;
            }
//            打印目标文件的字节数
            System.out.println(count);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

 

      完成公文的复制(InputStream 、OutputStream 和 Reader 、Writer)。文本文件的操作使用 Reader Writer(字符流) 去贯彻,功效高。可是不得以去操作媒体文件;媒体文件使用 InputStream OutputStream 去落到实处,也足以对文本文件举行操作,可是从未字符流高效。

4887王中王鉄算盘奖结果 8

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyFile {

    public static void main(String[] args) {
//        设置一次从目标文件中读取多少字节
        byte[] buffer = new byte[1024];

        int len = 0;
        File file = new File("C:/Users/lenovo/Desktop/123.wmv");
        InputStream fileInput = null;
        OutputStream fileOut = null;

        try {
            fileInput = new FileInputStream(file);
            fileOut = new FileOutputStream(new File("C:/Users/lenovo/Desktop/trave2.wmv"));

//            len 的作用是防止读取文件时最后一次其长度不够读取被置为零,read() 返回读入缓冲区的字节总数
            while ((len = fileInput.read(buffer)) != -1) {
                fileOut.write(buffer, 0, len);
            }
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileOut.close();
                fileInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}





//利用 Reader Writer 实现
package com.java.io.file.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class ReaderWriter {

    public static void main(String[] args) {
        File file = new File("hello.txt");
        int len = 0;
        Reader fileReader = null;
        Writer fileWriter = null;
        char[] ch = new char[125];

        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(new File("world.txt"));

            while((len = fileReader.read(ch)) != -1) {
                fileWriter.write(ch, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

 

10.  应用缓冲流达成公文的复制操作,功用更加高

4887王中王鉄算盘奖结果 9

package com.java.io.file.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TestBufferedCopy {
// 使用缓冲流实现文件的复制
    public static void main(String[] args)  {

        int len = 0;
        byte[] buffer = new byte[2048];

        File file = new File("C:/Users/lenovo/Desktop/123.rmvb");
        InputStream inputFile = null;
        OutputStream outputFile = null;

        BufferedInputStream bufferedInput = null;
        BufferedOutputStream bufferedOutput = null;

        try {
            inputFile = new FileInputStream(file);
            outputFile = new FileOutputStream("C:/Users/lenovo/Desktop/456.rmvb");

            bufferedInput = new BufferedInputStream(inputFile);
            bufferedOutput = new BufferedOutputStream(outputFile);

            while((len = bufferedInput.read(buffer)) != -1) {
                bufferedOutput.write(buffer, 0, len);
            }

            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
//                只需关闭复制文件用到的就可以,即最后两个
                bufferedOutput.close();
                bufferedInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

 

地点的代码计算啥的都以自身日常练习进程中的代码和体会,对于知识点讲明覆盖的并不到家,还望谅解。初来乍到不晓得该怎么去写!

基础,java基础 安插把 Java 基础的有一点点部分重新看一回,加强一下,上边以及后来就能享受温馨再一次学习的有些笔记!不是关于题指标所...

安排把 Java 基础的有一点部分重新看叁遍,加强一下,上面以及以往就能享用本身重新学习的一些笔记!不是有关标题标兼具知识点,只是本人以为模糊的片段知识点。

陈设把 Java 基础的有一些部分重新看一次,巩固一下,上面以及以往就能享受自身重新学习的有个别笔记!不是有关题指标有所知识点,只是自身以为模糊的一部分知识点。

1.  对于泛型类来讲,你若未有指明其种类,默认为Object;

1.  对此泛型类来讲,你若未有指明其连串,默许为Object;

2.  在三番四遍泛型类以及接口的时候能够指明泛型的项目,也足以不指明;

2.  在后续泛型类以及接口的时候可以指明泛型的种类,也能够不指明;

  1.   泛型也数据库中的应用:
  1.   泛型也数据库中的应用:

      写一个 DAO 类对数据库中的数据开始展览增加和删除改查其品种注解为 <T> 。每张表对应三个类,对应每一张表实现三个类承接该 DAO 类并指明 DAO 泛型为该数据表对应的类,再落到实处三个与该表匹配的 DAO 操作类,那样就不要在每一个数据表的操作达成类中去贯彻增加和删除改查的着力办法。举例(实际行使中山高校约就是那观念,下边包车型客车比方并不完整):

      写三个 DAO 类对数据库中的数据开始展览增加和删除改查其品种声明为 <T> 。每张表对应多个类,对应每一张表达成叁个类承继该 DAO 类并指明 DAO 泛型为该数据表对应的类,再落到实处八个与该表相配的 DAO 操作类,那样就不需求在每贰个数据表的操作达成类中去落到实处增加和删除改查的骨干方法。比如(实际选择中山大学约正是那观念,下边的比喻并不完整):

4887王中王鉄算盘奖结果 104887王中王鉄算盘奖结果 11

4887王中王鉄算盘奖结果 124887王中王鉄算盘奖结果 13

 1 //数据表对应的类
 2 public class Customer{
 3     private int id;
 4     private String name;
 5     ...
 6 }
 7 
 8 //所有数据表的操作类都要实现的 DAO 基类
 9 public class DAO<T> {
10     //增
11     public void add(T t) {
12     …
13     }
14 }
15 
16 public T get(int index) {
17     //查
18     return null;
19 }
20 
21 public void delete() {
22     //删
23     …
24 }
25 
26 public List<T> getForList(int index) {
27     //查
28     return null;
29 }
30 
31 //数据表操作对应的实现类
32 public class CustomerDao extends DAO<Customer> {
33                 
34 }
35 
36 //测试类
37 public class Test {
38     public static void mian(String[] args) {
39     CustomerDao cus = new CustomerDao;
40     Cus.add(new Customer);
41     }
42 }
 1 //数据表对应的类
 2 public class Customer{
 3     private int id;
 4     private String name;
 5     ...
 6 }
 7 
 8 //所有数据表的操作类都要实现的 DAO 基类
 9 public class DAO<T> {
10     //增
11     public void add(T t) {
12     …
13     }
14 }
15 
16 public T get(int index) {
17     //查
18     return null;
19 }
20 
21 public void delete() {
22     //删
23     …
24 }
25 
26 public List<T> getForList(int index) {
27     //查
28     return null;
29 }
30 
31 //数据表操作对应的实现类
32 public class CustomerDao extends DAO<Customer> {
33                 
34 }
35 
36 //测试类
37 public class Test {
38     public static void mian(String[] args) {
39     CustomerDao cus = new CustomerDao;
40     Cus.add(new Customer);
41     }
42 }

4887王中王鉄算盘奖结果,View Code

View Code

 

 

  1.   静态方法中不可能利用泛型(static)
  1.   静态方法中不得以行使泛型(static)

      因为static 证明的不二秘技还是类以及变量都是在类开始化的时候开首化,而泛型是在运作的时候才回到开始化的,所以就应际而生了难题(后出现的调用了先出现的)。

      因为static 注解的章程依然类以及变量都以在类开端化的时候初步化,而泛型是在运维的时候才回到起头化的,所以就涌出了难题(后出现的调用了先现身的)。

4887王中王鉄算盘奖结果 144887王中王鉄算盘奖结果 15

4887王中王鉄算盘奖结果 164887王中王鉄算盘奖结果 17

public T t;
    //Error
    public static void show() {
        System.out.println(t);
}
public T t;
    //Error
    public static void show() {
        System.out.println(t);
}

View Code

View Code

 

 

5.  通配符

5.  通配符

      能够读取申明为通配符的集聚,但不足往里写入成分(读的时候能够把成分都觉着是 Object,但写的时候其宣称为 ?,不是 Object,也正是说写什么品种都是错的,但足以存 null),比方

      能够读取评释为通配符的会晤,但不足往里写入成分(读的时候能够把成分都以为是 Object,但写的时候其宣称为 ?,不是 Object,也正是说写什么品种都是错的,但能够存 null),举例

4887王中王鉄算盘奖结果 184887王中王鉄算盘奖结果 19

4887王中王鉄算盘奖结果 204887王中王鉄算盘奖结果 21

Public void testList() {
    List<String> strList = new ArrayList<>();
    strList.add(“Hello”);
    strList.add(“World”);

    //correct
    List<?> list = strList;

    //error
    list.add(“hi”);
    list.add(123);
    //correct
    list.add(null);
}
Public void testList() {
    List<String> strList = new ArrayList<>();
    strList.add(“Hello”);
    strList.add(“World”);

    //correct
    List<?> list = strList;

    //error
    list.add(“hi”);
    list.add(123);
    //correct
    list.add(null);
}

View Code

View Code

 

 

6.  集合Map 的遍历

6.  集合Map 的遍历

4887王中王鉄算盘奖结果 224887王中王鉄算盘奖结果 23

4887王中王鉄算盘奖结果 244887王中王鉄算盘奖结果 25

package com.java.map.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapEntry {

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        // 得到 map 所有键的集合
        Set<Integer> keys = map.keySet();

        for (Integer key : map.keySet()) {
            System.out.println(map.get(key));
        }

        // 利用迭代器 遍历
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            System.out.println(entry.getKey()   " -> "   entry.getValue());
        }

        // 第三种
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }

        // 遍历所有的 value 值
        Collection<String> values = map.values();

        for (String val : values) {
            System.out.println(val   ">>-");
        }

        Iterator<String> i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next()   "-->");
        }

        List<String> lists = new ArrayList<>();
        lists.add("1");
        lists.add("2");
        lists.add("3");
        lists.add("4");

        Iterator<String> it2 = lists.iterator();

        while (it2.hasNext()) {
            System.out.println(it2.next());
        }

        Collections.reverse(lists);
        Iterator<String> it3 = lists.iterator();
//        Comparator comparator = new 


        while (it3.hasNext()) {
            System.out.println(it3.next()   "<->");
        }
    }
}
package com.java.map.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapEntry {

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        // 得到 map 所有键的集合
        Set<Integer> keys = map.keySet();

        for (Integer key : map.keySet()) {
            System.out.println(map.get(key));
        }

        // 利用迭代器 遍历
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            System.out.println(entry.getKey()   " -> "   entry.getValue());
        }

        // 第三种
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }

        // 遍历所有的 value 值
        Collection<String> values = map.values();

        for (String val : values) {
            System.out.println(val   ">>-");
        }

        Iterator<String> i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next()   "-->");
        }

        List<String> lists = new ArrayList<>();
        lists.add("1");
        lists.add("2");
        lists.add("3");
        lists.add("4");

        Iterator<String> it2 = lists.iterator();

        while (it2.hasNext()) {
            System.out.println(it2.next());
        }

        Collections.reverse(lists);
        Iterator<String> it3 = lists.iterator();
//        Comparator comparator = new 


        while (it3.hasNext()) {
            System.out.println(it3.next()   "<->");
        }
    }
}

View Code

View Code

 

 

7.  利用反射获取方法名和属性名,利用反射还足以博得构造器等其他新闻

7.  利用反射获取方法名和属性名,利用反射还足以拿走构造器等别的新闻

4887王中王鉄算盘奖结果 264887王中王鉄算盘奖结果 27

4887王中王鉄算盘奖结果 284887王中王鉄算盘奖结果 29

package com.java.reflct.test;

//实体类
public class Person {

    private String id;

    private String name;

    public int phone;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }

    public int getPhone() {
        return phone;
    }

    private void print() {
        System.out.println("your id is "   id   ", your name is "   name   ", your phone is "   phone   "!");
    }

    @Override
    public String toString() {
        return "Person [id="   id   ", name="   name   ", phone="   phone   "]";
    }
}

package com.java.reflct.test;
//测试类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) {
        try {
//            通过 Class.forName("全类名"); 获取 Class,还以利用  对象名.getClass()  类名.class(); 获取Class
            Class cla = Class.forName("com.java.reflct.test.Person");
            Class cla2 = Person.class;

//            获取所有的 变量,返回数组,包括私有变量
            Field[] fields = cla2.getDeclaredFields();
//            遍历变量数组
            for (Field fie : fields) {
                System.out.println(fie "-..-");
            }

//            获取所有的方法,返回数组,包括私有方法
            Method[] methods = cla.getDeclaredMethods();

            for (Method met : methods) {
                System.out.println(met);
            }

            try {
//                获取单个私有属性
                Field field = cla.getDeclaredField("id");
//                打破封装
                field.setAccessible(true);
                System.out.println(field   "<<>>");
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Method method = null;

            try {
//                获取单个私有方法
                method = cla.getDeclaredMethod("print");
//                打破封装
                method.setAccessible(true);
                System.out.println(method   ">><<");
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
//                通过cla.newInstance(); 获取类的对象
                Person person = (Person) cla.newInstance();
                person.setId("1");
                person.setName("yinyin");
                person.setPhone(110);

                System.out.println(person   "__>>__");
                try {
//                    执行 person 对象的中 method 所对应的方法
                    method.invoke(person);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InstantiationException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }


        } catch(ClassNotFoundException e) {
            System.out.println("There is no class "   e);
        }
    }
}
package com.java.reflct.test;

//实体类
public class Person {

    private String id;

    private String name;

    public int phone;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }

    public int getPhone() {
        return phone;
    }

    private void print() {
        System.out.println("your id is "   id   ", your name is "   name   ", your phone is "   phone   "!");
    }

    @Override
    public String toString() {
        return "Person [id="   id   ", name="   name   ", phone="   phone   "]";
    }
}

package com.java.reflct.test;
//测试类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) {
        try {
//            通过 Class.forName("全类名"); 获取 Class,还以利用  对象名.getClass()  类名.class(); 获取Class
            Class cla = Class.forName("com.java.reflct.test.Person");
            Class cla2 = Person.class;

//            获取所有的 变量,返回数组,包括私有变量
            Field[] fields = cla2.getDeclaredFields();
//            遍历变量数组
            for (Field fie : fields) {
                System.out.println(fie "-..-");
            }

//            获取所有的方法,返回数组,包括私有方法
            Method[] methods = cla.getDeclaredMethods();

            for (Method met : methods) {
                System.out.println(met);
            }

            try {
//                获取单个私有属性
                Field field = cla.getDeclaredField("id");
//                打破封装
                field.setAccessible(true);
                System.out.println(field   "<<>>");
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Method method = null;

            try {
//                获取单个私有方法
                method = cla.getDeclaredMethod("print");
//                打破封装
                method.setAccessible(true);
                System.out.println(method   ">><<");
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
//                通过cla.newInstance(); 获取类的对象
                Person person = (Person) cla.newInstance();
                person.setId("1");
                person.setName("yinyin");
                person.setPhone(110);

                System.out.println(person   "__>>__");
                try {
//                    执行 person 对象的中 method 所对应的方法
                    method.invoke(person);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InstantiationException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }


        } catch(ClassNotFoundException e) {
            System.out.println("There is no class "   e);
        }
    }
}

View Code

View Code

 

 

8.  Comparator  类的利用(利用  Comparator  实现群集的自定义排序)

8.  Comparator  类的运用(利用  Comparator  达成集结的自定义排序)

      注意区分 Collections (集结的管理类)和 Collection (会集基类)

      注意区分 Collections (集合的管理类)和 Collection (会集基类)

4887王中王鉄算盘奖结果 304887王中王鉄算盘奖结果 31

4887王中王鉄算盘奖结果 324887王中王鉄算盘奖结果 33

package com.java.collection.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/*
 * Collections 是 Collection 的操作类
 */

public class CollectionComparator {

    public static void main(String[] args) {

        Comparator<Customer> com = new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,使得 id 相等时有其他的处理方法
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
//                    给 return 添加一个 - 号可以实现 “从大到小”
                    return o1.getName().compareTo(o2.getName());
                }
//                                    Id 不相等时返回其值        
                                   return i;
            }
        };

        List<Customer> lists = new ArrayList<>();
        lists.add(new Customer("yinyin", "110", 1001));
        lists.add(new Customer("zhao", "10086", 1002));
        lists.add(new Customer("ls", "10010", 1001));;

        Collections.sort(lists, com);

//        利用匿名类实现自定义排序
        /*
        Collections.sort(lists, new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,避免 id 相等没有其值
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
                    return o1.getName().compareTo(o2.getName());
                }
                return i;
            }
        });
        */
 //利用迭代器遍历集合
        Iterator<Customer> it = lists.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }

    }
}
package com.java.collection.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/*
 * Collections 是 Collection 的操作类
 */

public class CollectionComparator {

    public static void main(String[] args) {

        Comparator<Customer> com = new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,使得 id 相等时有其他的处理方法
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
//                    给 return 添加一个 - 号可以实现 “从大到小”
                    return o1.getName().compareTo(o2.getName());
                }
//                                    Id 不相等时返回其值        
                                   return i;
            }
        };

        List<Customer> lists = new ArrayList<>();
        lists.add(new Customer("yinyin", "110", 1001));
        lists.add(new Customer("zhao", "10086", 1002));
        lists.add(new Customer("ls", "10010", 1001));;

        Collections.sort(lists, com);

//        利用匿名类实现自定义排序
        /*
        Collections.sort(lists, new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中,避免 id 相等没有其值
                int i = o1.getId().compareTo(o2.getId());

//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
                    return o1.getName().compareTo(o2.getName());
                }
                return i;
            }
        });
        */
 //利用迭代器遍历集合
        Iterator<Customer> it = lists.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }

    }
}

View Code

View Code

 

 

9.  IO

9.  IO

      读取指标文本文件的字节数

      读取指标文本文件的字节数

4887王中王鉄算盘奖结果 344887王中王鉄算盘奖结果 35

4887王中王鉄算盘奖结果 364887王中王鉄算盘奖结果 37

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class MyIoTest {

    public static void main(String[] args) {

//        在 IO 中出现的异常最好都使用 try-catch 包裹起来,不要 throw,因为这样可以保证流的关闭在任何时候都可以正常执行
        InputStream fileStream = null;
        int count = 0;
        try {
            fileStream = new FileInputStream(new File("hello.txt"));
//            读取文件的下一个字节
            while (fileStream.read() != -1) {
                count  ;
            }
//            打印目标文件的字节数
            System.out.println(count);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class MyIoTest {

    public static void main(String[] args) {

//        在 IO 中出现的异常最好都使用 try-catch 包裹起来,不要 throw,因为这样可以保证流的关闭在任何时候都可以正常执行
        InputStream fileStream = null;
        int count = 0;
        try {
            fileStream = new FileInputStream(new File("hello.txt"));
//            读取文件的下一个字节
            while (fileStream.read() != -1) {
                count  ;
            }
//            打印目标文件的字节数
            System.out.println(count);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

View Code

 

 

      达成文件的复制(InputStream 、OutputStream 和 Reader 、Writer)。文本文件的操作使用 Reader Writer(字符流) 去完成,功能高。可是不可以去操作媒体文件;媒体文件使用 InputStream OutputStream 去贯彻,也得以对文本文件实行操作,但是尚未字符流高效。

      实现文件的复制(InputStream 、OutputStream 和 里德r 、Writer)。文本文件的操作使用 Reader Writer(字符流) 去贯彻,功用高。不过不能去操作媒体文件;媒体文件使用 InputStream OutputStream 去落到实处,也足以对文本文件实行操作,但是没有字符流高效。

4887王中王鉄算盘奖结果 384887王中王鉄算盘奖结果 39

4887王中王鉄算盘奖结果 404887王中王鉄算盘奖结果 41

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyFile {

    public static void main(String[] args) {
//        设置一次从目标文件中读取多少字节
        byte[] buffer = new byte[1024];

        int len = 0;
        File file = new File("C:/Users/lenovo/Desktop/123.wmv");
        InputStream fileInput = null;
        OutputStream fileOut = null;

        try {
            fileInput = new FileInputStream(file);
            fileOut = new FileOutputStream(new File("C:/Users/lenovo/Desktop/trave2.wmv"));

//            len 的作用是防止读取文件时最后一次其长度不够读取被置为零,read() 返回读入缓冲区的字节总数
            while ((len = fileInput.read(buffer)) != -1) {
                fileOut.write(buffer, 0, len);
            }
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileOut.close();
                fileInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}





//利用 Reader Writer 实现
package com.java.io.file.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class ReaderWriter {

    public static void main(String[] args) {
        File file = new File("hello.txt");
        int len = 0;
        Reader fileReader = null;
        Writer fileWriter = null;
        char[] ch = new char[125];

        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(new File("world.txt"));

            while((len = fileReader.read(ch)) != -1) {
                fileWriter.write(ch, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyFile {

    public static void main(String[] args) {
//        设置一次从目标文件中读取多少字节
        byte[] buffer = new byte[1024];

        int len = 0;
        File file = new File("C:/Users/lenovo/Desktop/123.wmv");
        InputStream fileInput = null;
        OutputStream fileOut = null;

        try {
            fileInput = new FileInputStream(file);
            fileOut = new FileOutputStream(new File("C:/Users/lenovo/Desktop/trave2.wmv"));

//            len 的作用是防止读取文件时最后一次其长度不够读取被置为零,read() 返回读入缓冲区的字节总数
            while ((len = fileInput.read(buffer)) != -1) {
                fileOut.write(buffer, 0, len);
            }
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileOut.close();
                fileInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}





//利用 Reader Writer 实现
package com.java.io.file.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class ReaderWriter {

    public static void main(String[] args) {
        File file = new File("hello.txt");
        int len = 0;
        Reader fileReader = null;
        Writer fileWriter = null;
        char[] ch = new char[125];

        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(new File("world.txt"));

            while((len = fileReader.read(ch)) != -1) {
                fileWriter.write(ch, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

View Code

 

 

10.  利用缓冲流落成文件的复制操作,作用更加高

10.  使用缓冲流完结公文的复制操作,作用更加高

4887王中王鉄算盘奖结果 424887王中王鉄算盘奖结果 43

4887王中王鉄算盘奖结果 444887王中王鉄算盘奖结果 45

package com.java.io.file.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TestBufferedCopy {
// 使用缓冲流实现文件的复制
    public static void main(String[] args)  {

        int len = 0;
        byte[] buffer = new byte[2048];

        File file = new File("C:/Users/lenovo/Desktop/123.rmvb");
        InputStream inputFile = null;
        OutputStream outputFile = null;

        BufferedInputStream bufferedInput = null;
        BufferedOutputStream bufferedOutput = null;

        try {
            inputFile = new FileInputStream(file);
            outputFile = new FileOutputStream("C:/Users/lenovo/Desktop/456.rmvb");

            bufferedInput = new BufferedInputStream(inputFile);
            bufferedOutput = new BufferedOutputStream(outputFile);

            while((len = bufferedInput.read(buffer)) != -1) {
                bufferedOutput.write(buffer, 0, len);
            }

            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
//                只需关闭复制文件用到的就可以,即最后两个
                bufferedOutput.close();
                bufferedInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
package com.java.io.file.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TestBufferedCopy {
// 使用缓冲流实现文件的复制
    public static void main(String[] args)  {

        int len = 0;
        byte[] buffer = new byte[2048];

        File file = new File("C:/Users/lenovo/Desktop/123.rmvb");
        InputStream inputFile = null;
        OutputStream outputFile = null;

        BufferedInputStream bufferedInput = null;
        BufferedOutputStream bufferedOutput = null;

        try {
            inputFile = new FileInputStream(file);
            outputFile = new FileOutputStream("C:/Users/lenovo/Desktop/456.rmvb");

            bufferedInput = new BufferedInputStream(inputFile);
            bufferedOutput = new BufferedOutputStream(outputFile);

            while((len = bufferedInput.read(buffer)) != -1) {
                bufferedOutput.write(buffer, 0, len);
            }

            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
//                只需关闭复制文件用到的就可以,即最后两个
                bufferedOutput.close();
                bufferedInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

View Code

 

 

地点的代码总括啥的都以和煦日常演习进度中的代码和经验,对于知识点疏解覆盖的并不全面,还望谅解。初来乍到不知底该怎么去写!

下面的代码计算啥的都是温馨平凡演练进度中的代码和心得,对于知识点讲明覆盖的并不周到,还望谅解。初来乍到不知道该怎么样去写!

本文由4887王中王鉄算盘奖结果发布于王中王鉄算盘,转载请注明出处:Java 基础,java基础【4887王中王鉄算盘奖结果】

关键词:

最火资讯