JAVA温习课堂8

43、Collections （操作集合的工具类）
        reverse(List)
            反转 List 中元素的顺序
        shuffle(List)
            对 List 集合元素进行随机排序
        sort(List)
            根据元素的自然顺序对指定 List 集合元素按升序排序
        sort(List，Comparator)
            根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        swap(List，int， int)
            将指定 list 集合中的 i 处元素和 j 处元素进行交换
        Object max(Collection)
            根据元素的自然顺序，返回给定集合中的最大元素
        Object max(Collection，Comparator)
            根据 Comparator 指定的顺序，返回给定集合中的最大元素
        Object min(Collection)
        Object min(Collection，Comparator)
        int frequency(Collection，Object)
            返回指定集合中指定元素的出现次数
        boolean replaceAll(List list，Object oldVal，Object newVal)
            使用新值替换 List 对象的所有旧值

// Collections 工具类 对List 集合进行sort操作
        Collections.sort(list,new Comparator(){

            public int compare(Object obj1, Object obj2) {
                if(obj1 instanceof Person && obj2 instanceof Person){
                    Person p1 = (Person) obj1;
                    Person p2 = (Person) obj2;

                    return - (p1.getAge() - p2.getAge());
                }else{
                    throw new ClassCastException("类型转换失败");
                }
            }
        });


//      获取线程安全的 List 对象，使用synchronizedList()
        List list2 = Collections.synchronizedList(new ArrayList());

        list2.add(new Person("EngineerZhong", 1));

//      创建Enumeration 并通过此进行遍历
        Enumeration names = Collections.enumeration(list2);

        while(names.hasMoreElements()){

            Object obj = names.nextElement();
            System.out.println(obj);
        }


输出结果：
    Person [name=EngineerZh, age=4]
    Person [name=EngineerZho, age=3]
    Person [name=EngineerZhon, age=2]
    Person [name=EngineerZhong, age=1]

    Person [name=EngineerZhong, age=1]

44、泛型（Generic）
    核心思想：把一个List集合中的内容限制为一个特定的数据类型
通过泛型对Map进行遍历
程序代码：
        Map<String,Person> maps = new HashMap<String,Person>(); 

        maps.put("E", new Person("EngineerZhong", 20));
        maps.put("EN", new Person("EngineerYe", 19));
        maps.put("Eng", new Person("EngineerZhou", 22));

        //泛型遍历
        for(Map.Entry<String, Person> entry : maps.entrySet()){
            System.out.println("Key: " + entry.getKey() + " Value: " + entry.getValue());
        }
输出结果：
    Key: E Value: Person [name=EngineerZhong, age=20]
    Key: EN Value: Person [name=EngineerYe, age=19]
    Key: Eng Value: Person [name=EngineerZhou, age=22]

//利用泛型的思想，将集合转成数组
    Person[] personArray = persons.toArray(new Person[0]);
    System.out.println(personArray.length);

    （对于集合没有泛型的情况）
        放入集合中的对象可以是任意类型
        获取元素后，需要进行强制类型转换

    定义泛型类
    public class Dao<T>{
        public T get(Integer id){
            T result = null;
            return result;
        }
    }

    泛型与继承 & 通配符
        String 为Object 类型的子类，则 String[] 也是Object[] 的子类
        Object[] obj = new String[]{"AA","BB","CC"};
        String 为 Object 类型的子类，则List<String> 不是 List<Object>的子类
        //List<String> strList = new ArrayList("AA");
        //List<Object> objList = strList;

    /**
     *  工具方法，打印信息
     *  ？ 通配符 继承 Person
     *  意味着 persons此处可传入 Person 类型 或 Person 子类的某一个类型
        但不能确定是哪个类型，放任何类型都会导致安全问题
     * */
    public static void printStudent2Info(List<? extends Person> persons){   
        for(Person person : persons){
            System.out.println(person);
        }
    }

    定义符泛型方法
        在方法声明时，同时声明泛型，在方法的返回值，参数列表以及方法体中都可以使用泛型类型
        把指定类型的数组中的元素放入到指定类型的集合中

45、枚举类
    一个类的对象是有限而且固定的，因此不能在类的外部创建类的对象
    enum 关键字用于定义枚举类
        enum定义的枚举类默认继承了 java.lang.Enum 类
        枚举类的构造器只能使用private 访问控制符
        所有的枚举类都提供了一个values 方法，该方法能够很方便的遍历所有的枚举值
        代码实例：
            for(Season2 s : Season2.values()){
                System.out.println(s);
            }
        switch 表达式中使用枚举类的对象作为表达式，case 子句可以直接使用枚举值的名字，无需添加枚举类作为限定
        若枚举只有一个成员，则可以作为一种单子模式的实现方法
        枚举类对象的属性不应允许被改动，应该使用 private final 修饰
        枚举类可以实现一个或多个接口
    实现枚举类
        私有化（private） 修饰构造器
        对象是固定的，所以属性只能是常量，使用 private final 修饰
        在类的内部创建对象，但需要在类的外部能够访问到该对象,且不能被修改
        把该类的所有实例都使用 private static final修饰

46、注解 Annotation
        代码中的特殊标记，可以在编译、类加载、运行时被读取，并执行相应的处理
        可以像修饰符一样被使用
        三个基本的Annotation
            @Override : 限定重写父类方法，该注释只能用于方法
            @Deprecated : 表示某个程序元素（类、方法、属性已经过期了）,可以使用，但是不建议使用
            @SuppressWarnings ： 抑制编译器警告
        元数据（MetaData）
    自定义注解
        使用 @interface 关键字 定义注解
        使用类似于接口方法声明的方式来定义注解的属性，其中返回值成为属性的类型，方法名为属性的名称

47、IO流
        输入：读取外部数据到程序（内存）中
        输出：将程序（内存）的数据输出到磁盘等存储设备中
    File 类
        代表与平台无关的文件和目录
        代表物理上的文件和文件夹的形式
            可以新建、删除、重命名文件和目录，File不能访问文件内容，需要通过IO流进行相关访问
代码示例：
        // 创建File 对象的方法
        File file = new File("HelloIo.txt");
        // 文件名相关的方法
        String fileName = file.getName();
        System.out.println(fileName);

        //访问文件的绝对路径
        String path = file.getAbsolutePath();
        System.out.println(path);

        // 重命名文件
//      System.out.println(file.renameTo(new File("g:\\HelloIoTest.txt")));

        //文件检测相关方法
        System.out.println(file.exists());

        //检测是否为文件
        System.out.println(file. isFile());

        //检测是否为目录
        System.out.println(file.isDirectory());

        // 新建目录
        File fileDirectory = new File("EngineerZhong");
        System.out.println(fileDirectory.mkdir());

        //检测内容长度
        System.out.println(file.length());

输入/输出流
    InputStream 和 Reader 是所有输入流的基类
    OutputStream 和 Writer 是所有输出流的基类


部分程序代码实现：       
        /*
         * 字节流 形式读取文件内容
         * */
//      InputStream in = new FileInputStream("helloIo.txt");
//      byte[] bt = new byte[10];
//      int len = 0;
//      while((len = in.read(bt)) != -1){
//          for(int i = 0 ;i < len ; i++){
//              System.out.print((char)bt[i]);
//          }
//      }

        /*
         * 字符流形式读取文件内容
         * */
//      Reader rin = new FileReader("HelloIo.txt");
//      char[] ch = new char[10];
//      int len = 0;
//      while((len = rin.read(ch)) != -1){
//          for(int i = 0; i< len;i++){
//              System.out.print(ch[i]);
//          }
//      }
//      rin.close();

        /*
         * 通过字节流向文件写入数据
         * */
//      
//      OutputStream out = new FileOutputStream("engineer.txt");
//      String content = "EngineerZhong,engineerZhong,hahahhhhhhhhhhhhhh";
//      byte[] buffer = content.getBytes();
//      
//      out.write(buffer);
//      
//      out.close();

        /*
         * 文件拷贝的实现
         * */   
//      InputStream in = new FileInputStream("hello.txt");
//      
//      OutputStream out = new FileOutputStream("hello2.txt");
//      
//      byte[] buffer = new byte[1024 * 10];
//      int len = 0;
//      
//      while((len = in.read(buffer))!= -1){
//          out.write(buffer,0,len);
//      }
//      
//      in.close();
//      out.close();

        /*
         * Buffered 包装流
         *  复制文件
         * */
//      InputStream in = new FileInputStream("engineer.txt");
//      BufferedInputStream bufferedinputstream = new BufferedInputStream(in);
//      
//      OutputStream out = new FileOutputStream("engineer1.txt");
//      BufferedOutputStream bufferedoutputstream = new BufferedOutputStream(out);
//      
//      byte[] buffer = new byte[1024 * 10];
//      int len = 0;
//
//      while((len = bufferedinputstream.read(buffer)) != -1){
//          out.write(buffer, 0, len);
//      }

    /*
    *   文件复制
    *   先创建两个字节输入输出流
    *   然后再转为字符输入输出流
    *   再转为带缓冲的字符输入输出流
    * */
        // 输入流

        InputStream in = new FileInputStream("engineer.txt");

        Reader reader = new InputStreamReader(in);

        BufferedReader bufferedreader = new BufferedReader(reader);

        // 输出流

        OutputStream out = new FileOutputStream("engineerZ.txt");

        Writer writer = new OutputStreamWriter(out);

        BufferedWriter bufferedwriter = new BufferedWriter(writer);

        // 读取信息
        String str = null;
        int i = 0;
        while((str = bufferedreader.readLine()) != null){
            if(i != 0){
                bufferedwriter.write("\n");
            }
            bufferedwriter.write(str);
            i++;
//          bufferedwriter.write(str+"\n");   这个会在文件的最后加上一个换行
        }
        bufferedreader.close();
        bufferedwriter.close();

更新时间：2016年9月21日