Java I/O流详解与应用（二）

I/O流（二）

一.缓冲流（缓冲区）：

特点：本身没有读写的能力，需要借助普通的读写流进行读写，但可以加快读写的效率

分类：字符缓冲流：BufferedReader（读），BufferedWriter（写）

字节缓冲流：BufferedInputStream（读），BufferedOutputStream（写）

字符缓冲流代码实现文件读写：

public class Test {

    public static void main(String[] args) throws IOException {
       BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\Downloads\\workSpaceCJY\\WorkDemoIO\\c.txt"));
       BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("j.txt")); 

       String num=null;
       while((num = bufferedReader.readLine())!=null) {//缓冲流特有方法，一次读一行
           System.out.println(num);
           bufferedWriter.write(num);
           bufferedWriter.newLine();//缓冲流特有换行方式
           bufferedWriter.flush();
       }
       bufferedReader.close();
       bufferedWriter.close();
    }

}

字节缓冲流

public class Test {

    public static void main(String[] args) throws IOException {
       BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\Downloads\\workSpaceCJY\\WorkDemoIO\\c.txt"));
       BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("j.txt")); 

       int num=0;
       byte[]arr=new byte[10];
       while((num = bufferedInputStream.read(arr))!=-1) {
           System.out.println(new String(arr,0,num));
           bufferedOutputStream.write(arr);

           bufferedOutputStream.flush();
       }
       bufferedInputStream.close();
       bufferedOutputStream.close();
    }

}

LineNumberReader（父类是BufferedReader）：可以设置行号

       LineNumberReader lineNumberReader = new LineNumberReader(new FileReader("D:\\Downloads\\workSpaceCJY\\WorkDemoIO\\c.txt"));
       lineNumberReader.setLineNumber(0);

       int num = 0 ;
       char[]arr = new char[10];
       while((num=lineNumberReader.read(arr))!=-1) {
           System.out.println(new String(arr,0,num));
       }

二. 标准输入流:默认是将数据从控制台写入内存，接收的是键盘敲入的数据

标准输出流:默认是将数据从内存写入控制台

//实例：从键盘不断的接收，一次接收一行

public static void main(String[] args) throws IOException {
        InputStream in = System.in;// 这里可以直接得到标准输入流的对象，并与键盘绑定，可以直接从键盘接收数据，标准输入流是字节流
        // int num = in.read();//称为阻塞式的方法 特点是一直等待用户输入

        StringBuffer buffer = new StringBuffer();
        while (true) {
            int num = in.read();// 读一个字节

            if (num == '\r') {
                continue;
            } else if (num == '\n') {
                // over字符串作为停止的表示
                if (buffer.toString().equals("over")) {
                    break;
                }
                System.out.println(buffer.toString());
                // 清空
                buffer.delete(0, buffer.length());
            } else {
                buffer.append(num);
            }

        }

    }

三.转化流：

作用：将字节流转化成字符流

分类：输入转化流：InputStreamReader

输出转化流：OutputStreamWriter

public static void main(String[] args) throws IOException {
        // 分析：刚才实现的功能类似于BufferedReader里面的readLine(),现在的标准输入流是字节流，要想使用readLine(),就将字节流转换成字符流

        //  1.获取标准输入流
        // InputStream in = System.in;
        //  2.通过转化流，转成字符流
        // InputStreamReader is = new InputStreamReader(in);
        //  3.得到缓冲流
        // BufferedReader br = new BufferedReader(is);

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //  4.获取标准输出流 PrintStream:打印流，是输出标准的一种
        // PrintStream pr = System.out;
        //  5.通过转化流，转成字符流
        // OutputStreamWriter osw = new OutputStreamWriter(pr);
        //  6.得到字符缓冲写出流
        // BufferedWriter bw = new BufferedWriter(osw);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        // 7.进行读写（读一行，写一行）
        String data = null;
        while ((data = br.readLine()) != null) {
            bw.write(data);
            bw.newLine();// 换行
            bw.flush();// 因为没执行到close所以单独加个刷新

            // 将over字符串作为结束的标记
            if (data.equals("over")) {
                break;
            }
        }

        br.close();
        bw.close();

    }

四.打印流

特点：除了拥有流的特点之外，还有打印的功能

分类：字节打印流：PrintStream（直接支持的设备：File类型的文件，字符串类型的文件，字节输出流）

字符打印流：PrintWriter（直接支持的设备：File类型的文件，字符串类型的文件，字节输出流，字符输出流）

//File类型的文件
// new PrintStream(new File("D\\下载\\AV\\H.txt"));
//字符串类型
//new PrintStream("D.txt");
//字节输出流
//new PrintStream(FileOutputStream("H.txt"));

PrintStream p = new PrintStream("C.txt");
p.write(97);
p.write(353);
p.write(String.valueOf(353).getBytes());
p.close

//1.File类型的文件
//new PrintWriter(new File(""));
//2.字符串类型的文件
//new PrintWriter("temp1.txt");
//3.字节输出流
//new PrintWriter(new FileOutputStream("temp1.txt"));
//4.字符输出流
//new PrintWriter(new FileWriter("temp1.txt"));

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

PrintWriter printWriter = new PrintWriter(System.out);

String data = null;
while ((data = bufferedReader.readLine()) != null) {
            printWriter.write(data);
            printWriter.write("\r\n");
            printWriter.flush();
        }
bufferedReader.close();
printWriter.close();

五.序列化流和反序列化流

序列化流：将数据从内存存储到磁盘中的过程，数据可以长久的保存

反序列化流：将数据从磁盘取出，放入内存的过程

序列化的作用：主要是实现数据的长久存储（数据持久化）

实现序列化的流：ObjectOutputStream

实现反序列化的流：ObjectInputStream

注意：序列化流和反序列化流都要通过对应的流实现读写

public class Test1 {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {

        // 完成序列化-写出
        // writeFile();
        // 完成序列化-读入
        readFile();
    }

    public static void writeFile() throws FileNotFoundException, IOException {
        // 创建序列化流对象并关联对象流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ObjectFile"));
        // objectOutputStream.writeInt(4);
        // 调用方法实现序列化:序列化的内容不能直接查看（中文乱码），要想查看内容必须进行反序列化
        objectOutputStream.writeObject(new Person("bingbing", 11));
        // 关闭流
        objectOutputStream.close();

    }

    public static void readFile() throws FileNotFoundException, IOException, ClassNotFoundException {

        // 创建反序列化流对象并关联对象流
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ObjectFile"));
        Object object = inputStream.readObject();
        System.out.println(object);
        inputStream.close();
    }

}

六.随机流

定义：随机流又叫随机访问流，不属于IO体系，只能操作文件，内部既有字节输入流，也有字节输出流（同一个对象）

原理：在随机流内部有一个大的字节数组，可以通过指针进行操控，当我们进行随机访问时，让指针指向对应的字节，就可以从当前字节开始读或写

//随机流
public class Test {
    public static void main(String[] args) throws IOException {
        // 写
        // writeFile();
        // 读
        readFile();
    }

    // 写
    public static void writeFile() throws IOException {
        // 1.创建随机访问流对象并关联文件
        RandomAccessFile accessFile = new RandomAccessFile("data.txt", "rw");// mode指定当前对象的可操作模式：read只读,write只写,readwrite读写

        // 验证读
        // byte[]arr = new byte[50];
        // accessFile.read(arr);
        // System.out.println(new String(arr));

        // 2.写
        accessFile.write("bingbing".getBytes());// 8个字节
        accessFile.writeInt(97);// 4个字节
        accessFile.write(97);// 1个字节

        // 获取当前的所有字节数(获取当前文件指针的位置)
        System.out.println(accessFile.getFilePointer());// 13
        // 要求：从第十六个字节开始写内容:seek(16);参数代表当前指针指向的位置（默认指向文件的最后一个字节）
        accessFile.seek(16);
        accessFile.write(100);// 4个字节
        System.out.println(accessFile.getFilePointer());//

        accessFile.close();

    }

    // 读
    public static void readFile() throws IOException {
        RandomAccessFile accessFile = new RandomAccessFile("data.txt", "rw");

        // 要求只读bingbing，指针指向了15
        accessFile.seek(15);
        // 验证读
        byte[] arr = new byte[50];
        accessFile.read(arr);
        System.out.println(new String(arr));

        accessFile.close();
    }
}