学习总结：

1 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2 输入流

2.1 输入字符流（Reader）

java.io.Reader 抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。下面是 Reader 的体系：

public abstract class Reader implements Readable, Closeable{
    protected Reader();
    protected Reader(Object lock)
        //它是个抽象类，因此不能被实例化。
}

2.2实例方法

public void close() ：关闭此流并释放与此流相关联的任何系统资源。

public int read() ： 从输入流读取一个字符。

public int read(char[] cbuf) ： 从输入流中读取一些字符

public abstract int read(char[] cbuf, int off, int len) : 从输入流中读取一些字符

public int read(CharBuffer target) :将字符读入指定的字符缓冲区

public void mark(int readAheadLimit) :标记流中的位置

public boolean ready() : 流是否准备好被读取

public void reset() : 重置流

public long skip(long n) : 跳过字符

2.3 FileReader

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

2.3.1 构造方法

FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。

FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。

File file = new File("D:\\temp\\a.txt"); 

FileReader reader = new FileReader(file); 

FileReader reader1 = new FileReader("D:\\temp\\a.txt");

构造方法内部都是调用了父类的构造方法，传入一个 FileInputStream 对象。

2.3.2 实例方法

FileReader 中的所有方法都来自其父类 InputStreamReader ,没有重写任何方法同时也没有扩展的方法。也就是说，学习了 FileReader 同时也学习了 InputStreamReader .

2.2.4 读取多个字符

// 使用文件名称创建流对象 
FileReader fr = new FileReader("D:/temp/reader2.txt"); 
// 定义变量，保存有效字符个数 
int len; // 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2]; 
// 循环读取 
while ((len = fr.read(cbuf)) != -1) 
{
    System.out.println(new String(cbuf));
}// 关闭资源 fr.close();

2.4 BufferedReader

java.io.BufferedReader 从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。 它是一个缓冲流。

BufferedReader 继承了 Reader 中所有 public 方法，还扩展了一个方法：

public String readLine()//读取一行文字

当 readLine() 读取完毕时，返回 null

2.5增强try

public static void main(String[] args) throws IOException {
    FileOutputStream out = null;
    OutputStreamWriter writer = null;
    try {
        out = new FileOutputStream("d:/temp/outStreamWriter.txt"); Charset set =                     Charset.forName("utf-8");
        writer = new OutputStreamWriter(out, set); 
        System.out.println("编码格式为： " + writer.getEncoding());
        writer.write("站在那别动，我去买橘子");
    } catch (IOException e) { 
        e.printStackTrace(); 
    }finally {
        //关闭资源
        writer.close(); out.close();
    }
}

3.序列化（Serializable）

public interface Serializable { 

} 

3.1例子

package com.ittzb.demo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Demo {
    public static void main(String[] args) {
        Student student =new Student(11,"zs","女");
        
        try(FileOutputStream fs = new FileOutputStream("D:\\lol\\temp.txt");
                ObjectOutputStream oss = new ObjectOutputStream(fs)) {  
                    oss.writeObject(student);
                }
    catch (IOException e) {
    }
}
}

class Student implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Integer age;
    private String name;
    private String gender;
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + ", gender=" + gender + "]";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public Student(Integer age, String name, String gender) {
        super();
        this.age = age;
        this.name = name;
        this.gender = gender;
    }
    
}

package com.ittzb.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Demo02 {
    public static void main(String[] args) {
         try(FileInputStream fs = new FileInputStream("D:\\lol\\temp.txt");
                 ObjectInputStream oss = new ObjectInputStream(fs)
                 ){
             Object o =oss.readObject();
             System.out.println(o.getClass());
             if(o instanceof Student) {
                 Student stu = (Student)o;
                 System.out.println(stu);
             }
             
         } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

作业：

package com.ittzb.demo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Exam {
    
public static void main(String[] args) {
     Exam ex =new Exam();
     Map<Integer,String> map = ex.getMap("D:\\lol\\temp.txt");
        Set<Map.Entry<Integer, String>> entrys =map.entrySet();
        Iterator<Map.Entry<Integer, String>> iter = entrys.iterator();
        while (iter.hasNext()) {
            Map.Entry<Integer, String> en =iter.next();
            System.out.println(en.getValue());
        }
    ex.sort(map,"D:\\\\lol\\\\temp1.txt");
} 
public Map<Integer,String> getMap(String path) {
    Map<Integer,String> map =new TreeMap<Integer,String>(
            (c1,c2)->{
                return c1-c2;
            }
            );
    try(    FileReader fis = new FileReader(path);
            BufferedReader br = new BufferedReader(fis)){
        String line = null;
        int breakWhile= br.read();
        while((line = br.readLine()) != null) {
            map.put(breakWhile,line);
             breakWhile= br.read();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return map;
}

public void  sort(Map<Integer,String> map,String path) {
    
    try(FileWriter fw = new FileWriter(path);
            BufferedWriter bf = new BufferedWriter(fw)
            ){
        Set<Map.Entry<Integer, String>> entrys =map.entrySet();
        Iterator<Map.Entry<Integer, String>> iter = entrys.iterator();
        while (iter.hasNext()) {
            Map.Entry<Integer, String> en =iter.next();
            bf.write(en.getKey());
            bf.write(en.getValue());
            bf.newLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}