JavaSe:IO

IO流原理及流的分类

原理

1.I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

2.Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。

3.java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中

流的分类

1.按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)

2.按数据流的流向不同分为：输入流，输出流

3.按流的角色的不同分为：节点流，处理流

字节流通常处理非文本文件

字符流通常用来处理文本文件

1.Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。

2.由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

流的体系结构：

抽象基类	节点流（或文件流)	缓冲流（处理流的一种）
InputStream	FileInputStream	BufferedInputStream
outputStream	FiLeoutputStream	BufferedOutputStream
Reader	FiLeReader	BufferedReader
writer	Filewriter	Bufferedwriter

节点流和处理流

==节点流==：直接从数据源或目的地读写数据
==处理流==：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

@Test
void t1() {
	//1.实例化File 对象，指明要操作的文件
    File file = new File("helloJavaIO.txt");
    //2.提供具体的流
    FileReader fr = null;
    try {
        fr = new FileReader(file);
        //3.数据的读入
        //read() 返回读入的字符，如果到达文件末尾，返回-1
        int data;
        while ((data = fr.read()) != -1) { //此处的read类似于Iterator的 next() 会默认向下，读取下一个字符。
            System.out.print((char) data);
        }
        fr.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        System.out.println("找不到文件! ");
    } catch (IOException e) {
        e.printStackTrace();
        System.out.println("读取字符失败! ");
    }
}

1️⃣节点流(或文件流)

🍅读取文件

1.建立一个流对象，将已存在的一个文件加载进流。

`FileReader fr = new FileReader(new File(“Test.txt”));`

2.创建一个临时存放数据的数组。

char[] ch = new char[1024];

3.调用流对象的读取方法将流中的数据读入到数组中。

 `fr.read(ch);`

4.关闭资源。

`fr.close();`

🍅写入文件

1.创建流对象，建立数据存放文件

`FileWriter fw = new FileWriter(new File(“Test.txt”));`

2.调用流对象的写入方法，将数据写入流

`fw.write(“atguigu-songhongkang”);`

3.关闭流资源，并将流中的数据清空到文件中。

` fw.close();`

1.InputStream & Reader

InputStream 和 Reader 是所有输入流的基类。

==InputStream==（典型实现：FileInputStream）

int read()
int read(byte[] b)
int read(byte[] b, int off, int len)

==Reader==（典型实现：FileReader）

int read()
int read(char [] c)
int read(char [] c, int off, int len)

程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。

FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取非文本数据之类的原始字节流。要读取字符流，需要使用 FileReader

🌳InputStream

**int read()**从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。

**int read(byte[] b)**从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。

**int read(byte[] b, int off,int len)**将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。

public void close() throws IOException关闭此输入流并释放与该流关联的所有系统资源。

🌳Reader

**int read()**读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回 -1

**int read(char[] cbuf)**将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。

**int read(char[] cbuf,int off,int len)**将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。

public void close() throws IOException关闭此输入流并释放与该流关联的所有系统资源

package pers.dhx_.java0620;

import org.junit.jupiter.api.Test;

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

/**
 * @author Dhx_
 * @className FileReaderWriterTest
 * @description TODO
 * @date 2022/6/20 16:16
 */
public class FileReaderWriterTest {
    @Test
    void t1() {//read() 空参,每次读取一个字符
        //1.实例化File 对象，指明要操作的文件
        File file = new File("helloJavaIO.txt");
        //2.提供具体的流
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            //3.数据的读入
            //read() 返回读入的字符，如果到达文件末尾，返回-1
            int data;
            while ((data = fr.read()) != -1) { //此处的read类似于Iterator的 next() 会默认向下，读取下一个字符。
                System.out.print((char) data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到文件! ");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取字符失败! ");
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //d对于read ：使用read的重载方法，读取多个字符
    @Test
    void t2() {
        //keypoint
        // 1.File类的实例化
        File file = new File("helloJavaIO.txt");

        // 2.FileReader的实例化     // 区别主要是 二三步 的区别
        FileReader fr = null;
        try {
            fr = new FileReader(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        // 3.读入的操作
        char[] cbuf = new char[5];
        //keypoint
        // fr.read(cbuf); 返回每次读入cbuf数组中的字符的个数 ，如果达到末尾，返回-1

        int len = 0, cnt = 1;
        try {
            while (((len = fr.read(cbuf)) != -1)) {
                System.out.println("第 " + cnt++ + "次 : 字符数量" + len);
                for (int i = 0; i < len; i++) {
//注意这个地方必须是i <len ，因为上一次读取 并赋值给cbuf的字符没有清空
                    System.out.println(cbuf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 4. 资源的关闭
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
//文件内容：464gs57yh65yuh556bbvfghe54yh
/*
		第 1次 : 字符数量5
		464gs
        第 2次 : 字符数量5
        57yh6
        第 3次 : 字符数量5
        5yuh5
        第 4次 : 字符数量5
        56bbv
        第 5次 : 字符数量5
        fghe5
        第 6次 : 字符数量3
        4yh
*/
    }

}

2.OutputStream & Writer

1.OutputStream 和 Writer 也非常相似：

**void write(**int b / int c);

**void write(**byte[] b/char[] cbuf);

**void write(**byte[] b/char[] buff, int off, int len);

void flush();

void close(); 需要先刷新，再关闭此流

2.因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数

void write(String str);

void write(String str, int off, int len);

3.FileOutputStream 从文件系统中的某个文件中获得输出字节.FileOutputStream ==用于写出非文本数据之类的原始字节流==。要写出字符流，需要使用 FileWriter

💃OutputStream

**void write(int b)**将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。即写入0~255范围的。

**void write(byte[] b)**将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。

**void write(byte[] b,int off,int len)**将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

public void flush()throws IOException刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。

public void close() throws IOException关闭此输出流并释放与该流关联的所有系统资源。

💃Writer

==对于文件的写入：==

实际代码过程中发现如果不关闭流资源，就无法完成正常的文件写入、

注意不弄使用字符流处理字节流数据（图片、视频等）。

如果文件不存在会自动创建

如果存在就看FileWriter的构造器是用的哪个

如果用的构造器是FileWriter(file,false) 或者 FileWriter(file)，就会覆盖原有的文件。
如果用的构造器是FileWriter(file,true) ，就会再原有的文件基础上追加内容。

**void write(int c)**写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。即写入0 到 65535 之间的Unicode码。

**void write(char[] cbuf)**写入字符数组。

**void write(char[] cbuf,int off,int len)**写入字符数组的某一部分。从off开始，写入len个字符。

**void write(String str)**写入字符串。

**void write(String str,int off,int len)**写入字符串的某一部分。

**void flush()**刷新该流的缓冲，则立即将它们写入预期目标。

public void close() throws IOException关闭此输出流并释放与该流关联的所有系统资源。

@Test
void t1() throws IOException {
    File file = new File("FileWriter_.txt");

    FileWriter fw = new FileWriter(file);
    //文件不存在的话会自动创建
    fw.write(1);
    fw.write('5');
    fw.write("5345!@%$%I_534g435_");
    fw.close();
}

package pers.dhx_.java0620;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author Dhx_
 * @className FIleInputStreamTest
 * @description TODO
 * @date 2022/6/22 9:54
 */
public class FIleInputStreamTest {
    @Test
    void t1() {
        //造文件
        File file = new File("helloJavaIO.txt");
        //2.造 流
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            //3.读数据
            byte[] buffer = new byte[5];
            int len;// 每次读取的字节数
            while ((len = fis.read(buffer)) != -1) {
                String s = new String(buffer, 0, len);
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    @Test
    void t2() {// .jpg 复制
        File srcFile = new File("$QCA4KG1[{ZH9GYHMP%5%C0.jpg");
        File DesFile = new File("$picture.jpg");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(DesFile);
            byte[] buffer = new byte[256];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void copyFile(String srcPath, String desPath) {// 非文本File复制
        File srcFile = new File(srcPath);
        File desFile = new File(desPath);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(desFile);
            byte[] buffer = new byte[8196];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
//                for (int i = 0; i < len; i++)
//                    System.out.print(buffer[i]);
//                System.out.println();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    @Test
    void copyFileTest() { //测试使用的时间
        long start = System.currentTimeMillis();
        copyFile("C:\\Users\\lenovo\\Videos\\test.mkv", "C:\\Users\\lenovo\\Desktop\\JavaIOFileInputStream_Test.mkv");
        long end = System.currentTimeMillis();
        System.out.println("复制文件耗时 " + (end - start) + " ms");
    }

}

总结

1.定义文件路径时，注意：可以用“/”或者“\”。

2.在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。

3.如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。

4.在读取文件时，必须保证该文件已存在，否则报异常。

5.字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt

6.字符流操作字符，只能操作普通文本文件。最常见的文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。

2️⃣缓冲流

==为了提高数据读写的速度==，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。

![image-20220622103632903](C:\Users\lenovo\Desktop\Java\SUMMER_JAVA\JavaSe _Note\image\image-20220622103632903.png)

缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

BufferedInputStream
BufferedOutputStream

BufferedReader

BufferedWriter

细节

1.当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区

2.当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。

3.向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流

4.关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流

5.flush()方法的使用：手动将buffer中内容写入文件

6.如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

void t1() {
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
        // 创建缓冲流对象：它是处理流，是对节点流的包装
        br = new BufferedReader(new FileReader("d:\\IOTest\\source.txt"));
        bw = new BufferedWriter(new FileWriter("d:\\IOTest\\dest.txt"));
        String str;
        while ((str = br.readLine()) != null) { 
            // 一次读取字符文本文件的一行字符
            bw.write(str); // 一次写入一行字符串
            bw.newLine(); // 写入行分隔符
        }
        bw.flush(); // 刷新缓冲区
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 关闭IO流对象
        try {
            if (bw != null) {
                bw.close(); 
                // 关闭过滤流时,会自动关闭它所包装的底层节点流
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

🍅使用缓冲流复制非文本文件

package pers.dhx_.java0620;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author Dhx_
 * @className BufferInputStreamTest
 * @description TODO
 * @date 2022/6/22 10:39
 */
public class BufferInputStreamTest {
    @Test
    void t1() throws Exception {
        long start = System.currentTimeMillis();

        File srcFile = new File("C:\\Users\\lenovo\\Videos\\test.mkv");
        File desFile = new File("C:\\Users\\lenovo\\Desktop\\test.mkv");
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //读取
        byte[] buffer = new byte[56];
        int len;
        while ((len = bis.read(buffer)) != -1) {
            //写入
            bos.write(buffer, 0, len);

        }
        //资源关闭 ：先关闭外层的流，再关闭内层的流
        //keypoint
        // 关闭外层流的同时 ，内层六也会同时关闭
        bis.close();
        bos.close();
        fis.close();
        fos.close();
        long end = System.currentTimeMillis();
        System.out.println("复制文件耗时 " + (end - start) + " ms");
    }
}

⭕使用缓冲流复制文本文件

@Test
void t2() throws Exception {//非文本文件
    long start = System.currentTimeMillis();

    File srcFile = new File("helloJavaIO.txt");
    File desFile = new File("C:\\Users\\lenovo\\Desktop\\test.txt");
    FileReader fis = new FileReader(srcFile);
    FileWriter fos = new FileWriter(desFile);
    BufferedReader br = new BufferedReader(fis);
    BufferedWriter bw = new BufferedWriter(fos);
    //读取
    //        方式一 char[]
    //        char[] cbuf = new char[1024];
    //        int len;
    //        while ((len = br.read(cbuf)) != -1) {
    //            //写入
    //            bw.write(cbuf, 0, len);
    //        }
    //方式二 ： String  readLine()
    //keypoint
    // 读取一行 的数据， 不包含换行
    String data = "";
    while ((data = br.readLine()) != null) {
        bw.write(data + '\n');
        /*keypoint
             * 或者
             * bw.writr(data);
             * bw.newLine(); 换行
             */
    }
    //资源关闭 ：先关闭外层的流，再关闭内层的流
    //keypoint
    // 关闭外层流的同时 ，内层六也会同时关闭
    br.close();
    bw.close();
    long end = System.currentTimeMillis();
    System.out.println("复制文件耗时 " + (end - start) + " ms");
}

练习

package pers.dhx_.java0620.pictureTest;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Dhx_
 * @className PicTest
 * @description TODO
 * @date 2022/6/22 11:29
 */
public class PicTest {
    @Test
    void t1() throws Exception { //图品加密
        FileInputStream fis = new FileInputStream("$picture.jpg");
        FileOutputStream fos = new FileOutputStream("Secret_picture.jpg");
        byte[] buffer = new byte[48];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            for (int i = 0; i < len; i++) {
                buffer[i] ^= 5;
            }
            fos.write(buffer, 0, len);
        }
        fis.close();
        fos.close();
    }

    @Test
    void t2() throws Exception { //图片解密
        FileInputStream fis = new FileInputStream("Picture/Secret_picture.jpg");
        FileOutputStream fos = new FileOutputStream("Picture/decrypt_Secret_picture.jpg");
        byte[] buffer = new byte[48];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            for (int i = 0; i < len; i++) {
                buffer[i] ^= 5; // a==((a^b)^b);
            }
            fos.write(buffer, 0, len);
        }
        fis.close();
        fos.close();
    }

    @Test
    void t3() { //获取文本中每一个字符出现的个数  利用Map
        Map<Character, Integer> map = new HashMap<>();
        File srcFile = new File("Txt/FileWriter_.txt");
        FileReader fr = null;
        try {
            fr = new FileReader(srcFile);
            int c;
            while ((c = fr.read()) != -1) {
                char ch = (char) c;
                if (map.containsKey(ch)) {
                    Integer cnt = map.get(ch);
                    map.put(ch, cnt + 1);
                } else {
                    map.put(ch, 1);
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        System.out.println(map);
    }
}

3️⃣转换流

转换流提供了在字节流和字符流之间的转换

Java API提供了两个转换流：

InputStreamReader：将InputStream转换为Reader

OutputStreamWriter：将Writer转换为OutputStream

==字节流中的数据都是字符时，转成字符流操作更高效。==

很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

InputStreamReader

实现将==字节的输入流==按指定字符集转换为字符的输入流。

需要和InputStream“套接”。

构造器

public InputStreamReader(InputStream in)

public InputSreamReader(InputStream in,String charsetName)

==charsetName 为指定字符集==

如： Reader isr = new InputStreamReader(System.in,”gbk”);

OutputStreamWriter

实现将==字符的输出流==按指定字符集转换为==字节的输出流==。

需要和OutputStream“套接”。

理解：

构造器

public OutputStreamWriter(OutputStream out)

public OutputSreamWriter(OutputStream out,String charsetName)

@Test
public void testMyInput() throws Exception {
    FileInputStream fis = new FileInputStream("dbcp.txt");
    FileOutputStream fos = new FileOutputStream("dbcp5.txt");
    InputStreamReader isr = new InputStreamReader(fis, "GBK");
    OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
    BufferedReader br = new BufferedReader(isr);
    BufferedWriter bw = new BufferedWriter(osw);
    String str = null;
    while ((str = br.readLine()) != null) {
        bw.write(str);
        bw.newLine();
        bw.flush();
    }
    bw.close();
    br.close();
}

package pers.dhx_.java0620;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author Dhx_
 * @className InputStreamReaderTest
 * @description TODO
 * @date 2022/6/22 14:24
 */
public class InputStreamReaderTest {
    @Test
    void t1() throws Exception { //转换流读文件
        FileInputStream fis = new FileInputStream("Txt\\FileWriter_.txt");
        /*keypoint
         *  参数2 指明了字符集，取决于文件保存时使用的字符集*/
        InputStreamReader isr = new InputStreamReader(fis, "Utf-8");
        char[] cbuf = new char[10];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            String s = new String(cbuf, 0, len);
            System.out.println(s);
        }
        isr.close();
    }

    @Test
    void t2() throws Exception {
        File srcFile = new File("Txt\\FileWriter_.txt");
        File desFile = new File("Txt\\OutputStreamWriterTest.txt");
        /*keypoint
         *  参数2 指明了字符集，取决于文件保存时使用的字符集*/
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);
        InputStreamReader isr = new InputStreamReader(fis);//使用默认字符集
        OutputStreamWriter osr = new OutputStreamWriter(fos, "gbk");
        char[] cbuf = new char[25];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            osr.write(cbuf, 0, len);
        }
        isr.close();
        osr.close();
    }
}

⭐：字符编码

计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。

这就是编码表。

常见的编码表

ASCII

美国标准信息交换码。用一个字节的7位可以表示。

ISO8859-1

拉丁码表。欧洲码表用一个字节的8位表示。

GB2312

中国的中文编码表。最多两个字节编码所有字符

GBK

中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码

Unicode

国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。

UTF-8

变长的编码方式，可用1-4个字节来表示一个字符。

1.Unicode不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别Unicode和ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？第三个，如果和GBK等双字节编码方式一样，用最高位是1或0表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode在很长一段时间内无法推广，直到互联网的出现。

2.面向传输的众多 UTF（UCS Transfer Format）标准出现了，顾名思义，UTF- 8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。

3.Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。

编码：字符串(看得懂的)–>字节数组

解码：字节数组（看不懂的）–>字符串

转换流的编码应用

可以将字符按指定编码格式存储
可以对文本数据按指定编码格式来解读
指定编码表的动作由构造器完成

4️⃣标准输入、输出流( 了解 )

System.in: InputStream

System.java

1	public static final InputStream in = null;

System.in和System.out分别代表了系统标准的输入和输出设备
默认输入设备是：键盘，输出设备是：显示器
System.in的类型是InputStream
System.out的类型是PrintStream，其是OutputStream的子类

FilterOutputStream 的子类

重定向：通过System类的setIn，setOut方法对默认设备进行改变。

public static void setIn(InputStream in)

public static void setOut(PrintStream out)

⭕从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

package pers.dhx_.java0620.System;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author Dhx_
 * @className inTest
 * @description TODO
 * @date 2022/6/22 15:08
 */
public class inTest {
    public static void main(String[] args) throws IOException {
//方法1 ，使用 Scanner 实现
//方法2 ，使用 System.in实现，
//System.in---> 转换流 ---> BufferedReader 的readLine()
        InputStreamReader isr = new InputStreamReader(System.in, "gbk");
        BufferedReader br = new BufferedReader(isr);
        while (true) {
            String s = br.readLine();
            if (s.equalsIgnoreCase("e") || s.equalsIgnoreCase("exit")) {
                System.out.println("程序结束");
                break;
            }
            String upperCase = s.toUpperCase();
            System.out.println(upperCase);
        }
    }
}

System.out.println("请输入信息(退出输入e或exit):");
// 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
while ((s = br.readLine()) != null) { // 读取用户输入的一行数据 --> 阻塞程序
if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
System.out.println("安全退出!!");
break; }
// 将读取到的整行字符串转成大写输出
System.out.println("-->:" + s.toUpperCase());
System.out.println("继续输入信息");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流
}
} catch (IOException e) {
e.printStackTrace();
} }

5️⃣打印流

实现将基本数据类型的数据格式转化为字符串输出

打印流：PrintStream和PrintWriter

提供了一系列重载的print()和println()方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出IOException异常
PrintStream和PrintWriter有自动flush功能
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
System.out返回的是PrintStream的实例

6️⃣数据流

为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。数据流有两个类：(用于读取和写出基本数据类型、String类的数据）**==DataInputStream 和 DataOutputStream==**分别“套接”在 InputStream 和 OutputStream 子类的流上

DataInputStream中的方法

boolean readBoolean()

byte readByte()

char readChar()

float readFloat()

double readDouble()

short readShort()

long readLong()

int readInt()

String readUTF() void readFully(byte[] b)

DataOutputStream中的方法

将上述的方法的read改为相应的write即可。

void t1() {
    DataOutputStream dos = null;
    try { // 创建连接到指定文件的数据输出流对象
        dos = new DataOutputStream(new FileOutputStream("destData.dat"));
        dos.writeUTF("我爱北京天安门"); // 写UTF字符串
        dos.writeBoolean(false); // 写入布尔值
        dos.writeLong(1234567890L); // 写入长整数
        System.out.println("写文件成功!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally { // 关闭流对象
        try {
            if (dos != null) {
                // 关闭过滤流时,会自动关闭它包装的底层节点流
                dos.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Test
void t1() {
    DataInputStream dis = null;
    try {
        dis = new DataInputStream(new FileInputStream("destData.dat"));
        String info = dis.readUTF();
        boolean flag = dis.readBoolean();
        long time = dis.readLong();
        System.out.println(info);
        System.out.println(flag);
        System.out.println(time);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (dis != null) {
            try {
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}