JAVA IO流，以代码的形式解读

import java.io.*;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.stream.IntStream;

public class mainTest {

    //RandomAccessFile查一下
    public static void main(String[] args) throws Exception{
        //FileInputStream,读取byte[]，返回readLine
        //method_01();

private static void method_01(){
    new Thread(()->{
        try {
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\10167\\Desktop\\c.txt");
            byte[] bytes = new byte[1024];
            int readLine = fileInputStream.read(bytes);
            while (readLine!=-1){
                System.out.println(new String(bytes,0,readLine));
                readLine = fileInputStream.read(bytes);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

        //FileOutputStream，写入byte[]
        //method_02();

private static void method_02(){
    new Thread(()->{
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\10167\\Desktop\\c.txt");

            fileOutputStream.write("杨长辉是最棒的".getBytes());
            fileOutputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

        //FileReader，读取char[],返回readLine
        //method_03();

private static void method_03(){
    new Thread(()->{
        try {
            FileReader reader = new FileReader("C:\\Users\\10167\\Desktop\\c.txt");
            char[] chars = new char[1024];
            int readLine = reader.read(chars);
            while (readLine != -1){
                System.out.println(new String(chars,0,readLine));
                readLine = reader.read(chars);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

        //FileWriter，可写入char[]和String
        //mehtod_04();

private static void mehtod_04(){
    new Thread(()->{
        try {
            FileWriter fileWriter = new FileWriter("C:\\Users\\10167\\Desktop\\c.txt");
            String newString = "不要放弃，坚持下去";
            fileWriter.write(newString);
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

        //PrintStream，可写入任何数据类型，非常好用，就是没有字节流
        //method_05();

private static void method_05(){
    new Thread(()->{
        try {
            PrintStream printStream = new PrintStream(new FileOutputStream(new File("C:\\Users\\10167\\Desktop\\c.txt")));
            printStream.print("你是最棒的！！！！");
            printStream.println(new char[]{'你','好'});
            printStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }).start();
}

        //PrintWriter，可写入任何数据，非常好用，就是没有字节流
        //method_06();

private static void method_06(){
    new Thread(()->{
        try {
            PrintWriter printWriter = new PrintWriter(new FileOutputStream(new File("C:\\Users\\10167\\Desktop\\c.txt")));
            printWriter.print("你才是最棒的");
            printWriter.append('啊');
            printWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }).start();
}

        //Scanner,可读取文件，也可读取键盘
        //method_07();

private static void method_07(){
    new Thread(()->{
        //Scanner scanner = new Scanner(new File(""));
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        System.out.println(s);
    }).start();
}

        //StringReader，读取String，转化为char[]
        //method_08();

private static void method_08(){
    new Thread(()->{
        String s = "天王盖地虎\n小鸡炖蘑菇\n";
        StringReader stringReader = new StringReader(s);
        char[] chars = new char[4];
        try {
            int readLine = stringReader.read(chars);
            while (readLine!=-1){
                System.out.println(new String(chars,0,readLine));
                readLine = stringReader.read(chars);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

        //StringWriter：写入String，可以动态的增加，里面内置的是StringBuffer，不是新创建的String
        //method_09();

private static void method_09(){
    new Thread(()->{
        //StringBuffer stringBuffer = new StringBuffer(100);
        StringWriter stringWriter = new StringWriter();
        stringWriter.write("你好世界");
        System.out.println(stringWriter);
        stringWriter.append("你到底好不好？啊，回答我！！！");
        System.out.println(stringWriter);
    }).start();
}

        //InputStreamReader是从byte转成char的桥梁,BufferedReader()是char类型输入的包装类，可以读取System.in和Socket.getInputStream的输入流，非常好用
        //BufferReader
        //method_10();

private static void method_10(){
    new Thread(()->{
        InputStreamReader inputStreamReader = new InputStreamReader(System.in);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String s = null;
        try {
            s = bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(s);
    }).start();
}

        //跟上面的类似，只不过一个是读取，一个是写入
        //method_11();

    private static void method_11() throws InterruptedException {
        Thread thread1 = new Thread(){
            @Override
            public void run() {
                try {
                    ServerSocket serverSocket = new ServerSocket(8088);
                    Socket accept = serverSocket.accept();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
/*                    char[] chars = new char[1024];
                    int read = bufferedReader.read(chars);
                    while (read!=-1){
                        System.out.println(new String(chars,0,read));
                        read = bufferedReader.read(chars);
                    }*/
                    String s = bufferedReader.readLine();
                    System.out.println(s);

                    accept.close();
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread2 = new Thread(){
            @Override
            public void run() {
                try {
                    Socket socket = new Socket("127.0.0.1",8088);
                    BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                    bufferedWriter.write("客户端，你是我儿子");
                    bufferedWriter.flush();
                    bufferedWriter.write("客户端，你是我儿子2");
                    bufferedWriter.flush();
                    bufferedWriter.write("客户端，你是我儿子3");
                    bufferedWriter.flush();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        thread1.start();
        Thread.sleep(10);
        thread2.start();
    }

        // BufferedInputStream/BufferedOutputStream,读取，写入
        method_12();

private static void method_12() throws IOException {
    BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\Users\\10167\\Desktop\\c.txt"));
    byte[] bytes = new byte[1024];
    int readLine = bufferedInputStream.read(bytes);
    while (readLine!=-1){
        System.out.println(new String(bytes,0,readLine));
        readLine = bufferedInputStream.read(bytes);
    }
}

    }

}