java中io流、属性集Properties、缓冲流、转换流、序列化和反序列化、打印流、网络编程、TCP通信程、B/S服务案例

IO流：

io流中i表示input输入，o表示output输出，流表示数据（字符，字节，1个字符=2个字节=8个位）；这里的输入输出是以内存为基础，将数据从内存中输出到硬盘的过程称为输出，将数据从硬盘中输入到内存中称为输入，这里的输入和输出就被称为io流；这个数据输入输出有字符和字节，所以又可分为字符流和字节流。

字节流： 一切皆为字节，所有的文件都是以字节为单位存储的，一个字节=8个位，文件的读写是以字节为单位的。无论是什么流，最底层传输还是二进制数据；字节流又分为字节输出流OutputStream和字节输入流InputStream。

OutputSteam输出流： OutputSteam是所有输出流的顶级父类，此类为抽象类，其子类已知有： ByteArrayOutputStream往字节数组中写入数据的字节输出流、FileOutputStream往文件中写数据的字节输出流、FilterOutputStream带过滤器的字节输出流、ObjectOutputStream对象输出流、PipedOutputSream管道流

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class TestOutputStream {
   
    // 1.OutputSteam是一个抽象类，此类定义了一些共性的方法和一些子类，如：FileOutputStream将内存中的数据写入到硬盘中的文件中：
    // 2.FileOutputStream有两个构造方法，分别传入一个字符串或File,表示数据写入的目的地，实际就是一个路径。
    // 3.FileOutputStream的作用：1.创建FileOutputStream对象 2.根据构造方法中的路径创建一个空文件 3.把FileOutputStream对象指向创建好的文件
    // 4.内存写入数据到硬盘的原理：java程序-->jvm虚拟机-->os操作系统-->os调写数据的方法-->把数据写入到文件中
    // 5.字节输出流的使用步骤：1.创建一个FileOutputStream对象，构造方法中传入写入数据文件的目的地（文件或路径）2.调用FileOutputStream对象中的write方法将数据写入到文件 3.释放系统资源（流在使用的过程中占用了一部分内存资源，使用完要释放掉，提高程序的效率,不释放也没关系）
    public static void main(String[] args) throws IOException {
   
        // 1.创建一个FileOutputStream对象
        FileOutputStream fos = new FileOutputStream("D:\\00.java高级\\练习\\javaDemo\\075.OutputStream流\\hello.txt"); // 这个路径可以是相对路径，这里可能会抛出异常，需要处理
        // 2.将数据写入到文件
        fos.write(97); // write会抛出异常，需要处理，这里97表示小写的a，int类型表示的是字节对应的Ascall码值，97对应的字节写入到硬盘中最终是以二进制存储的，任意的文本编辑器在打开文件时都会去查Ascall码表或系统码表（gbk等），把字节转为字符表示。
        fos.write('g'); // 直接写入一个字节，一个字节等于8个比特位（10101010），一个字节的比特位最大值11111111（十六进制FF、十进制255）
        fos.write('中'); // 汉字在这里乱码了，但是还是可以写入的，

        // 一次写入多个字节：1.支持byte数组 2.支持一部分byte数组写入(byte[] b, int off, int length)，b表示byte数组，off表示开始位置，length表示写入数组的长度
        // 如果写的第一个字节是正数（0-127）那么显示的时候会查Ascall表；如果写入的第一个字节是负数，那么第一个字节会和第二个字节组成一个中文，查询系统默认码表（gbk）
        byte[] ls = {
   97,12,99,97,12,99};
        fos.write(ls);
        byte[] ls2 = {
   -97,-12,99};
        fos.write(ls2);
        byte[] lss = {
   97,12,99,97,12,99};
        fos.write(lss,1,2);

        // 写入字符串：利用字符串转byte数组api getByte
        byte[] strls = "你好".getBytes();
        System.out.println(Arrays.toString(strls)); // [-28, -67, -96, -27, -91, -67]
        fos.write(strls);

        // 文件中输出：ag-acac燈cc浣犲ソ，这里看到并没有你好，是因为这里是按utf-8字符编码集，三个字节为一个中文，而gbk中为两个字节为一个中文
        // 3.释放资源：
        fos.close();

        // 4.追加数据：每次执行上面的代码实际都是将源文件覆盖掉的，如果想要在当前文件继续追加数据可以使用两个参数的构造方法FileOutputStream，其中第一个构造方法参数表示目标文件，第二个参数表示是否开启追加：
        FileOutputStream fos2 = new FileOutputStream("D:\\00.java高级\\练习\\javaDemo\\075.OutputStream流\\append.txt", true);
        fos2.write('g');// 每次执行都会追加字符上去
        fos2.write("\r\n".getBytes()); // 换行：win(\r\n)、linux(/n)、mac(/r)
        fos2.write("你好".getBytes());
        fos2.close();
    };
}

InputStream字节输入流: 此类也是io流类的一个子类，它也是抽象的，并且是所有字节输入流的父类，它下面还有一些子类：BufferedInputStream、AudioInputStream读取音频、ByteArrayInputStream读取字节数组、FileInputStream读取文件、DataInputStream、FilterInputStream带过滤器的、read()、OutputStream、PushbackInputStream、ObjectInputStream读取对象的、PipedInputStream管道流、SequenceInputStream处理队列的、StringBufferInputStream读取字符串缓存区

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

public class TestFileInputStream {
   
    public static void main(String[] args) throws IOException {
   
        // 1.FileInputStream文件字节流输入流，将硬盘中文件中的数据读取到内存中，其构造方法中参数表示要读取文件的路径或文件
        // 2.构造方法的作用：1.创建一个FileInputStream对象 2.将FileInputStream对象指定构造方法中要读取的文件
        // 3.读取数据原理：java程序-->jvm-->os-->os读取数据的方法-->读取文件
        // 4.字节输入流的使用步骤：1.创建一个FileInputStream对象,构造方法参数指明文件 2.调用FileInputStream的read方法读取文件 3.调用FileInputStream的close方法释放资源

        // 1.创建FileInputStream对象：
        FileInputStream fis = new FileInputStream("D:\\00.java高级\\练习\\javaDemo\\076.InputStream流\\test.txt");
        int num;
        do {
   
            num = fis.read(); // 2.读取文件中的一个字节并返回，读取到文件末尾返回-1
            System.out.println(num);
            System.out.println((char)num);

            byte[] ls = new byte[2];
            int num2 = fis.read(ls); // read传入一个字节数组时读取字节数组长度的字节并返回给字节数组
            System.out.println(Arrays.toString(ls)); // [0, 0]
            System.out.println(num2);
            System.out.println((char)num2);
            System.out.println("---------------");
        } while (num != -1);
        // 3.释放资源：
        fis.close();
    };
}

文件复制demo:

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

public class CopyFileDemo {
   
    public static void main(String[] args) throws IOException {
   
        // 创建读文件的流：将内存中的数据流输出（读取）,写入到文件中
        FileOutputStream fos = new FileOutputStream("D:\\00.java高级\\练习\\javaDemo\\076.InputStream流\\copy_test.mp4");
        // 创建写文件的流：将文件读取到内存缓存区
        FileInputStream fis = new FileInputStream("D:\\00.java高级\\练习\\javaDemo\\076.InputStream流\\test.mp4");
        // 一读一写实现文件拷贝：
        int bts = 0; // 记录每次读取有效字节个数
        // 循环将硬盘中的文件数据写入内存,如果不指定字节数量，每次都会读取一个字节写入一个字节，这样速度很慢，可以读取多个字节写入多个字节
        byte[] size = new byte[1024 * 50]; // 值越大，速度越快
        // while((bts = fis.read()) != -1) {
   
        while((bts = fis.read(size)) != -1) {
    // 优化读取多个字节
            // 将内存中的流输出到新的文件中：
            // fos.write(bts);
            fos.write(size,0,bts); // 优化写入多个字节
        };
        //释放资源：
        fos.close();
        fis.close();
    };
}

字符流： 字节流读取中文时可能会有显示不全乱码的问题，因为中文占有多个字节存储，为解决这个问题，java提供了字符流类，以字符为单位读写数据，专门用于处理文本文件的Reader类，此类为字符输入流最顶层的类，此类也是一个抽象类，其子类有：BufferedReader缓存流、CharArrayReader字符数组流、FilterReader过滤流、InputStreamReader转换流、PipedReader管道流、StringReader读取字符串流

一个中文如果是GBK编码则占用2个字节，如果是utf-8编码则占用3个字节。

字符输入流： 将硬盘文件中的数据以字符的方式读取到内存中

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReader {
   
    // 1.Reader字符输入流：是字符输入流的最顶层父类，定义了一些共性的成员方法，是一个抽象类
    // 2.共性方法：read()读取单个字符并返回、read(char[] cbuf)一次读取多个字符，将字符读取到数组
    // 3.close()关闭该流并释放与之关联的所