JAVA学习第四部分 - 无名喵站

前言

java 语言的安装、介绍；语法、流程控制、数组、javaBean 等知识，可以查询上上一个内容

Java学习第一部分

java 语言的 String、StringBuilder、集合、对象和类进阶、窗体等知识，可以查阅上一个内容

Java学习第二部分

java 语言的 api、时间类、递归异常、集合

Java学习第三部分

Stream 流

Stream 不是数据结构，而是 对数据源（集合、数组、I/O等）进行高效、声明式处理的操作序列，类似流水线

Stream 操作的三大步骤：数据源 → 中间操作(链式) → 终止操作

常用方法

创建 Stream

方法	示例	说明
`Collection.stream()`	`list.stream()`	最常用，从集合获取
`Arrays.stream()`	`Arrays.stream(array)`	从数组
`Stream.of()`	`Stream.of("a","b","c")`	直接列举元素
`IntStream.range()`	`IntStream.range(1, 100)`	生成整数范围（无装箱）
`Stream.iterate()`	`Stream.iterate(0, n->n+2).limit(10)`	生成无限流，需要限制
`Stream.generate()`	`Stream.generate(Math::random).limit(5)`	生成无限流

中间操作（惰性，返回新 Stream）

常用组合：filter → map → sorted → limit 或 filter → flatMap → distinct → collect

方法	用途	示例
filter	过滤元素	`.filter(x -> x > 10)`
map	转换元素类型或值	`.map(String::length)`
flatMap	将每个元素转为流并扁平化（合并）	`.flatMap(list -> list.stream())`
distinct	去重（依赖 equals）	`.distinct()`
sorted	排序	`.sorted()` / `.sorted(Comparator)`
limit	截取前 n 个	`.limit(5)`
skip	跳过前 n 个	`.skip(10)`
peek	调试查看每个元素（不修改）	`.peek(System.out::println)`
takeWhile (Java 9+)	取开头满足条件的元素	`.takeWhile(x -> x < 50)`
dropWhile (Java 9+)	删除开头满足条件的元素	`.dropWhile(x -> x < 10)`

静态方法

无需主动实例化，直接可以调用的静态工厂方法，它们一般属于构造流的工具方法，用于创建流

方法	用途	示例
concat	合并参数1和参数2两个流为1个流（静态方法）	`Stream.concat(Stream a, Stream b)`

Stream.concat(a,b) 创建的流会“接管”原流的数据源，一旦新流被终端操作触发，streamA 和 streamB 都会被消耗关闭，不能再单独操作

终止操作（触发执行，关闭流）

对于 Stream 实例，只要方法返回的不是某种流类型（例如普通对象、基本类型、void），它就是终端操作

方法	返回	说明
forEach	void	遍历每个元素
collect	R（集合/自定义）	将结果收集到容器，最常用（搭配 `Collectors`）
reduce	Optional / T	聚合：求和、乘积、拼接等
count	long	元素个数
anyMatch	boolean	是否存在任一元素匹配
allMatch	boolean	是否全部匹配
noneMatch	boolean	是否全不匹配
findFirst	Optional	找到第一个元素
findAny	Optional	找到任意一个（并行流更快）
max / min	Optional	按比较器求最大值/最小值
toArray	Object[] 或指定类型数组	转为数组

操作说明

集合获取 Stream 流 操作

使用 Collection 接口中的默认方法（单列集合内置）

Java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class StreamTest2 {
    static void main() {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        // ArrayList集合 获取 steam 流
        list.stream().forEach(i -> System.out.println(i));

        HashSet<String> list1 = new HashSet<>();
        list1.add("张三");
        list1.add("李四");
        list1.add("王五");
        // HashSet集合 获取 steam 流
        list.stream().forEach(i -> System.out.println(i));

        HashMap<String, Integer> list2 = new HashMap<>();
        list2.put("张三", 100);
        list2.put("李四", 100);
        list2.put("王五", 80);
        // HashMap是双列集合，推荐 entrySet 转为单列后 获取 steam流
        Set<Map.Entry<String, Integer>> ent = list2.entrySet();
        ent.stream().forEach(i -> System.out.println(i.getKey() + ":" + i.getValue()));
    }
}

效果展示

数组获取 Stream流 操作

通过 Arrays.stream() 静态方法将数组转换成 stream 流

Java

import java.util.*;

public class StreamTest2 {
    static void main() {
        int[] list = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Arrays.stream(list).forEach(i -> System.out.println(i));
    }
}

效果展示

零散数据获取 Steam流 操作

通过 Stream.of() 传入数据转换成 stream 流

Java

import java.util.*;
import java.util.stream.Stream;

public class StreamTest2 {
    static void main() {
        Stream<Integer> stream = Stream.of(4, 2, 1, 4, 5, 2);
        stream.forEach(System.out::println);
        
        Stream<String> sreeam2 = Stream.of("张三", "李四", "王五");
        sreeam2.forEach(System.out::println);
    }
}

效果展示

当触发终止操作后流将关闭，无法再次执行中间方法

另外，一旦 Stream.concat 创建的新流被关闭，底层的 stream1 和 stream2 就会被关闭，进入 “已操作” 状态，不能再被复用。
因此，建议一旦流被拼接，只使用 Stream.concat 拼接后的新流。

Java

import java.util.*;
import java.util.stream.Stream;

public class StreamTest2 {
    static void main() {
        Stream<Integer> s1 = Stream.of(4, 2, 1, 4, 5, 2);
        Stream<Integer> s2 = Stream.of(3, 1, 3, 14, 5, 3);
        // 合并 s1 和 s2 流
        Stream<Integer> s3 = Stream.concat(s1, s2);
        s3.forEach(System.out::println);
        // 报错：提示流已关闭
        s3.distinct().forEach(System.out::println);
        // 无法再次调用 s1，因为 s1 已经被消费过了
        // s1.forEach(i -> System.out.println(s));
    }
}

效果展示

错误提示：stream has already been operated upon or closed

Collect 终止收集

通过 collect 方法，传入 Collectors 类，将 stream 流的数据收集并导入到 List 或者 Map 或者 Set 集合中

转 List

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest2 {
    static void main() {
        Stream<Integer> s1 = Stream.of(4, 2, 1, 4, 5, 2);
        List<Integer> collect = s1.limit(4).skip(1).collect(Collectors.toList());
        System.out.println(collect);
    }
}

效果展示

Collectors.toMap(new Function,new Function) 接收键和值，并得到 map 集合数据

Java

import java.util.ArrayList;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class StreamTest3 {
    static void main() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("张三,22");
        list.add("李四,24");
        list.add("王五,18");
        list.add("老六,24");
        list.add("头七,22");
        list.add("刘八,13");

        Map<String, Integer> collect = list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return Integer.parseInt(s.split(",")[1]) > 18;
            }
        }).collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split(",")[1]);
            }
        }));
        System.out.println(collect);
    }
}

效果展示

File 类

Java 中的 File 类是 java.io 包的一部分，用于表示文件和目录路径名的抽象表示形式。

File类不是用来读写文件内容的（那要使用 InputStream/OutputStream 等流），而是主要用于文件和目录的创建、删除、重命名、获取属性等元操作。

常用方法

文件/目录基本判断

方法	说明
`boolean exists()`	文件或目录是否存在
`boolean isFile()`	是否为普通文件
`boolean isDirectory()`	是否为目录
`boolean canRead()`	是否可读
`boolean canWrite()`	是否可写
`boolean canExecute()`	是否可执行
`boolean isHidden()`	是否为隐藏文件（依赖于操作系统）

获取信息

方法	说明
`String getName()`	返回文件或目录名，不包含路径
`String getPath()`	返回构造时传入的路径字符串
`String getAbsolutePath()`	返回绝对路径字符串
`String getParent()`	返回父目录路径，可能为 `null`
`long length()`	文件大小（字节），目录时返回值不确定
`long lastModified()`	最后修改时间的毫秒值

操作文件/目录

方法	说明
`boolean createNewFile()`	当且仅当文件不存在时创建一个新的空文件，返回是否成功
`boolean mkdir()`	创建单级目录
`boolean mkdirs()`	创建多级目录（包括所有不存在的父目录）
`boolean delete()`	删除文件或空目录。非空目录需递归删除
`void deleteOnExit()`	在 JVM 退出时删除文件或目录（常用于临时文件）
`boolean renameTo(File dest)`	重命名文件/目录，可能移动文件（取决于操作系统）

目录遍历

方法	说明
`String[] list()`	返回目录下所有文件和目录的名称数组，若为文件或无权限返回 `null`
`String[] list(FilenameFilter filter)`	带文件名过滤器的名称列表
`File[] listFiles()`	返回 `File` 对象数组
`File[] listFiles(FileFilter filter)`	使用 `FileFilter` 过滤的 `File` 数组
`File[] listFiles(FilenameFilter filter)`	使用 `FilenameFilter` 过滤的 `File` 数组

路径比较与转换

方法	说明
`boolean equals(Object obj)`	比较是否指向同一抽象路径（系统依赖）
`int compareTo(File another)`	按字典顺序比较路径
`URI toURI()`	将文件路径转换为 `file:` URI
`Path toPath()`（JDK 7+）	转换为 `java.nio.file.Path`

基本操作

多种 Flie 类关联路径的操作（不使用 Path 类情况）

Java

import java.io.File;
import java.io.IOException;

public class FileTest {
    static void main() throws IOException {
      // 方式 A：直接给完整路径
      File f1 = new File("E:\\smm\\code\\javaWord\\test\\1.txt");

      // 方式 B：父路径 + 子路径（推荐，自动处理分隔符）
      File parent = new File("E:\\smm\\code\\javaWord");
      File f2 = new File(parent, "test\\1.txt");

      // 方式 C：字符串父路径 + 子路径
      File f3 = new File("E:\\smm\\code\\javaWord", "test\\1.txt");
    }
}

效果展示

关联路径对应文件

通过 File 类可以创建文件夹、文件，检查文件信息

Java

import java.io.File;
import java.io.IOException;

public class FileTest {
    // 存在异常可能 需要抛出异常
    static void main() throws IOException {
        File dir = new File("E:\\smm\\code\\javaWord\\test");
        File file = new File("E:\\smm\\code\\javaWord\\test\\1.txt");
        // 创建目录，若路径节点均存在则返回 false
        if (dir.mkdirs()) {
            System.out.println("目录不存在，已创建。");
        }
        // 在指定位置创建文件，若原本存在则不处理并返回 false
        if (file.createNewFile()) {
            System.out.println("文件不存在，已创建。");
        }
        // 检查状态
        System.out.println("是否为文件: " + file.isFile());
        System.out.println("大小: " + file.length() + " bytes");
    }
}

效果展示

通过执行代码后，得到空白文件

通过 new File("").getAbsolutePath() 获取当前项目的绝对路径，如果不指定路径直接创建文件，默认也是当前项目下创建

绝对路径：从盘符开始往下到具体位置文件或文件夹，相对路径：相对于当前项目

Java

import java.io.File;
import java.io.IOException;

public class FileTest {
    static void main() throws IOException {
        File basedir = new File(new File("").getAbsolutePath());
        System.out.println(basedir);
        File text = new File("1.txt");
        System.out.println(text.getAbsolutePath());
    }
}

效果展示

获取更多文件数据信息，例如最后更新时间、是否为目录、是否隐藏

Java

package cn.smmcat.test02;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FileTest {
    static void main() throws IOException {
        File basedir = new File(new File("").getAbsolutePath());
        System.out.println(basedir.getAbsolutePath());
        File text = new File("1.txt");
        System.out.println(text.createNewFile()); // 目录是否存在
        System.out.println(text.getAbsolutePath()); // 获取此文件绝对路径
        System.out.println(text.isFile()); // 判断是否为文件
        System.out.println(text.isDirectory()); // 判断是否为目录
        System.out.println(text.isHidden()); // 文件是否隐藏
        System.out.println(text.length()); // 文件大小（文件夹无法正常显示）
        System.out.println(text.getName()); // 获取文件名
        // 最后修改时间 并搭配 SimpleDateFormat 进行格式化
        String lastUpTime = new SimpleDateFormat("yyyy年M月d日 HH:mm:ss")
        .format(new Date(text.lastModified()));
        System.out.println(lastUpTime);
    }
}

效果展示

通过 File.delete() 可以删除文件或者文件夹，需要注意是：文件夹必须里面没有文件才可以删除，且不走回收站

Java

import java.io.File;
import java.io.IOException;

public class FileTest3 {
    static void main() throws IOException {
        File file = new File("/temp/2.txt");
        File dir  = new File("/temp");
        // 创建文件夹
        dir.mkdirs();
        // 创建文件
        file.createNewFile();
        // 当文件夹存在文件时，无法删除文件夹，返回 false
        System.out.println(dir.delete());
        // 删除文件，成功返回 true
        System.out.println(file.delete());
        // 当文件夹中不存在任何文件时候，就可以删除文件夹，返回 true
        System.out.println(dir.delete());
    }
}

效果展示

IO 流

IO 流体系结构

写入数据

通过 FileOutputStream 对目标文件写入字节数据（输入的是字节，会被记事本解析成字节对应的字符）

当调用 FileOutPutStream 关联文件写入前，默认是会先清空所有内容，再进行数据的写入（覆盖操作），
若需要执行的是追加数据操作，只需要在 FileOutPutStream() 的参数二中传入 true 即可

Java

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutPutStreamTest1 {
    /**
     * 程序入口主方法
     * throws IOException：声明抛出IO读写异常，交由JVM统一处理
     */
    static void main() throws IOException {
        // 1. 创建文件字节输出流对象
        // 参数：文件绝对路径 E:\\smm\\code\\javaWord\\1.txt
        // 底层逻辑：
        // ① 检查路径对应的1.txt文件是否存在
        // ② 文件不存在：自动新建该文件
        // ③ 文件已存在：直接清空文件内部所有原有数据
        // ④ 建立Java程序与磁盘文件之间的字节写入通道
        FileOutputStream fos = new FileOutputStream("E:\\smm\\code\\javaWord\\1.txt");

        // 定义单个字节变量，ASCII码97对应小写字母a
        byte a = 97;
        // 定义字节数组，ASCII码 98=b、99=c、100=d
        byte[] b = {98, 99, 100};

        // 2. write(int b) 方法：写入单个字节
        // 传入byte类型数字，底层会转成对应ASCII字符写入文件
        fos.write(a);

        // 3. write(byte[] b) 方法：一次性写入整个字节数组
        // 会把数组中全部字节依次写入目标文件，效率高于多次调用单字节write
        fos.write(b);
        // 字符串转字节写入
        fos.write("你好Java".getBytes());

        // close()：关闭输出流，刷新缓冲区，释放操作系统文件句柄
        // 不关闭会导致文件占用、数据丢失、资源泄漏问题
        fos.close();
    }
}

效果展示

如果执行字节写入需要捕获异常，JDK7 版本前和后的写法有所不同

JDK7前

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutPutStreamTest2 {
    static void main() {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("E:\\smm\\1.txt");
            fos.write("今天开始我要自己上厕所".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK7+

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutPutStreamTest2 {
    static void main() {
        try (FileOutputStream fos = 
        new FileOutputStream("E:\\smm\\1.txt")) {
            // getBytes 可以传入字符串编码
            fos.write("爸爸妈妈你们不要小看我"
            .getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

从 JDK7 版本开始，抓捕异常会自动调用 close 方法，无需手动操作，并且能放在 try 的括号内的类，必须要实现 AutoClosealbe 接口。（会在 try 中自动执行）

在 try 的括号内的类，必须实现 AutoCloseable 接口

Java

public class FileOutPutStreamTest2 {
    static void main() {
        try (Demo4 demo = new Demo4()) {

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Demo4 implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("这句话在 try 中内容运行后自动执行");
    }
}

效果展示

读取数据

通过 FileInputStream 对目标文件读取字节数据（read() 读取的是字节，可以单个接收或者用 byte[] 多个接收）

Java

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamTest1 {
    static void main() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\javaWord\\study\\1.txt");
        byte[] b = new byte[1024];
        int len = fis.read(b);
        // String 参数1 byte[] 参数2 从哪里开始 参数3 多少长度
        System.out.println(new String(b, 0, len));
        fis.close();
    }
}

效果展示

搭配 FileOutPutStream 输入流，可以实现文件数据拷贝的效果

Java

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class FileInputStreamTest1 {
    static void main() throws IOException {
        FileInputStream fis = new FileInputStream("E\\javaWord\\study\\1.txt");
        FileOutputStream fos = new FileOutputStream("E:\\javaWord\\study\\2.txt");
        byte[] b = new byte[2];
        int len;
        while ((len = fis.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        fis.close();
        fos.close();
    }
}

效果展示

缓冲字节流

数据少时，差别不明显，数据多时，缓冲字节流通常更快，如果真正文件复制、批量读写：优先用缓冲字节流

BufferedInputStream 和 BufferedOutputStream 只是把底层的读写做了缓冲（内置 byte数组，缓冲流仅包装且不具备读写操作），减少磁盘 I/O 次数

普通字节流：直接和文件/硬件交互，每次读写都可能触发一次底层 I/O
缓冲字节流：先经过内存缓冲区，攒一批数据再和底层交互，I/O 次数更少

BufferedInputStream / BufferedOutputStream

Java

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.txt"));

读文件：
磁盘 -> 缓冲区 -> BufferedInputStream -> 程序
写文件：
程序 -> BufferedOutputStream -> 缓冲区 -> 磁盘

字节缓冲流的特点：

内部带一个缓冲区，比如默认 8KB
bis.read() 不一定每次都直接读文件，而是先从缓冲区取
bos.write() 也不一定立刻写入文件，可能先放进缓冲区
满了、flush()、或 close() 时再真正写入底层
一般更快，尤其是复制大文件时

Java

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

public class Test {
    public static void main(String[] args) throws IOException {
        try (
            BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("E:\\javaWord\\study\\1.txt")
            );
            BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("E:\\javaWord\\study\\2.txt")
            )
        ) {
            // 一般建议 1024 字节
            byte[] b = new byte[1024];
            int len;
            while ((len = bis.read(b)) != -1) {
                bos.write(b, 0, len);
            }
        }
    }
}

效果展示

当传输大文件时，字节缓冲流的效率一般要比字节流大（字节缓冲流底层自动创建长度为 1892 的 byte[]）

Java

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

public class FileInputStreamTest1 {
    static void main() throws IOException {
        BufferFn();
        defaultFn();
    }

    private static void defaultFn() throws IOException {
        long start = System.currentTimeMillis();

        FileInputStream fis = new FileInputStream("E:\\study\\test.mp4");
        FileOutputStream fos = new FileOutputStream("E:\\study\\test2.mp4");
        int len;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }
        fis.close();
        long end = System.currentTimeMillis();
        System.out.println("使用 字节流 传输大文件用时：" + (end - start) + "ms");
    }

    private static void BufferFn() throws IOException {
        long start = System.currentTimeMillis();
        
        BufferedInputStream bis = 
        new BufferedInputStream(new FileInputStream("E:\\study\\test.mp4"));
        BufferedOutputStream bos = 
        new BufferedOutputStream(new FileOutputStream("E:\\study\\test1.mp4"));

        int len;
        while ((len = bis.read()) != -1) {
            bos.write(len);
        }
        bis.close();
        long end = System.currentTimeMillis();
        System.out.println("使用 字节缓存流 传输大文件用时：" + (end - start) + "ms");
    }
}

效果展示

数据加密/解密

通过字节缓冲流/字节流可以实现加密数据（修改字节数据后，无法正常读取数据）

Java

import java.io.*;
import java.util.ArrayList;

public class ImageTest {
    static void main() throws IOException {
        BufferedInputStream fis = 
        new BufferedInputStream(new FileInputStream("E:\\study\\test.mp4"));
        
        // 不确定大小的情况下使用 集合
        ArrayList<Integer> list = new ArrayList<Integer>();
        int i;
        while ((i = fis.read()) != -1) {
            list.add(i);
        }
        fis.close();

        // 将原数据准备进行加密写入
        BufferedOutputStream fos = 
        new BufferedOutputStream(new FileOutputStream("E:\\study\\test1.mp4"));
        
        for (int o = 0; o < list.size(); o++) {
            // 异或操作 （加密文件，本质上就是让系统无法正常读取数据）
            fos.write(list.get(o) ^ 2);
        }
        fos.close();
    }
}

效果展示

再次对加密的文件异或后，数据还原（还原加密的修改后，即可正常读取）

Java

import java.io.*;
import java.util.ArrayList;

public class ImageTest {
    static void main() throws IOException {
        BufferedInputStream fis = 
        new BufferedInputStream(new FileInputStream("E:\\study\\test1.mp4"));
        
        // 不确定大小的情况下使用 集合
        ArrayList<Integer> list = new ArrayList<Integer>();
        int i;
        while ((i = fis.read()) != -1) {
            list.add(i);
        }
        fis.close();

        // 将加密数据准备进行解密写入
        BufferedOutputStream fos = 
        new BufferedOutputStream(new FileOutputStream("E:\\study\\test1.mp4"));
        
        for (int o = 0; o < list.size(); o++) {
            // 异或操作 （解密文件，本质上就是让异或后的字节再次异或进行还原）
            fos.write(list.get(o) ^ 2);
        }
        fos.close();
    }
}

效果展示

字符流

与字节流不同，字符流会涉及字符编码，适用于处理文本字符

字符编码：是指一种映射规则，根据这个规则可以将某个字符映射成其他形式的数据以便在计算机中存储和传输

字节流与字符流使用场景区别

字节流以 byte 为单位进行读写，直接处理原始二进制数据，适合处理所有类型的数据，尤其适合图片、视频、压缩包等非文本文件
字符流以 char 为单位进行读写，读写过程中会涉及字符编码和解码，适合处理文本文件；如果用字符流处理非文本文件，可能因为编码转换导致文件内容损坏

FileReader 字符输入流

用于读取纯文本文件，解决中文乱码问题

参数接收

方法提供

Java

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

public class FileReaderTest1 {
    static void main() throws IOException {
        FileReader fr = new FileReader("E:\\smm\\code\\javaWord\\study\\1.txt");
        char[] buf = new char[1024];
        int len;
        // 虽然只执行了一次 read 但实际上是读取了 8192长度字节数组内容
        len = fr.read(buf);
        System.out.println(new String(buf,0,len));
        fr.close();
    }
}

效果展示

常用字符集

字符集	时间	由来	简介
GB2312	1980	中国国家标准 GB 2312-80，全称《信息交换用汉字编码字符集基本集》。	主要用于简体中文信息交换，收录 6763 个汉字以及常用符号、字母、数字等；采用区位码体系，常见实现中汉字通常以双字节表示。
BIG5	1984	由台湾地区相关机构和厂商制定，名称通常认为来自参与制定或推广的“五大厂商”。	主要用于繁体中文环境，曾广泛应用于台湾、香港、澳门等地区；采用双字节编码，收录大量繁体汉字。
GBK	1995	GBK 即《汉字内码扩展规范》，是在 GB2312 基础上的扩展，并向下兼容 GB2312。	主要为支持更多汉字和符号而制定，覆盖简体、繁体汉字及部分少数民族文字；曾在中文 Windows 系统中长期作为常用编码（ANSI）。
Unicode	1991	由 Unicode Consortium 发布，目标是为世界上几乎所有文字和符号建立统一编码标准。	Unicode 是统一字符集标准，不是单一编码方式；常见编码包括 UTF-8、UTF-16、UTF-32，是现代操作系统、编程语言和互联网的基础字符标准。

FileWriter 字符输出流

提供的常用方法 write 支持的参数

常规使用（若不执行 fw.close() 方法，写入数据不够缓冲区上限时，这些数据并没有成功写入）

Java

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    static void main() throws IOException {
        FileWriter fw = new FileWriter("E:\\javaWord\\study\\1.txt");
        fw.write("宝宝巴士教我上厕所秘诀");
        fw.close();
    }
}

效果展示

写入文本数据到指定文件成功

若想数据即时写入，close() 可以改为 flush() 方法

flush：把缓冲区里的内容强制写出去（流还可以继续写，只想确保数据及时落盘）
close：先 flush，再关闭流（把数据刷出去，关闭流用于释放资源，写完文件并结束使用）

Java

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    static void main() throws IOException {
        FileWriter fw = new FileWriter("E:\\smm\\code\\javaWord\\study\\1.txt");
        fw.write("我等不及了");
        fw.flush(); // 将缓冲区内容立即写入文件，但流仍可继续使用
        fw.write("我要上厕所");
        fw.close(); // 完成写入，关闭流
    }
}

效果展示