缓冲流，Properties 集合以及对象流解析

```
缓冲流（高效的流）
BufferedOutputStream
BufferedInputStream

构造方法
BufferedOutputStream(OutputStream out)
参数就是字节输出流的父类


例
写入：
FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/test/ppp.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("wanzhiwei".getBytes());
bos.close();

注意 关闭时只要关闭缓冲流就可以了


读出
FileInputStream inputStream = new FileInputStream("/Users/lanou/Desktop/test/ppp.txt");
BufferedInputStream bis = new BufferedInputStream(inputStream);
int len = 0;
byte[] b = bew byte[1024];
while((len = bis.read(b))!=-1){
    System.out.println(new String(b,0,len));
}
bis.close();


BufferWriter
BufferReader()
构造方法
参数：Writer（父类）
可以传字符流，也可以传转换流


写入
FileWriter f = new FileWriter("/Users/lanou/Desktop/test/ppp.txt")
BUfferedWriter bf = new BufferedWriter(f);
bf.write("是兄弟");
bf.nextline();
bf.write("是兄弟就来完贪玩蓝月");
bf.flush();
bf.close();

注意 写一次刷新一次，nextline这个方法无关平台性，可以写入一个换行


FileReader f = new  FileReader("/Users/lanou/Desktop/test/ppp.txt");
BufferedReader br =new BufferedReader(f);
String string = "";
whiel((string = br.readline())!=null){
    System.out.println(string);
}

文件复制
FileReader reader = new FileReader("/Users/lanou/Desktop/test/ppp.txt");    FileWriter writer = new FileWriter("/Users/lanou/Desktop/test/ppp2.txt");
BufferedReader bfs = new BufferedReader(reader);
BufferedWriter bfw = new BufferedWriter(writer);

String string = "";
while((string =bfs.readline())!=null){
    bfw.write(string);//写入
    bfw.nextline();
    bfw.flush();
}
bfs.close();
bfw.close();

注意 ； 这里复制是时候换行是复制不出来的 要手动添加




流的总结：
读：intputStream Reader
写：outputStream writer

字节流是全能流 能操作文件 音频 图片 
FileInputStream  FIleoutputStream
字符流只能操作文本
FileReader  FileWriter
提高效率
Buffered


properties 集合 父类是HashTable 线程安全 不能存空值 
作用：Proferties是集合中唯一一个能和io流配合的类
读取和写入时传入的参数字符流，字节流都可以

//读取
Properties properties =new Properties();
FileReader fileReader =new FileReader("/Users/lanou/Desktop/test/ppp.txt");
properties.load(fileReader);
System.out.println("properties");



写入
Properties properties =new Properties();
properties.setProperty("我","李易峰");
properties.setProprety("qwe","ahh");
FileWriter fw =new FileWriter("/Users/lanou/Desktop/test/xzb.properties");
properties.store(fw,"");
fw.close();


注意 这个集合的两个参数都是字符串类型
store（）方法中两个参数 ，后面那个作注释用一般不填。



序列化和反序列化
注意点 如果要对对象实例化 ，就必须实现接口Serializable 
该接口是标记性接口 
写对象要用字节流去写
写入：
FileOutputStream fos =new FileOutputStream("/Users/lanou/Desktop/test/person.txt");
OBjectOutputStream oos = new ObjectOutPutStream(fos);
oos.write(new Preson("sdhh",15));
oos.close();

读取：
FileInputStream fis =new FileInputStream("/Users/lanou/Desktop/test/person.txt");
    ObjectInputStream ois =new ObjectInputStream(fis);
    //读文件
 Object object = ois.readObject();
 System.out.println(object);
    ois.close();

注意在写的时候要抛出两个异常 FileNotFoundException, IOException，ClassNotFoundException


键盘录入6个学员信息(格式为  张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中

public class demofuxi {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Student> getarraylist = getarraylist();
        write(getarraylist);
        ArrayList<Student> readlist = readlist();
        for (Student student : readlist) {
            System.out.println(student);                                                
        }
        TreeSet<Student> set =new TreeSet<>(new compare());
        set.addAll(readlist);
       readlist.clear();
       readlist.addAll(set);
        write(readlist);
        ArrayList<Student> readlist2 = readlist();
        for (Student student2 : readlist2) {
            System.out.println(student2);
        }
    }

键盘获取集合
    public static ArrayList<Student> getarraylist() {
        ArrayList<Student> list = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        while (list.size() < 6) {
            System.out.println("请输入6个学生信息按 张三,男,25，格式");
            String string = scanner.nextLine();
            try {
                String[] split = string.split(",");
                String name = split[0];
                String gender = split[1];
                int age = Integer.parseInt(split[2]);
                list.add(new Student(name, gender, age));
            } catch (Exception e) {
                System.out.println("输入格式不对");
            }

        }
        return list;
    }

写入
    public static void write(ArrayList<Student> arrayList) throws IOException {
        FileOutputStream fos =new FileOutputStream("/Users/lanou/Desktop/test/person.txt");
        ObjectOutputStream oos =new ObjectOutputStream(fos);
        oos.writeObject(arrayList);
        oos.close();        
    }
读出
    public static ArrayList<Student> readlist() throws IOException, ClassNotFoundException{
        FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/test/person.txt");
        ObjectInputStream ois =new ObjectInputStream(fis);
        ArrayList<Student> studentlist = (ArrayList<Student>)ois.readObject();
        return studentlist;     
    }
}
比较器 按年龄比较
class compare implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.getAge()-o2.getAge();
        return num;
    }

学生类
public class Student implements Serializable{
private String name;
private String gender;
private int age;

public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String name, String gender, int age) {
    super();
    this.name = name;
    this.gender = gender;
    this.age = age;
}

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 int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

@Override
public String toString() {
    return "[name=" + name + ", gender=" + gender + ", age=" + age + "]";
}



@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((gender == null) ? 0 : gender.hashCode());
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Student other = (Student) obj;
    if (age != other.age)
        return false;
    if (gender == null) {
        if (other.gender != null)
            return false;
    } else if (!gender.equals(other.gender))
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

}
“`