JAVA 基础IO流

java.io 包中定义了所有的"流"类

如何分类：

按数据流的方向不同可以分为输入流和输出流，读取文件的时候就是数据流

按处理数据单位不同可以分为字节流和字符流，字节（一个字节）010101读的时候，字符（UNCODE 两个字节）：一个字符一个字符读的时候

按功能不同的可以分为节点流和处理流：个人理解的话，节点流其实就是上面说的直接通过InputStream OutputStream Reader Writer 单类进行读取的，而处理流就是要在正常的读取上进行更一步的细化细分，比如 FileInputStream放到了BufferedInputStream中去这种进行包装之后的就叫做处理流

输入流和输出流：

举个例子，如果一个程序要从文件中读取数据，那么这个流是输入流和输出流？

这个应该是相对的，如果对于程序来说这个肯定是输入流，应该要把文件中的数据输入到自身中，但是对于文件来说，那就是输出流，因为自身的数据被读取出来

重点：以后我们都是站到程序的角度上去理解，所以读取文件就要用输入流！！！

凡事以Stream结尾的类都是字节类InputStream OutputStream，字符流的话一般都是Reader Writer（读取的是两个字节的）

需要注意的是：刚才Stream的话是相对于程序的，但是这里Reader就是相对于文件的，比如读取文件用的就是Reader，所以这样理解！

先看输入流输出流，这里用到的是FileInputStream 和 FileOutputStream，它们继承于InputStream 和 OutputStream类

FileInputStream的如下举例，这里实现了通过FileInputStream对象将文件的内容读取出来，并且通过ByteArrayOutputStream对象来将该流中的内容进行保存，所以如果不想要保存的话其实也可以直接输出，看你自己怎么用了

package com.zpchcbd.stream;

import java.io.*;
import java.util.Arrays;

public class MyFileInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\test.txt");
        }catch (FileNotFoundException e){
            System.out.println(e);
            System.exit(-1);
        }

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        byte[] bytes = new byte[1024];
        int iReadSize = 0;
        try {
            while((iReadSize = fileInputStream.read(bytes)) != -1){
                byteArrayOutputStream.write(bytes,0,iReadSize);
            }
        }catch (IOException e){
            System.out.println(e);
        }
        fileInputStream.close();
        byteArrayOutputStream.close();
        System.out.println(bytes.toString());
    }
}

通过，代码如下：

public class MyFileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\wwww.txt");
        String szBufferContent = "aaaaaaaaaaa";
        fileOutputStream.write(szBufferContent.getBytes());
    }
}

继续看FileReader类，跟流的功能一样，但是唯一的区别就是读取单位的大小不同，Reader、Writer这种一次读取是读两个字节的！！！

public class MyFileReader {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\test.txt");
        char[] chars = new char[1024];
        int iReadSize = 0;
        while((iReadSize = fileReader.read(chars)) != -1){
            System.out.println(chars);
        }
        fileReader.close();
    }
}

那么类似的FileWriter类，实现的代码如下，就直接实现一个简单的通过FileReader和FileWriter实现读写的文件操作：

package com.zpchcbd.stream;

import javax.swing.*;
import java.io.*;

public class MyFileWriter {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\test.txt");
        FileWriter fileWriter = new FileWriter("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\qqqq.txt");
        char[] chars = new char[1024];
        int iReadSize = 0;
        while((iReadSize = fileReader.read(chars)) != -1){
            fileWriter.write(chars);
        }
        fileReader.close();
        fileWriter.close();
    }
}

缓存流

继续讲，关于什么是缓冲流（其实是处理流中的一种，进行了封装） 比如BufferedInputStream类 和 BufferedOutputStream类，这种流就是对基本输入流和输出流的增强，提供了一些新的方法以便于更方便的处理

可以看下这些类的构造方法，如下可以看出它是需要一个普通的输入流和输出流作为支撑的，其实也好理解要不然怎么增强呢，一定是基于某种基础上继续加强

public BufferedInputStream(InputStream in) {
    this(in, DEFAULT_BUFFER_SIZE);
}

实现方法如下，原本想试下，但是发现mark 和 reset函数不见效，那么这里BufferOutputStream其实也是类似的！

public class MyBufferInputStream{
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\wwww.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        int iReadSize = 0;
        byte[] bytes = new byte[1024];
        System.out.println(bufferedInputStream.read());
        System.out.println(bufferedInputStream.read());


        //bufferedInputStream.mark(100);
        while((iReadSize = bufferedInputStream.read(bytes)) != -1){
            byteArrayOutputStream.write(bytes, 0, iReadSize);
        }
        System.out.println(byteArrayOutputStream.toString());
        //bufferedInputStream.reset();
//        while((iReadSize = bufferedInputStream.read(bytes)) != -1){
//            byteArrayOutputStream.write(bytes, 0, iReadSize);
//        }
//        System.out.println(byteArrayOutputStream.toString());
        bufferedInputStream.close();
        byteArrayOutputStream.close();
    }
}

BufferWriter，不同点其实就是读取的字节单位大小，并且还提供了一写好使用的方法，实现的代码如下，这样实现了读取一个字符能够换行的代码！

小提醒：在BufferedReader还提供了一个readline的方法用来读取一行，这里自己就没写了

public class MyBufferedWriter {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\wwww.txt");
        FileWriter fileWriter = new FileWriter("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\asdasd.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        int iReadSize = 0;
        while((iReadSize = bufferedReader.read()) != -1){
            bufferedWriter.write(iReadSize);
            bufferedWriter.newLine();
        }

        bufferedWriter.flush();
        bufferedReader.close();
        bufferedWriter.close();
    }
}

转换流

继续讲，什么是转换流？就是能够实现将字符流与字节流进行相互转换，OutputStreamWriter类 和 InputStreamReader类

OutputStreamWriter类的使用：

例如OutputStream 转换为 Writer来进行写入

public class MyOutputStreamWriter {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\qzczc.txt"));
        outputStreamWriter.write("123123123");
        System.out.println(outputStreamWriter.getEncoding());

        // 扩展：还可以进行追加写入
        outputStreamWriter = new OutputStreamWriter(new FileOutputStream("C:\Users\dell\Desktop\ALL\javaidea\MyFirstTestMaven\javaApp2\servlet1\qzczc.txt", true), "ISO8859_1");
        System.out.println(outputStreamWriter.getEncoding());
        outputStreamWriter.write("321312321");
        outputStreamWriter.close();
    }
}

InputStreamReader类的使用：

public class MyInputStreamReader {
    public static void main(String[] args) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(System.in); // System.in默认是一个输入流，这个System.in输入流当进行接收的时候会堵塞
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader); //能够使用readline方法，更好的测试读取

        String szBuffer;
        szBuffer = bufferedReader.readLine();
        while(szBuffer != null){
            System.out.println(szBuffer);
            szBuffer = bufferedReader.readLine();
        }

        bufferedReader.close();
    }
}

数据流

DataInputStream 和 DataOutputStream 分别继承自 InputStream 和 OutputStream，它们属于处理流，是在InputStream 和 OutputStream类型的节点流是上。

通过它们这两个类可以实现存取与机器无关的Java原始类型数据的方法

唯一需要注意的就是读取的时候是谁先写入先读谁的，那么也就是dataOutputStream中的数据结构是队列！

public class MyDataOutputStream {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
        dataOutputStream.writeBoolean(true);
        dataOutputStream.writeFloat((float) 0.1);


        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream);
        boolean bRet =  dataInputStream.readBoolean();
        System.out.println(bRet);
        float fnum = dataInputStream.readFloat();
        System.out.println(fnum);
    }
}

Print流

PrintWriter PrintInputStream 都属于输出流，分别针对的是字符和字节

1、通过设置系统标准输出的位置，来通过System.out.println来进行写文件

public class MyPrinterStream {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fileOutputStream = new FileOutputStream("./aaa.txt");
        PrintStream printStream = new PrintStream(fileOutputStream);
        System.setOut(printStream);
        System.out.println("aaaaaaaaa");
    }
}

2、通过命令行窗口中输入内容，将内容写入到指定文件中

public class MyPrinterWriter {
    public static void main(String[] args) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(System.in); //这里的System.in 是一个InputStream
        String s = null;

        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        FileWriter fileWriter = new FileWriter("./asd.txt");
        PrintWriter printWriter = new PrintWriter(fileWriter);
        while((s = bufferedReader.readLine()) != null){
            if(s.toLowerCase().equals("exit"))break;
            System.out.println(s);
            printWriter.write(s);
            bufferedReader.readLine();
        }
        printWriter.close();
        bufferedReader.close();
    }
}

Object流

接口为Serializable序列化和反序列化的实现：

public class MyObjectInputStreamAndOutputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream fileOutputStream = new FileOutputStream("./object.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

        T t1 = new T();
        t1.a = 5555;
        objectOutputStream.writeObject(t1);


        FileInputStream fileInputStream = new FileInputStream("./object.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        T t2 = (T)objectInputStream.readObject();
        System.out.println(t2.a);
    }
}


class T implements Serializable{
    public int a=1;
    public float b = (float) 0.1;
    public String c = "123";
}