[Java]IO流（二）

缓冲流：

缓冲流自带缓冲区，可以提高原始字节流，字符流读写数据的性能。

 每次读数据时自动加载部分数据到内存中，这样就可以在内存中读写这些数据，不需要与文件对接。

缓冲字节输入输出流： 

  与之前的原始流用法一样：

package wryyyyy;

import java.io.*;

public class IODemo
{
    public static void main(String[] args) throws IOException
    {
        try (
            //创建一个字节输入流管道与原文件接通
            InputStream is = new FileInputStream("src/data02.txt");
            //把原始的字节输入流包装成高级的缓冲字节输入流
            InputStream bis = new BufferedInputStream(is);
            //创建一个字节输出流管道与目标文件接通
            OutputStream os = new FileOutputStream("src/data03.txt");
            //把字节输出流管道包装成高级的缓冲字节输出流管道
            OutputStream bos = new BufferedOutputStream(os);
        )//资源放在（）里面，不需要释放资源
        {
            byte[] buffer = new byte[1024];
            int len;
            while ((len=bis.read(buffer))!=-1)
            {
                bos.write(buffer,0,len);
            }
            System.out.println("复制完成！");
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

 字符缓冲输入流：

package wryyyyy;

import java.io.*;

public class IODemo
{
    public static void main(String[] args) throws IOException
    {
        try(
                Reader fr = new FileReader("src/data03.txt");
                //包装
                //由于增加了独有功能，不能用多态写了
                BufferedReader br = new BufferedReader(fr);
                )
        {
//            char[] buffer = new char[1024];
//            int len;
//            while ((len=br.read(buffer))!=-1)
//            {
//                String rs = new String(buffer,0,len);
//                System.out.println(rs);
//            }
            //新增功能：可以按行读
            System.out.println(br.readLine());//如果空行下面没有行就读不到，如果没有行就为null
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }
    }
}

  字符缓冲输入流：

多出来了一个newline换行功能

案例：文件内容排序，并拷贝的新文件中去：

package wryyyyy;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class IODemo
{
    public static void main(String[] args) throws IOException
    {
        try(
                //1.创建字符缓冲输入流与原文件接通
                BufferedReader br = new BufferedReader(new FileReader("src/data02.txt"));
                //5.定义缓冲字符输出管道与目标文件接通
                BufferedWriter bw = new BufferedWriter(new FileWriter("src/data03.txt"));
                )
        {
            //2.定义一个List集合存储每行内容
            List<String> data= new ArrayList<>();
            //3.定义循环按行读取文章
            String line;
            while ((line=br.readLine())!=null)
            {
                data.add(line);
            }
            System.out.println(data);
            //4.排序
            List<String> sizes = new ArrayList<>();
            Collections.addAll(sizes,"A","B","C","D","E","F","H","I","G");//下一步，提取这些字符作为索比较大小
            Collections.sort(data, new Comparator<String>()
            {
                @Override
                public int compare(String o1, String o2) //自定义排序规则
                {


                    return sizes.indexOf(o1.substring(0,o1.indexOf(".")))-sizes.indexOf(o2.substring(0,o2.indexOf(".")));
                }
            });
            System.out.println(data);
            //6.遍历集合元素写到新文件中去，并且要换行
            for (String datum : data)
            {
                bw.write(datum);
                bw.newLine();//换行
            }
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

序列化：

对象序列化：

以内存为基准，把内存中的对象存的磁盘文件中去。

package wryyyyy;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class IODemo
{
    public static void main(String[] args) throws IOException
    {
        //创建学生对象
        Student s = new Student("小王","xiaowang","114514",21);

        //对象序列化，使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/data.txt"));

        //直接调用序列化方法
        oos.writeObject(s);

        //释放资源
        oos.close();
    }
}

package wryyyyy;

/*
* 对象如果要序列化，必须实现Serializable接口
* */

import java.io.Serializable;

public class Student implements Serializable
{
    //省略
}

 对象反序列化：

package wryyyyy;

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

public class IODemo1
{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建对象字节输入流管道包装低级的字节输入流管道
        ObjectInputStream is = new ObjectInputStream(new FileInputStream("src/data.txt"));

        //2.调用对象字节输入流的反序列化方法
        Student s = (Student)is.readObject();
        System.out.println(s);
    }
}

如果想要某个成员变量不参与序列化，在前面加上transient

private transient String loginName;

声明序列化版本号：

序列化版本号与反序列化的必须一致。

（加上这个之后要先序列化在反序列化，不能直接序列化）

private static final long serialVersionUID = 1;

打印流：

打印数据到文件中。

PrintStream：

PrintStream ps = new PrintStream(new FileOutputStream("src/data.txt"));
ps.println(97);
ps.println('a');
ps.println("qwerty");
ps.println(true);//是什么就打印什么
ps.flush();
ps.close();
        

PrintWriter： 

 输出语句的重定向：

属于打印流的一种应用，可以把输出语句的位置改到文件。（之前的输出语句是打印到控制台）