1、Collection中的集合称为单列集合，Map中的集合称为双列集合（键值对集合）。

2、Map常用方法：map.put()   map.get()   map.remove()   map.keySet()  //关系对象图 ，可用于遍历，一旦有遍历，就会有迭代器。   打印set 集合， 返回集合所有键的数组。map.getClass()   //返回类的全名。它是Object类的内部类 。

3、八种基本类型的包装类   int  =>  Integer   ;   double  =>  Double 。 基本数据类型只能干加减乘除，别的事情干不了，所以就有了它的包装类。需求：年龄需转成字符串，考试成绩要转为double类型。

包装类提供多种方法实现对数据的操作。  parseInt()   //  将字符串参数作为有符号的十进制整数进行解析，也就是字符串转int类型。

 4、map接口里面的静态接口Entry  （好比静态方法一样），接口中的内部成员，如果不设置非静态的话，就要对象去调用，而接口是不能建立对象的，所以用静态调用。

5、1、泛型的嵌套： Set<Map.Entry<Integer,String>> set = map.entrySet();   // 接口的内部接口。类似类中的内部类。2、迭代Set集合：Iterator<Map.Entry<Integer,String>> it = set.irerator();

 6、增强 for 的底层也是迭代器iterator，所以增强 for 的写法只是简化代码量。

7、面试题：增强for 能不能遍历 Map 集合  ？   //  不能。

8、增强 for 间接遍历 Map 集合。

9、HashMap集合的两种遍历方法  （内在含义都是转set单列结合才能遍历）

 10、重点。HashMap 存储自定义对象 作为键出现，保证键 的 唯一性，就需要重写 hashCode 和 equals 方法。sources。

11、LinkHashMap 保证存储元素顺序的一致  这是与HashMap的区别。两者都是线程不安全的集合，因为运行速度快。

12、Map 接口实现类 Hashtable  。线程安全，运行速度慢。

13、需要记住Map集合的一些特点。HashMap 允许存储 null 键 和 null 值，null 类型 当值当键 都没问题。而Hashtable 不允许存储 null 值 与 null 键。

14、Hashtable 在 1.2起就 逐渐被抛弃，但它的孩子 Properties 依然 活跃在开发舞台。Properties  表示一个持久的属性集。可保存在流中或从流中加载。(集合都是内存的东西，一旦程序结束，就废了，但IO流可以和内存结合起来，把数据集合变成一个永久性的集合存在)。

15、java sdk 1.5新特性==》静态导入的作用：减少开发的代码量。

16、java sdk 1.5新特性==》可变参数：前提，数据类型需要确定，然后参数个数任意。

17、可变参数语法： 数据类型... 变量名。 可变参数，本质，就是一个数组a 。

18、可变参的注意事项：1、一个方法只能有一个可变参数。2、可变参数必须写在列表的最后一位。无敌可变参 Object...o

19、Collection是集合的根接口，而Collections 是集合的工具类。

20、List集合 ，尽量写成多态形式。扩展性强（vector,LinkedList 、ArrayList）。

21、Collections.binarySearch(arr,5)  //  5代表 集合元素  ，返回该元素的索引。Collections.binarySearch(arr,16)  //  16代表 非集合元素，返回值：-（集合长度+1）。

22、Collections.shuffle(list)  // 对集合元素进行随机排列。

23、集合的嵌套：Map集合 存储 Map集合。 

24、Map的Entry子接口，泛型的嵌套，在集合的嵌套遍历之中需要注意。

25、throwable超类。thorows IOException 。

FileInputStream ：字节输入流  （读取操作） ； FileOutputStream ：字节输出流  （写入操作）  第二参数是布尔值，文件追加内容。

 定义一个字节数组缓冲区：byte[] buf = new byte[fis.available()];  注：关闭资源  fis.close();    

26、Reader，读取字符流的抽象超类。

27、FileReader 读取包含中文的文件。看下面拉：

//输出的字符对应的编码值         //输出字符本身
// System.out.println(ch);　　    System.out.print((char)ch);

28、fw.flush()  // 刷新该流的缓冲。

29、flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。

close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。

package cn.laoda.zhaoda;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextFileTest {

    public static void main(String[] args) throws IOException{
        copyTextFile();
    }
    
    public static void copyTextFile() throws IOException {
        //1,明确源和目的。
        FileReader fr = new FileReader("g:\\cn.txt");
        FileWriter fw = new FileWriter("g:\\copy.txt");
        //2,为了提高效率。自定义缓冲区数组。字符数组。
        char[] buf = new char[1024];
        int len = 0;
        while((len=fr.read(buf))!=-1){
            fw.write(buf,0,len);//保留疑问：每次写入的起始位置都是？
        }
        /*2,循环读写操作。效率低。
        int ch = 0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        */
        //3,关闭资源。
        fw.close();
        fr.close();
    }

}

30、IO读写  =>  类总结：

31、把字符转成字节的转换流对象：OutputStreamWriter 。

public class outputStreamWriterDemo {
    public static void main(String[] args) throws Exception{
        outputStreamWriterDemo();
    }
    
    public static void outputStreamWriterDemo() throws Exception {
        //创建与文件关联的字节输出流对象
        FileOutputStream fos = new FileOutputStream("g:\\cn8.txt");
        //创建可以把字符转成字节的转换流对象，并指定编码
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        //调用转换流，把文字写出去，其实是写到转换流的缓冲区中
        osw.write("你好");//写入缓冲区。
        osw.close();
    }
    
}

 32、OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //演示字节转字符流的转换流
        readCN();
    }
    public static void readCN() throws IOException{
        //创建读取文件的字节流对象
        InputStream in = new FileInputStream("c:\\cn8.txt");
        //创建转换流对象 
        //InputStreamReader isr = new InputStreamReader(in);这样创建对象，会用本地默认码表读取，将会发生错误解码的错误
        InputStreamReader isr = new InputStreamReader(in,"utf-8");
        //使用转换流去读字节流中的字节
        int ch = 0;
        while((ch = isr.read())!=-1){
            System.out.println((char)ch);
        }
        //关闭流
        isr.close();
    }
}

 33、public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

34、字符缓冲输入流 ：BufferedReader （从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取） 。   字符缓冲输出流： BufferedWriter  （将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入）    作用：完成文本数据的高效的写入与读取的操作。

35、BufferedWriter  ====>    void newLine() 根据当前的系统，写入一个换行符。

/*
 * BufferedWriter 字符缓冲输出流
 * 方法
 *     public void newLine()写入一个行分隔符
 * 
 * 需求： 通过缓冲输出流写入数据到文件
 * 分析：
 *     1，创建流对象
 *     2，写数据
 *     3，关闭流
 * 
 */
public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建流
        //基本字符输出流
        FileWriter fileOut = new FileWriter("file.txt");
        //把基本的流进行包装
        BufferedWriter out = new BufferedWriter(fileOut);
        //2，写数据
        for (int i=0; i<5; i++) {
            out.write("hello");
            out.newLine();
        }
        //3,关闭流

36、BufferedReader   ==== >   public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

/*
 * BufferedReader 字符缓冲输入流
 * 
 * 方法：
 *     String readLine() 
 * 需求：从文件中读取数据，并显示数据
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //1,创建流
        BufferedReader in = new BufferedReader(new FileReader("file.txt"));
        //2，读数据
        //一次一个字符
        //一次一个字符数组
        //一次读取文本中一行的字符串内容
        String line = null;
        while( (line = in.readLine()) != null ){
            System.out.println(line);
        }
        
        //3,关闭流
        in.close();
    }
}

37、使用字符缓冲流完成文本文件的复制 

/*
 * 采用高效的字符缓冲流，完成文本文件的赋值
 * 
 * 数据源： file.txt
 * 目的地： copyFile.txt
 * 
 * 分析：
 *     1，指定数据源， 是数据源中读数据，采用输入流
 *     2,指定目的地，是把数据写入目的地，采用输出流
 *     3,读数据
 *     4，写数据
*     5，关闭流
 */

public class CopyTextFile {
    public static void main(String[] args) throws IOException {
        //1，指定数据源， 是数据源中读数据，采用输入流
        BufferedReader in = new BufferedReader(new FileReader("file.txt"));
        //2,指定目的地，是把数据写入目的地，采用输出流
        BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));
        //3,读数据
        String line = null;
        while ( (line = in.readLine()) != null ) {
            //4，写数据
            out.write(line);
            //写入换行符号
            out.newLine();
        }
        //5，关闭流
        out.close();
        in.close();
    }
}

~~~~~~·   ~~~~~~~~····~~~~~···· ~~~~~~·   ~~~~~~~

38、IO流中对象很多，解决问题(处理设备上的数据时)到底该用哪个对象呢？　　把IO流进行了规律的总结(四个明确)：

l  明确一：要操作的数据是数据源还是数据目的。

                  源：InputStream    Reader

                  目的：OutputStream Writer

先根据需求明确要读，还是要写。

l  明确二：要操作的数据是字节还是文本呢？

                  源：

                           字节：InputStream

                           文本：Reader

                  目的：

                           字节：OutputStream

                           文本：Writer

已经明确到了具体的体系上。

l  明确三：明确数据所在的具体设备。

                  源设备：

                           硬盘：文件  File开头。

                           内存：数组，字符串。

                           键盘：System.in;

                           网络：Socket

                  目的设备：

硬盘：文件  File开头。

                           内存：数组，字符串。

                           屏幕：System.out

                           网络：Socket

完全可以明确具体要使用哪个流对象。

l  明确四：是否需要额外功能呢？

                  额外功能：

                           转换吗？转换流。InputStreamReader OutputStreamWriter

                           高效吗？缓冲区对象。BufferedXXX

     InputStream

       FileInputStream

       BufferedInputStream

OuputStream

   FileOutputStream

   BufferedOuputStream

Writer

  OutputStreamWriter

     FileWriter

      BufferedWriter

Reader

  InputStreamReader

     FileReader

 BufferedReader

~~~~~~·   ~~~~~~~~····~~~~~···· ~~~~~~·   ~~~~~~~

总结：

l  字节流

  字节输入流 InputStream

  FileInputStream 操作文件的字节输入流

  BufferedInputStream高效的字节输入流

  字节输出流 OutputStream

  FileOutputStream 操作文件的字节输出流

  BufferedOutputStream 高效的字节输出流

l  字符流

  字符输入流 Reader

  FileReader 操作文件的字符输入流

  BufferedReader 高效的字符输入流

  InputStreamReader 输入操作的转换流(把字节流封装成字符流)

  字符输出流 Writer

  FileWriter 操作文件的字符输出流

  BufferedWriter 高效的字符输出流

  OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)

l  方法：

  读数据方法：

  read() 一次读一个字节或字符的方法

   read(byte[]  char[]) 一次读一个数组数据的方法

  readLine() 一次读一行字符串的方法(BufferedReader类特有方法)

  readObject() 从流中读取对象(ObjectInputStream特有方法)

  写数据方法：

  write(int) 一次写一个字节或字符到文件中

  write(byte[] char[]) 一次写一个数组数据到文件中

  write(String) 一次写一个字符串内容到文件中

  writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)

  newLine() 写一个换行符号(BufferedWriter类特有方法)

l  向文件中写入数据的过程

1，创建输出流对象

2，写数据到文件

3，关闭输出流

l  从文件中读数据的过程

1， 创建输入流对象

2， 从文件中读数据

3， 关闭输入流

l  文件复制的过程

1， 创建输入流（数据源）

2， 创建输出流（目的地）

3， 从输入流中读数据

4， 通过输出流，把数据写入目的地

5， 关闭流

39、Error：错误的发生往往都是系统级别的问题，都是jvm所在系统发生的，并反馈给jvm的。我们无法针对处理，只能修正代码。

40、Exception：指程序在编译、运行期间发生了某种异常(XxxException)，我们可以对异常进行具体的处理。若不处理异常，程序将会结束运行。

41、异常：

public class EEX {

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        getElement(arr,5);
    }

    public static int getElement(int[] arr,int index) throws NullPointerException, ArrayIndexOutOfBoundsException {
        if(arr==null){
            throw new NullPointerException("arr指向的数组不存在");
        }
        if(index<0 || index>=arr.length){
            throw new ArrayIndexOutOfBoundsException("错误的角标，"+index+"索引在数组中不存在");
        }
        int element = arr[index];
        return element;
    }
}执行结果：=>

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 错误的角标，5索引在数组中不存在
at cn.itcast.demo.EEX.getElement(EEX.java:15)
at cn.itcast.demo.EEX.main(EEX.java:7)

 42、运行时期异常

  RuntimeException和他的所有子类异常,都属于运行时期异常。NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.

  运行时期异常的特点:

  方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常。

43、异常重写注意细节：

1、子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。

2、当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。

3、当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常的。

举例：父类中会存在下列这种情况，接口也有这种情况

              问题：接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？

答：无法进行throws声明，只能catch的捕获。万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。

interface Inter {
    public abstract void method();
}
class Zi implements Inter {
    public void method(){ //无法声明 throws Exception
        int[] arr = null;
        if (arr == null) {
            //只能捕获处理
            try{
　　　　　　　　　　throw new Exception(“哥们，你定义的数组arr是空的!”);
　　　　　　　　} catch(Exception e){
   　　　　　　　　　　 System.out.println(“父方法中没有异常抛出，子类中不能抛出Exception异常”);
        　　　　　　　　//我们把异常对象e，采用RuntimeException异常方式抛出
        　　　　　　　　throw new RuntimeException(e);
　　　　　　　　　　}
　　　　　　}
　　　　}
　　}

44、异常中常用方法：

  getMessage方法：返回该异常的详细信息字符串，即异常提示信息。

  toString方法：返回该异常的名称与详细信息字符串。

  printStackTrace：在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置。

45、自定义异常类。=>  编译时异常继承Exception，运行时异常继承RuntimeException。

class NoAgeException extends Exception{
    NoAgeException() {
        super();
    }

    NoAgeException(String message)    {
        super(message);
    }
}

 // Person类

class Person{

    private String name;

    private int age;

    Person(String name,int age) throws NoAgeException  {

        //加入逻辑判断。

        if(age<0 || age>200)       {

            throw new NoAgeException(age+",年龄数值非法");

        }

        this.name = name;

        this.age = age;

    }

    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。

    public String toString()   {

        return "Person[name="+name+",age="+age+"]";

    }

}

//测试类

class ExceptionDemo{

    public static void main(String[] args) {

        try {

            Person p = new Person("xiaoming",20);

            System.out.println(p);

        }

        catch (NoAgeException ex){

            System.out.println("年龄异常啦");

        }

        System.out.println("over");

    }

}

 46、Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合

  方法

  load( InputStream in ) 从流所对应的文件中，读数据到集合中

  load( Reader in ) 从流所对应的文件中，读数据到集合中

  store( OutputStream out , String message ) 把集合中的数据，写入到流所对应的文件中

  store( Writer out , String message) 把集合中的数据，写入到流所对应的文件中

  实现文件内容的自动追加

  构造方法

  FileOutputStream(File file, boolean append)

  FileOutputStream(String fileName, boolean append)

  FileWriter(File, boolean append)

  FileWriter(String fileName, boolean append)

  实现文件内容的自动刷新

  构造方法

  PrintStream(OutputStream out, boolean autoFlush)

  PrintWriter(OutputStream out, boolean autoFlush)

  PrintWriter(Writer out, boolean autoFlush)

  Commons-IO

  方法

  readFileToString(File file)：读取文件内容，并返回一个String；

  writeStringToFile(File file，String content)：将内容content写入到file中；

  copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制

  copyFileToDirectory (File srcFile,File destFile);文件复制