Java篇：IO流

流（IO）

四个基本流：　　

　 InputStream（输入字节流）、OutputStream（输出字节流）、writer（输出字符流）、reader（输入字符流）-四个基本流都是抽象类不能实例化，固只能用其子类；
    注意：流结束后一定要关流（close()）和将引用设为null；以便被GC回收。

流的一般异常处理：
    1. 流对象要外置定义内置初始化
    2. 判断流对象是否初始化成功---判断流对象是否为空
    3. 关流操作无论成功与否，都需要将流对象值为null

    // 流对象需要外置定义内置初始化
    FileWriter writer = null;
    try {
        writer = new FileWriter("E:\b.txt");
        writer.write("bbb");

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //需要判断流对象是否为空,以防对象初始化失败出现空指针异常
        if (writer != null) {
            try {
                    writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                writer = null;
            }
        }
    }

字符流：
    FileWriter(String name):传入文件路径，创建新文件。

// 需要准备一个流对象---布尔值表示是否向文件中追加内容
FileWriter writer = new FileWriter("E:\a.txt",true);

// 利用write方法向文件中写入数据
// 数据不是直接写到文件中而是写到了缓冲区中
// 当缓冲区没有满的时候，数据不会写到文件中
// 程序一旦结束，数据死在了缓冲区中
writer.write("aaa
");

// 冲刷缓冲区
// writer.flush();

// 关闭流
//流在关闭之前会自动冲刷一次缓冲区以防有数据死在缓冲区中
//流在关闭之后并没有被销毁，只是不能再次使用
writer.close();
System.out.println(writer);
writer = null;

　　FileReader(String name):传入文件路径，读取文件

//创建一个输入流对象
FileReader reader = new FileReader("D:\a.txt");
//定义一个变量来记录读取的数据
int len = -1;
while((len = raeder.read()) != -1){
    System.out.println((char)len);
}

//需要一个数组来作为盛放读出的数据容器
char[] char = new char[1024];
//定义一个变量来记录读出的数据保存在数组的数
int len = -1;
//将数据读取到char数组中。读到末尾返回的是-1则表示读完了
while((len = rader.read(char))!=-1){
    //将char数组中的数据拿出来拼接成一个字符串并打印
    System.out.println(new String(char,0,len));
}
reader.close();
reader = null;

　　两个缓冲流：BuffReader、BufferedWriter---->主要的作用提供缓冲区

　　BuffReader：从字符输入流中来获取数据；Reader对象来指名数据的具体来源.(需要传入字符流)；

//BufferedReader需要一个字符输入流对象---字符输入流指名数据的具体来源，BufferedReader从流中来获取数据，然后提供一个缓冲区
BufferedReader br = new BufferedReader(new FileReader("D:\a.txt"));
        
//来定义一个变量来记录每一行的数据
String line = null;
        
//读取文件
while((line = br.readLine()) != null){
    System.out.println(line);
}
        
br.close();

　　BufferWriter:主要是提供了newLine这个方法。方便开发时换行在不同的平台实现相同的换行效果。只有BufferWriter这个对象才有newLine方法。

字节流：　　InputStream：输入字节流【如文件不存在时会自动创建，若文件存在则会被新创建的文件所覆盖】
        　　|--FileInputStream（子类）

FileInputStream fis = new FileInputStream("D:\a.txt");
int len = -1;
byte[] by = new byte[1024*1024];
while((len = fis.raeder(by))!=-1){  //将数据读取到字节数组内。
    System.out.println(by,0,len);
}

　　OutputStream：输出字节流【如文件不存在时会自动创建，若文件存在则会被新创建的文件所覆盖】
       　　 |--FileOutputStream（子类）

//准备了一个输出流来向文件中写入数据
FileOutputStream fos = new FileOutputStream("E:\c.txt");
        
//创建一个Scanner对象
Scanner s = new Scanner(System.in);
String str = s.nextLine();
s.close();
        
//写出数据---字节流没有缓冲区
fos.write(str.getBytes());
        
//关流
fos.close();

　　转换流：

　　　　OutputStreamWriter:将字节输出流转换成字符输出流。

//创建了一个流对象---没有指定编码的时候，采用的是系统平台码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\d.txt"),"utf-8");
        
//写出数据
osw.write("达内大数据~~~");
        
//关流
osw.close();

　　　　InputStreamReader:将字节输入流转换成字符输入流

//创建一个输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\d.txt"), "utf-8");
        
//创建一个缓冲流
BufferedReader br = new BufferedReader(isr);
        
//记录每行的数据
String line = null;
        
//读取数据
while((line = br.readLine()) != null){
    System.out.println(line);
}
        
//关流
br.close();

　　系统流：
        　　System.out   标准输出流
        　　System.in     标准输入流
        　　System.err    标准错误流

　　打印流：
        　　PrinteWriter：是一个输出流

// 创建打印流对象
PrintWriter pw = new PrintWriter("D:\a.txt");

// 写出数据
// pw.write("aaa");

// 打印数据
pw.print("aaaa");
pw.println(1.234);
// 打印对象的时候，默认调用了这个对象的toString方法
pw.println(new A());

pw.println("bbbb");

// System.out.println();

// 关流
pw.close();

　　合并流：
      　　  关键字：SequenceInputStream

//创建三个流对象指向三个文件
FileInputStream f1 = new FileInputStream("E:\a.txt");
FileInputStream f2 = new FileInputStream("E:\b.txt");
FileInputStream f3 = new FileInputStream("E:\c.txt");
        
//创建 一个向量对象
//Vector是List的一个实现类，是最早期的列表，在List之前产生的
Vector<InputStream> vector = new Vector<InputStream>();
        
//将流添加到集合中
vector.add(f1);
vector.add(f2);
vector.add(f3);
        
//利用集合产生枚举对象
Enumeration<InputStream> e = vector.elements();
        
//创建合并流对象
SequenceInputStream sis = new SequenceInputStream(e);
        
//读取数据
BufferedReader br = new BufferedReader(new InputStreamReader(sis));
        
//记录每一行的数据
String line = null;
        
//读取数据
while((line = br.readLine()) != null){
    System.out.println(line);
}
        
//关流
br.close();

　　序列化和反序列化：
        　　ObjectOutputStream:是个输出流。----序列化

//实例化一个对象（对象中自己的基本信息）
Person p = new Person;

//创建一个序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\test.txt"));

//序列化对象；writerObject 写入的是一个对象。
oos.writerObject(p);    

//关流     
oos.close();

　　　　ObjectInputStream:是个输入流。 ---反序列化

//创建反序列化流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\test.txt"));

//反序列化对象；从 ObjectInputStream 读取对象。 返回是个Object
Person person = (Person)ois.readObject;  

//关流
ois.close();

//测试；输出Person对象中需要的基本信息
System.ou.println(person.name+","+person.age); 

　　Properties：
       　　 Properties本质上是一个映射，继承了Hashtable类。---可持久的映射。---将映射保存到 properties文件中。
       　　 Properties中键值对的类型都是String。
       　　 properties文件中不能直接存储中文，一旦输入中文会将中文转化成对应的编码
        
       　　 HashMap---默认的初始大小是16，加载因子是0.75f---扩容，扩容一倍---是一个异步式线程不安全的映射---允许一个键为null，允许值为null
        　　Hashtable---默认的初始大小是11，加载因子是0.75f；每次不是一倍---是一个同步式线程安全的映射---不允许键值为空
        　　ConcurrentHashMap---是一个异步式线程安全的映射

　　　　下面的代码是序列化Properties：

//创建properties对象
Properties prop = new Properties();
        
//添加键值对---键值的类型只能是String类型
prop.put("name", "wade");
prop.setProperty("age", "15");
prop.setProperty("gender", "Male");
        
//将prop对象序列化到硬盘上
//第一个参数需要的是一个流对象
//第二个参数需要一个字符串---注释
prop.store(new FileWriter("person.properties"), "This is a person .");

　　　　下面的代码是反序列化Properties：

//创建一个properties对象
Properties p = new Properties();
        
//需要将对象反序列化回来
p.load(new FileInputStream("person.properties"));
        
//根据键来获取值
System.out.println(p.get("name"));

//给了一个默认值，如果这个键不存在或者没有对应的值，那么返回默认值；反之返回对应值
System.out.println(p.getProperty("hobby","打篮球！！！"));