stream

JavaSE/.idea/misc.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />

JavaSE/.idea/modules.xml

@@ -20,6 +20,10 @@
       <module fileurl="file://$PROJECT_DIR$/day15/day15.iml" filepath="$PROJECT_DIR$/day15/day15.iml" />
       <module fileurl="file://$PROJECT_DIR$/day16/day16.iml" filepath="$PROJECT_DIR$/day16/day16.iml" />
       <module fileurl="file://$PROJECT_DIR$/day17/day17.iml" filepath="$PROJECT_DIR$/day17/day17.iml" />
+      <module fileurl="file://$PROJECT_DIR$/day18/day18.iml" filepath="$PROJECT_DIR$/day18/day18.iml" />
+      <module fileurl="file://$PROJECT_DIR$/day19/day19.iml" filepath="$PROJECT_DIR$/day19/day19.iml" />
+      <module fileurl="file://$PROJECT_DIR$/day20/day20.iml" filepath="$PROJECT_DIR$/day20/day20.iml" />
+      <module fileurl="file://$PROJECT_DIR$/day21/day21.iml" filepath="$PROJECT_DIR$/day21/day21.iml" />
       <module fileurl="file://$PROJECT_DIR$/day_test/day_test.iml" filepath="$PROJECT_DIR$/day_test/day_test.iml" />
     </modules>
   </component>

JavaSE/day17/src/com/lc/homework/day17/thread7/Test.java

@@ -1,5 +1,8 @@
 package com.lc.homework.day17.thread7;
 
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
 /**
  * ClassName: Test
  *
@@ -51,5 +54,8 @@ public class Test {
         }.start();
 
 
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+
+
     }
 }

JavaSE/day18/day18.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

JavaSE/day18/src/com/lc/day18/file04/Test.java

@@ -0,0 +1,27 @@
+package com.lc.day18.file04;
+
+import java.io.File;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 13:43
+ * @Version 1.0
+ */
+public class Test {
+
+    public static void main(String[] args) {
+        //构造方法
+        File file = new File("C:\\LoveCoding\\VIP-31\\code\\JavaSE\\day18\\file\\a.txt");
+        File file1 = new File("a","\\b.txt");
+
+        File file2 = new File("b");
+        File file3 = new File(file2,"\\c.txt");
+
+        //file  绝对路径
+
+        //file2 相对路径
+        System.out.println(file3);
+    }
+}

JavaSE/day18/src/com/lc/day18/file04/Test1.java

@@ -0,0 +1,46 @@
+package com.lc.day18.file04;
+
+import java.io.File;
+import java.util.Date;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 13:43
+ * @Version 1.0
+ */
+public class Test1 {
+
+    public static void main(String[] args) {
+        /*
+        | 方法                         | 描述                                                         |
+        | ---------------------------- | ------------------------------------------------------------ |
+        | public String getName()      | 返回由此File表示的文件或目录的名称。                         |
+        | public long length()         | 返回由此File表示的文件的长度。 如果此路径名表示一个目录，则返回值是不确定的。 |
+        | public long lastModified()   | 返回File对象对应的文件或目录的最后修改时间（毫秒值）。       |
+        | public boolean exists()      | 此File表示的文件或目录是否实际存在。                         |
+        | public boolean isDirectory() | 此File表示的是否为目录。                                     |
+        | public boolean isFile()      | 此File表示的是否为文件。                                     |
+        | public boolean isHidden()    | 此File表示的是否为隐藏文件或目录。                           |
+         */
+        File file = new File("C:\\LoveCoding\\VIP-31\\code\\JavaSE\\day18\\file\\a.txt");
+        System.out.println(file.getName());
+
+        long length = file.length();
+        System.out.println("文件大小："+length+"字节");
+
+        long l = file.lastModified();
+        System.out.println( "时间戳"+ new Date(l));
+
+        System.out.println(file.isFile());
+
+        System.out.println(file.isDirectory());
+
+        System.out.println(file.isHidden());
+
+        File file2 = new File("/JavaSE/day18/file/a.txt");
+        System.out.println(file2.exists());
+
+    }
+}

JavaSE/day18/src/com/lc/day18/file04/Test2.java

@@ -0,0 +1,57 @@
+package com.lc.day18.file04;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 13:43
+ * @Version 1.0
+ */
+public class Test2 {
+
+    public static void main(String[] args) throws IOException {
+        /*
+        | 方法                               | 描述                                                     |
+        | ---------------------------------- | -------------------------------------------------------- |
+        | public boolean createNewFile()     | 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。 |
+        | public boolean **delete**()        | 删除由此File表示的文件或==空==目录。                     |
+        | public boolean mkdir()             | 创建由此File表示的目录。                                 |
+        | public boolean mkdirs()            | 创建由此File表示的目录，包括任何必需但不存在的父目录。   |
+        | public boolean renameTo(File dest) | 重新命名此抽象路径名表示的文件或目录。                   |
+         */
+        File file = new File("C:\\Users\\erga\\Desktop\\file\\c.txt");
+
+        boolean newFile = file.createNewFile();
+        System.out.println(newFile);
+
+        boolean delete = file.delete();
+        System.out.println(delete);
+
+
+        File file1 = new File("a");
+        System.out.println(file1.mkdir());
+
+        System.out.println(file1.getAbsolutePath());
+
+        System.out.println(file1.delete());
+
+        //多级目录
+        File file2 = new File("day18\\file\\a\\b\\c\\a.txt");
+        boolean mkdirs = file2.mkdirs();
+        System.out.println(mkdirs);
+
+        File file3 = new File("day18\\file\\a\\b\\c\\");
+
+        File file4 = new File(file3,"c.txt");
+        boolean newFile1 = file4.createNewFile();
+        System.out.println(newFile1);
+
+        File file5 = new File(file3,"b.txt");
+        boolean b = file4.renameTo(file5);
+        System.out.println(b);
+    }
+}

JavaSE/day18/src/com/lc/day18/file04/Test3.java

@@ -0,0 +1,54 @@
+package com.lc.day18.file04;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * ClassName: Test3
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 14:51
+ * @Version 1.0
+ */
+public class Test3 {
+    public static void main(String[] args) throws IOException {
+        //C:\Users\erga\Desktop
+        File file = new File("C:\\Users\\erga\\Desktop\\","file");
+        //创建文件夹
+        boolean mkdir = file.mkdir();
+        System.out.println(mkdir);
+
+        //在里面创建 三个文件 a.txt b.txt c.txt
+        File filea = new File(file,"a.txt");
+        boolean newFilea = filea.createNewFile();
+        System.out.println(newFilea);
+
+        File fileb = new File(file,"b.txt");
+        fileb.createNewFile();
+        File filec = new File(file,"c.txt");
+        filec.createNewFile();
+
+        //删除 a.txt
+        filea.delete();
+
+        //修改 b.txt 为 bbb.txt
+        fileb.renameTo(new File(file,"bbb.txt"));
+
+        //获取c.txt的 最后修改时间
+        System.out.println(new Date(filec.lastModified()));
+
+        File fileup = new File(file,"upload");
+        fileup.mkdir();
+
+        //在file  创建 /a/b/c 文件夹
+        File fileabc = new File(file,"\\a\\b\\c");
+        fileabc.mkdirs();
+
+        //判断 file中是否有d.txt 如果没有创建
+        File filed = new File(file,"d.txt");
+        if (!filed.exists()){
+            filed.createNewFile();
+        }
+    }
+}

JavaSE/day18/src/com/lc/day18/file05/Test.java

@@ -0,0 +1,62 @@
+package com.lc.day18.file05;
+
+import java.io.File;
+import java.io.FileFilter;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 15:20
+ * @Version 1.0
+ */
+public class Test {
+
+    /*
+    | 方法                                           | 描述                                                         |
+    | ---------------------------------------------- | ------------------------------------------------------------ |
+    | public File getParentFile()                    | 返回此抽象路径名父目录的抽象路径名                           |
+    | public File[] listFiles()                      | 返回一个File数组，所有的子文件或目录。                       |
+    | public File[] listFiles(FileFilter filter)     | 返回所有满足指定过滤器的文件和目录。<br>如果给定 filter 为 null，则接受所有路径名。 |
+    | public File[] listFiles(FilenameFilter filter) | 路径名满足过滤器返回true。                                   |
+     */
+    public static void main(String[] args) {
+        File file = new File("day18\\src\\com\\lc\\day18\\file04");
+
+        //获取父类文件
+        String parent = file.getParent();
+        System.out.println(parent);
+
+        File parentFile = file.getParentFile();
+        System.out.println(parentFile);
+
+        //子文件
+        String[] list = file.list();
+        for (int i = 0; i < list.length; i++) {
+            System.out.println(list[i]);
+        }
+
+        File[] files = file.listFiles();
+
+        for (File file1 : files) {
+            System.out.println(file1);
+        }
+
+        //listFiles
+        File[] files1 = file.listFiles(new FileFilter() {
+            @Override
+            public boolean accept(File pathname) {
+                String name = pathname.getName();
+
+                if (name.contains("1")) {
+                    return false;
+                }
+                return true;
+            }
+        });
+
+        for (File file1 : files1) {
+            System.out.println(file1);
+        }
+    }
+}

JavaSE/day18/src/com/lc/day18/file06/Test.java

@@ -0,0 +1,44 @@
+package com.lc.day18.file06;
+
+import java.io.File;
+import java.nio.file.Files;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 15:28
+ * @Version 1.0
+ */
+public class Test {
+
+    public static void main(String[] args) {
+
+        File file = new File("C:\\LoveCoding\\VIP-31\\code\\JavaSE\\day18\\file");
+        long fileSize = getFileSize(file);
+
+        System.out.println("文件夹的大小为："+ fileSize + "字节");
+
+        //强制删除
+        //Files.delete();
+    }
+
+    /*
+    递归方法
+     */
+    public static long getFileSize(File file) {
+        long sum = 0;
+        //子文件
+        File[] files = file.listFiles();
+
+        for (File file1 : files) {
+            if (file1.isDirectory()){
+                sum += getFileSize(file1);
+            }else {
+                long length = file1.length();
+                sum += length;
+            }
+        }
+        return sum;
+    }
+}

JavaSE/day18/src/com/lc/day18/file07/Test.java

@@ -0,0 +1,43 @@
+package com.lc.day18.file07;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 16:34
+ * @Version 1.0
+ */
+public class Test {
+
+    public static void main(String[] args) throws IOException {
+        //构造路径
+        File file = new File("day18/file");
+
+        //获取路径
+        File file1 = new File("day18/file", "a.txt");
+        String path = file1.getPath();
+        System.out.println(path);
+        String absolutePath = file1.getAbsolutePath();
+        System.out.println(absolutePath);
+
+        System.out.println("--------------");
+        //绝对路径
+        File file2 = new File("C:\\LoveCoding\\VIP-31\\code\\JavaSE\\day18\\file\\a.txt");
+        String path2 = file2.getPath();
+        System.out.println(path2);
+        String absolutePath2 = file2.getAbsolutePath();
+        System.out.println(absolutePath2);
+
+        System.out.println("-------");
+        //相对路径
+        File file3 = new File("../file/a.txt");
+
+        String path3 = file3.getPath();
+        System.out.println(path3);
+        String absolutePath3 = file3.getAbsolutePath();
+        System.out.println(absolutePath3);
+    }
+}

JavaSE/day18/src/com/lc/day18/test/test02.java

@@ -0,0 +1,31 @@
+package com.lc.day18.test;
+
+import java.io.File;
+
+/**
+ * ClassName: test02
+ * Package: File
+ * Description:
+ *
+ * @Author 赵叙淇
+ * @Create 2024/1/16 15:47
+ * @Version 1.0
+ */
+public class test02 {
+    public static void main(String[] args) {
+        File file = new File("day18");
+    long size = Getfilesize(file);
+        System.out.println(size);
+    }
+    public static long Getfilesize(File file){
+        long sum = 0;
+        File[] files = file.listFiles();
+        for (File file1 : files) {
+            if(file1.isDirectory()){
+                sum+=Getfilesize(file1);
+            }else
+                sum+=file1.length();
+        }
+        return sum;
+    }
+}

JavaSE/day18/src/com/lc/day18/thread01/PrintNumber.java

@@ -0,0 +1,37 @@
+package com.lc.day18.thread01;
+
+/**
+ * ClassName: PrintNumber
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 9:34
+ * @Version 1.0
+ */
+public class PrintNumber implements Runnable{
+    @Override
+    public void run() {
+
+        while (true){
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            //线程1 获取到锁  线程2等待
+            //同步代码块
+            synchronized (this){
+                //唤醒
+                notify();
+                //执行业务逻辑
+                System.out.println(Thread.currentThread().getName()+"线程执行");
+                //等待
+                try {
+                    wait(); //线程1 释放锁
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+    }
+}

JavaSE/day18/src/com/lc/day18/thread01/PrintNumber1.java

@@ -0,0 +1,48 @@
+package com.lc.day18.thread01;
+
+/**
+ * ClassName: PrintNumber
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 9:34
+ * @Version 1.0
+ */
+public class PrintNumber1 { //资源类
+
+    //标识
+    int flag = 1;
+
+    //线程 操作 资源类
+    public synchronized void printOdd() {
+        if (flag != 1){
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        System.out.println("奇数线程执行了");
+
+        //改变 flag = 2
+        flag = 2;
+        //通知
+        notify();
+    }
+
+    public synchronized void printEven() {
+        if (flag != 2){
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        System.out.println("偶数线程执行了");
+
+        //改变 flag = 2
+        flag = 1;
+        //通知
+        notify();
+    }
+
+}

JavaSE/day18/src/com/lc/day18/thread01/Test.java

@@ -0,0 +1,20 @@
+package com.lc.day18.thread01;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 9:33
+ * @Version 1.0
+ */
+public class Test {
+
+    public static void main(String[] args) {
+
+        PrintNumber printNumber = new PrintNumber();
+
+        new Thread(printNumber).start(); //线程1
+        new Thread(printNumber).start(); //线程2
+
+    }
+}

JavaSE/day18/src/com/lc/day18/thread01/Test1.java

@@ -0,0 +1,35 @@
+package com.lc.day18.thread01;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 9:33
+ * @Version 1.0
+ */
+public class Test1 {
+
+    public static void main(String[] args) {
+
+        PrintNumber1 printNumber = new PrintNumber1();
+
+        new Thread(){
+            @Override
+            public void run() {
+                for (int i = 0; i < 100; i++) {
+                    printNumber.printOdd();
+                }
+            }
+        }.start();
+
+        new Thread(){
+            @Override
+            public void run() {
+                for (int i = 0; i < 100; i++) {
+                    printNumber.printEven();
+                }
+            }
+        }.start();
+
+    }
+}

JavaSE/day18/src/com/lc/day18/thread02/Product.java

@@ -0,0 +1,47 @@
+package com.lc.day18.thread02;
+
+/**
+ * ClassName: Product
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 10:34
+ * @Version 1.0
+ */
+public class Product {
+    //限制
+    private int MAX_COUNT=20;
+    private int MIN_COUNT=0;
+    private int count=0;
+
+    //生产者
+    public synchronized void addProdut() throws InterruptedException {
+        //判断 不符合 等待
+        while ( count >= MAX_COUNT){
+            wait();
+        }
+
+        //生产
+        count++;
+        System.out.println(Thread.currentThread().getName()+"生产了第"+count+"个产品");
+
+        //通知消费者
+        notifyAll();
+    }
+
+    //消费者
+    // 线程2 20都消费  0 等待 唤醒所有。  线程3 不符合。唤醒 有可能 唤醒 线程2 继续执行
+    public synchronized void minProdut() throws InterruptedException {
+        //判断 不符合 等待
+        while ( count <= MIN_COUNT){
+            wait();
+        }
+
+        //消费
+        count--;
+        System.out.println(Thread.currentThread().getName()+"消费了第"+count+"个产品");
+
+        //通知消费者
+        notifyAll();
+    }
+
+}

JavaSE/day18/src/com/lc/day18/thread02/Test.java

@@ -0,0 +1,55 @@
+package com.lc.day18.thread02;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 10:39
+ * @Version 1.0
+ */
+public class Test {
+    public static void main(String[] args) {
+        //资源类
+        Product product = new Product();
+
+        new Thread(){
+            @Override
+            public void run() {
+                while (true){
+                    try {
+                        product.addProdut();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }.start();
+
+        new Thread(){
+            @Override
+            public void run() {
+                while (true){
+                    try {
+                        product.minProdut();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }.start();
+
+        new Thread(){
+            @Override
+            public void run() {
+                while (true){
+                    try {
+                        product.minProdut();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }.start();
+
+    }
+}

JavaSE/day18/src/com/lc/day18/thread03/MyCallable.java

@@ -0,0 +1,23 @@
+package com.lc.day18.thread03;
+
+import java.util.concurrent.Callable;
+
+/**
+ * ClassName: MyCallable
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 11:36
+ * @Version 1.0
+ */
+public class MyCallable implements Callable<Integer> {
+    @Override
+    public Integer call() throws Exception {
+        int sum = 0;
+        //求和
+        for (int i = 1; i <= 100; i++) {
+            sum+=i;
+        }
+
+        return sum;
+    }
+}

JavaSE/day18/src/com/lc/day18/thread03/Test.java

@@ -0,0 +1,45 @@
+package com.lc.day18.thread03;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 11:39
+ * @Version 1.0
+ */
+public class Test {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+
+        //Callable 对象
+        Callable<Integer> callable = new MyCallable();
+
+        //FutureTask对象 传入 callable
+        FutureTask futureTask = new FutureTask(callable);
+
+        //通过线程 执行futureTask
+        Thread thread = new Thread(futureTask);
+        thread.start();
+        //获取结果
+        Object o = futureTask.get();
+
+        System.out.println(o);
+
+
+        FutureTask future = new FutureTask(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                return 1000;
+            }
+        });
+
+        new Thread(future).start();
+
+        Object o1 = future.get();
+        System.out.println(o1);
+
+    }
+}

JavaSE/day18/src/com/lc/day18/thread03/Test01.java

@@ -0,0 +1,44 @@
+package com.lc.day18.thread03;
+
+import java.util.concurrent.*;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/16 11:48
+ * @Version 1.0
+ */
+public class Test01 {
+
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+
+        ExecutorService service = Executors.newFixedThreadPool(5);
+
+        service.execute(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("执行了");
+            }
+        });
+
+        FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable<Integer>() {
+            @Override
+            public Integer call() throws Exception {
+                int sum = 0;
+                for (int i = 0; i < 100; i += 2) {
+                    sum += i;
+                }
+                return sum;
+            }
+        });
+        //callable
+        service.submit(integerFutureTask);
+
+        //获取结果
+
+        Integer i = integerFutureTask.get();
+        System.out.println(i);
+
+    }
+}

JavaSE/day19/day19.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

JavaSE/day19/file/a.txt

@@ -0,0 +1,1599 @@
+# 第一章 File类
+
+`java.io.File` 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
+
+File类是java.io包下代表与平台无关的文件和目录
+
+## 1.1 构造方法
+
+| 构造器                              | 描述                                                         |
+| ----------------------------------- | ------------------------------------------------------------ |
+| `File(File parent, String child)`   | 从父抽象路径名和子路径名字符串创建新的 `File`实例。          |
+| `File(String pathname)`             | 通过将给定的路径名字符串转换为抽象路径名来创建新的 `File`实例。 |
+| `File(String parent, String child)` | 从父路径名字符串和子路径名字符串创建新的 `File`实例。        |
+| `File(URI uri)`                     | 通过将给定的 `file:` URI转换为抽象路径名来创建新的 `File`实例。 |
+
+注意：
+
+- 一个File对象代表硬盘或网络中可能存在的一个文件或者目录。
+- 无论该路径下是否存在文件或者目录，都不影响File对象的创建。
+
+示例代码如下：
+
+```java
+package com.lc.file;
+
+import java.io.File;
+
+public class FileObjectTest {
+    public static void main(String[] args) {
+        // 文件路径名
+        String pathname = "D:\\aaa.txt";
+        File file1 = new File(pathname);
+
+        // 文件路径名
+        String pathname2 = "D:\\aaa\\bbb.txt";
+        File file2 = new File(pathname2);
+
+        // 通过父路径和子路径字符串
+        String parent = "d:\\aaa";
+        String child = "bbb.txt";
+        File file3 = new File(parent, child);
+
+        // 通过父级File对象和子路径字符串
+        File parentDir = new File("d:\\aaa");
+        String childFile = "bbb.txt";
+        File file4 = new File(parentDir, childFile);
+    }
+}
+```
+
+## 1.2 常用方法
+
+### 获取判断方法
+
+| 方法                         | 描述                                                         |
+| ---------------------------- | ------------------------------------------------------------ |
+| public String getName()      | 返回由此File表示的文件或目录的名称。                         |
+| public long length()         | 返回由此File表示的文件的长度。 如果此路径名表示一个目录，则返回值是不确定的。 |
+| public long lastModified()   | 返回File对象对应的文件或目录的最后修改时间（毫秒值）。       |
+| public boolean exists()      | 此File表示的文件或目录是否实际存在。                         |
+| public boolean isDirectory() | 此File表示的是否为目录。                                     |
+| public boolean isFile()      | 此File表示的是否为文件。                                     |
+| public boolean isHidden()    | 此File表示的是否为隐藏文件或目录。                           |
+
+注意：如果File对象代表的文件或目录存在，则File对象实例初始化时，就会用硬盘中对应文件或目录的属性信息（例如，时间、类型等）为File对象的属性赋值，否则除了路径和名称，File对象的其他属性将会保留默认值。
+
+示例代码如下：
+
+```java
+
+```
+
+### 创建删除方法
+
+| 方法                               | 描述                                                     |
+| ---------------------------------- | -------------------------------------------------------- |
+| public boolean createNewFile**()   | 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。 |
+| public boolean **delete**()        | 删除由此File表示的文件或==空==目录。                     |
+| public boolean mkdir()             | 创建由此File表示的目录。                                 |
+| public boolean mkdirs()            | 创建由此File表示的目录，包括任何必需但不存在的父目录。   |
+| public boolean renameTo(File dest) | 重新命名此抽象路径名表示的文件或目录。                   |
+
+方法演示，代码如下：
+
+```java
+
+```
+
+### 文件列表
+
+| 方法                                           | 描述                                                         |
+| ---------------------------------------------- | ------------------------------------------------------------ |
+| public File getParentFile()                    | 返回此抽象路径名父目录的抽象路径名                           |
+| public File[] listFiles()                      | 返回一个File数组，所有的子文件或目录。                       |
+| public File[] listFiles(FileFilter filter)     | 返回所有满足指定过滤器的文件和目录。<br>如果给定 filter 为 null，则接受所有路径名。 |
+| public File[] listFiles(FilenameFilter filter) | 路径名满足过滤器返回true。                                   |
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        //打印一个文件夹里面所有的内容，打印所有文件的名字
+        File file = new File("C:\\Users\\Desktop\\aaa");
+        printFileName(file);
+    }
+
+    public static void printFileName(File src) {
+        //1.进入文件夹
+        //2，遍历数组
+        //3.判断，是否为文件，如果是文件，打印名字
+        //4.判断，是否为文件夹，如果是文件夹，递归
+        File[] files = src.listFiles();
+        for (File file : files) {
+            if (file.isFile()) {
+                System.out.println(file.getName());
+            } else {
+                //再次调用的时候，参数一定是src里面的子文件夹
+                printFileName(file);
+            }
+        }
+    }
+}
+```
+
+
+
+### 路径问题
+
+| 方法                            | 描述                           |
+| ------------------------------- | ------------------------------ |
+| public String getPath()         | 将此File转换为路径名字符串。   |
+| public String getAbsolutePath() | 返回此File的绝对路径名字符串。 |
+
+File类可以使用文件路径字符串来创建File实例，该文件路径字符串既可以是绝对路径，也可以是相对路径。
+
+默认情况下，系统总是依据用户的工作路径来解释相对路径，这个路径由系统属性“user.dir”指定，通常也就是运行Java虚拟机时所作的路径。
+
+* **构造路径**：使用File构造器创建File对象时指定的路径名。它可以是绝对路径，也可以是相对路径。
+* **绝对路径**：从盘符开始的路径，这是一个完整的路径。当构造路径是绝对路径时，那么getPath和getAbsolutePath结果一样。
+* **相对路径**：相对于**项目目录**的路径，这是一个便捷的路径，开发中经常使用。当构造路径是相对路径时，那么getAbsolutePath的路径 = user.dir的路径 + 构造路径
+* window的路径分隔符使用“\”，而Java程序中的“\”表示转义字符，所以在Windows中表示路径，需要用“\\”。或者直接使用“/”也可以，Java程序支持将“/”当成平台无关的路径分隔符。或者直接使用File.separator常量值表示。
+
+```java
+
+```
+
+
+
+# 第二章 IO概述
+
+## 2.1 什么是IO
+
+Java中I/O操作主要是指使用`java.io`包下的内容，进行输入、输出操作。**输入**也叫做**读取**数据，**输出**也叫做作**写出**数据。File对象不能直接读取和写入数据，如果要操作数据，需要IO流。File对象好比是到水库的“路线地址”以及水库的描述信息（包括水库的大小、位置、建造时间等），要“存取”里面的水到你“家里”，需要“管道”，IO流就好比是管道。
+
+
+
+## 2.2 IO的分类
+
+根据数据的流向分为：**输入流**和**输出流**。
+
+- **输入流** ：把数据从`其他设备`上读取到`内存`中的流。
+- **输出流** ：把数据从`内存` 中写出到`其他设备`上的流。
+
+格局数据的类型分为：**字节流**和**字符流**。
+
+- **字节流** ：以字节为单位，读写数据的流。
+- **字符流** ：以字符为单位，读写数据的流。
+
+## 2.3 四大顶级抽象父类
+
+|            |        **输入流**         |           输出流           |
+| :--------: | :-----------------------: | :------------------------: |
+| **字符流** |   字符输入流**Reader**    |    字符输出流**Writer**    |
+| **字节流** | 字节输入流**InputStream** | 字节输出流**OutputStream** |
+
+# 第三章 字节流
+
+## 3.1 一切皆为字节
+
+一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
+
+## 3.2 字节输出流【OutputStream抽象类】
+
+`java.io.OutputStream `抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
+
+- `public void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
+- `public void flush() ` ：刷新此输出流并强制任何缓冲的输出字节被写出。
+- `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
+- `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
+- `public abstract void write(int b)` ：将指定的字节输出流。
+
+> 小贴士：
+>
+> close方法，当完成流的操作时，必须调用此方法，释放系统资源。
+
+
+
+## 3.3 FileOutputStream类（实现类）
+
+`OutputStream`有很多子类，我们从最简单的一个子类开始。
+
+`java.io.FileOutputStream `类是文件输出流，用于将数据写出到文件。
+
+### 构造方法
+
+- `public FileOutputStream(File file)`：创建文件输出流以写入由指定的 File对象表示的文件。
+- `public FileOutputStream(String name)`： 创建文件输出流以指定的名称写入文件。
+
+当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
+
+- 构造举例，代码如下：
+
+```java
+public class FileOutputStreamConstructor throws IOException {
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileOutputStream fos = new FileOutputStream(file);
+
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("b.txt");
+    }
+}
+```
+
+### 写出字节数据
+
+1. **写出字节**：`write(int b)` 方法，每次可以写出一个字节数据，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 写出数据
+      	fos.write(97); // 写出第1个字节
+      	fos.write(98); // 写出第2个字节
+      	fos.write(99); // 写出第3个字节
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+abc
+
+```
+
+> 小贴士：
+>
+> 1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
+> 2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
+
+1. **写出字节数组**：`write(byte[] b)`，每次可以写出数组中的数据，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 字符串转换为字节数组
+      	byte[] b = "爱扣钉".getBytes();
+      	// 写出字节数组数据
+      	fos.write(b);
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+爱扣钉
+```
+
+1. **写出指定长度字节数组**：`write(byte[] b, int off, int len)` ,每次写出从off索引开始，len个字节，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 字符串转换为字节数组
+      	byte[] b = "abcde".getBytes();
+		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
+        fos.write(b,2,2);
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+cd
+```
+
+### 数据追加
+
+经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
+
+- `public FileOutputStream(File file, boolean append)`： 创建文件输出流以写入由指定的 File对象表示的文件。
+- `public FileOutputStream(String name, boolean append)`： 创建文件输出流以指定的名称写入文件。
+
+这两个构造方法，参数中都需要传入一个boolean类型的值，`true` 表示追加数据，`false` 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt"，true);
+      	// 字符串转换为字节数组
+      	byte[] b = "abcde".getBytes();
+		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
+        fos.write(b);
+      	// 关闭资源
+        fos.close();
+    }
+}
+文件操作前：cd
+文件操作后：cdabcde
+```
+
+
+
+## 3.4 字节输入流【InputStream】
+
+`java.io.InputStream `抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
+
+- `public void close()` ：关闭此输入流并释放与此流相关联的任何系统资源。
+- `public abstract int read()`： 从输入流读取数据的下一个字节。
+- `public int read(byte[] b)`： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
+
+> 小贴士：
+>
+> close方法，当完成流的操作时，必须调用此方法，释放系统资源。
+
+## 3.5 FileInputStream类
+
+`java.io.FileInputStream `类是文件输入流，从文件中读取字节。
+
+### 构造方法
+
+- `FileInputStream(File file)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
+- `FileInputStream(String name)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
+
+当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出`FileNotFoundException`
+
+- 构造举例，代码如下：
+
+```java
+public class FileInputStreamConstructor throws IOException{
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileInputStream fos = new FileInputStream(file);
+
+        // 使用文件名称创建流对象
+        FileInputStream fos = new FileInputStream("b.txt");
+    }
+}
+```
+
+### 读取字节数据
+
+1. **读取字节**：`read`方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回`-1`，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象
+       	FileInputStream fis = new FileInputStream("read.txt");
+      	// 读取数据，返回一个字节
+        int read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+      	// 读取到末尾,返回-1
+       	read = fis.read();
+        System.out.println( read);
+		// 关闭资源
+        fis.close();
+    }
+}
+输出结果：
+a
+b
+c
+d
+e
+-1
+```
+
+循环改进读取方式，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象
+       	FileInputStream fis = new FileInputStream("read.txt");
+      	// 定义变量，保存数据
+        int b ；
+        // 循环读取
+        while ((b = fis.read())!=-1) {
+            System.out.println((char)b);
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+输出结果：
+a
+b
+c
+d
+e
+```
+
+> 小贴士：
+>
+> 1. 虽然读取了一个字节，但是会自动提升为int类型。
+> 2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
+
+1. **使用字节数组读取**：`read(byte[] b)`，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回`-1` ，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象.
+       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
+      	// 定义变量，作为有效个数
+        int len ；
+        // 定义字节数组，作为装字节数据的容器
+        byte[] b = new byte[2];
+        // 循环读取
+        while (( len= fis.read(b))!=-1) {
+           	// 每次读取后,把数组变成字符串打印
+            System.out.println(new String(b));
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+
+输出结果：
+ab
+cd
+ed
+```
+
+错误数据`d`，是由于最后一次读取时，只读取一个字节`e`，数组中，上次读取的数据没有被完全替换，所以要通过`len` ，获取有效的字节，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象.
+       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
+      	// 定义变量，作为有效个数
+        int len ；
+        // 定义字节数组，作为装字节数据的容器
+        byte[] b = new byte[2];
+        // 循环读取
+        while (( len= fis.read(b))!=-1) {
+           	// 每次读取后,把数组的有效字节部分，变成字符串打印
+            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+
+输出结果：
+ab
+cd
+e
+```
+
+> 小贴士：
+>
+> 使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。
+
+
+
+## 3.6 复制文件
+
+一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
+
+![](imgs/2_copy.jpg)
+
+复制图片文件，代码使用演示：
+
+```java
+package com.lc.fileio;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class FileCopy {
+    public static void main(String[] args) throws IOException {
+        // 1.创建流对象
+        // 1.1 指定数据源
+        FileInputStream fis = new FileInputStream("D:\\test.jpg");
+        // 1.2 指定目的地
+        FileOutputStream fos = new FileOutputStream("test_copy.jpg");
+
+        // 2.读写数据
+        // 2.1 定义数组
+        byte[] b = new byte[1024];
+        // 2.2 定义长度
+        int len;
+        // 2.3 循环读取
+        while ((len = fis.read(b))!=-1) {
+            // 2.4 写出数据
+            fos.write(b, 0 , len);
+        }
+
+        // 3.关闭资源
+        fos.close();
+        fis.close();
+    }
+}
+```
+
+# 第四章 字符流
+
+当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。
+
+## 4.1 字符输入流【Reader】
+
+`java.io.Reader`抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
+
+- `public void close()` ：关闭此流并释放与此流相关联的任何系统资源。
+- `public int read()`： 从输入流读取一个字符。
+- `public int read(char[] cbuf)`： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
+
+## 4.2 FileReader类
+
+`java.io.FileReader `类是读取字符文件的便利类。构造时使用系统默认的字符编码。
+
+> 小贴士：
+>
+> 1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
+>
+> idea中UTF-8
+
+### 构造方法
+
+- `FileReader(File file)`： 创建一个新的 FileReader ，给定要读取的File对象。
+- `FileReader(String fileName)`： 创建一个新的 FileReader ，给定要读取的文件的名称。
+
+当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
+
+- 构造举例，代码如下：
+
+```java
+public class FileReaderConstructor throws IOException{
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileReader fr = new FileReader(file);
+
+        // 使用文件名称创建流对象
+        FileReader fr = new FileReader("b.txt");
+    }
+}
+```
+
+### 读取字符数据
+
+1. **读取字符**：`read`方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回`-1`，循环读取，代码使用演示：
+
+```java
+public class FRRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存数据
+        int b ；
+        // 循环读取
+        while ((b = fr.read())!=-1) {
+            System.out.println((char)b);
+        }
+		// 关闭资源
+        fr.close();
+    }
+}
+输出结果：
+黑
+马
+程
+序
+员
+```
+
+> 小贴士：虽然读取了一个字符，但是会自动提升为int类型。
+
+1. **使用字符数组读取**：`read(char[] cbuf)`，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回`-1` ，代码使用演示：
+
+```java
+public class FRRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存有效字符个数
+        int len ；
+        // 定义字符数组，作为装字符数据的容器
+         char[] cbuf = new char[2];
+        // 循环读取
+        while ((len = fr.read(cbuf))!=-1) {
+            System.out.println(new String(cbuf));
+        }
+		// 关闭资源
+        fr.close();
+    }
+}
+输出结果：
+黑马
+程序
+员序
+```
+
+获取有效的字符改进，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存有效字符个数
+        int len ；
+        // 定义字符数组，作为装字符数据的容器
+        char[] cbuf = new char[2];
+        // 循环读取
+        while ((len = fr.read(cbuf))!=-1) {
+            System.out.println(new String(cbuf,0,len));
+        }
+    	// 关闭资源
+        fr.close();
+    }
+}
+
+输出结果：
+黑马
+程序
+员
+```
+
+## 4.3 字符输出流【Writer】
+
+`java.io.Writer `抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
+
+- `public abstract void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
+- `public abstract void flush() ` ：刷新此输出流并强制任何缓冲的输出字符被写出。
+- `public void write(int c)` ：写出一个字符。
+- `public void write(char[] cbuf)`：将 b.length字符从指定的字符数组写出此输出流。
+- `public abstract void write(char[] b, int off, int len)` ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
+- `public void write(String str)` ：写出一个字符串。
+
+## 4.4 FileWriter类
+
+`java.io.FileWriter `类是写出字符到文件的便利类。构造时使用系统默认的字符编码。
+
+### 构造方法
+
+- `FileWriter(File file)`： 创建一个新的 FileWriter，给定要读取的File对象。
+- `FileWriter(String fileName)`： 创建一个新的 FileWriter，给定要读取的文件的名称。
+
+当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。
+
+- 构造举例，代码如下：
+
+```java
+public class FileWriterConstructor {
+    public static void main(String[] args) throws IOException {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileWriter fw = new FileWriter(file);
+
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("b.txt");
+    }
+}
+```
+
+### 基本写出数据
+
+**写出字符**：`write(int b)` 方法，每次可以写出一个字符数据，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 写出数据
+      	fw.write(97); // 写出第1个字符
+      	fw.write('b'); // 写出第2个字符
+      	fw.write('C'); // 写出第3个字符
+      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
+
+      	/*
+        【注意】流最后都要释放资源
+        */
+         fw.close();
+    }
+}
+输出结果：
+abC田
+```
+
+> 小贴士：
+>
+> 1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
+
+### 写出其他数据
+
+1. **写出字符数组** ：`write(char[] cbuf)` 和 `write(char[] cbuf, int off, int len)` ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 字符串转换为字节数组
+      	char[] chars = "黑马程序员".toCharArray();
+
+      	// 写出字符数组
+      	fw.write(chars); // 黑马程序员
+
+		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
+        fw.write(b,2,2); // 程序
+
+      	// 关闭资源
+        fos.close();
+    }
+}
+```
+
+1. **写出字符串**：`write(String str)` 和 `write(String str, int off, int len)` ，每次可以写出字符串中的数据，更为方便，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 字符串
+      	String msg = "黑马程序员";
+
+      	// 写出字符数组
+      	fw.write(msg); //黑马程序员
+
+		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
+        fw.write(msg,2,2);	// 程序
+
+        // 关闭资源
+        fos.close();
+    }
+}
+```
+
+1. **续写和换行**：操作类似于FileOutputStream。
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象，可以续写数据
+        FileWriter fw = new FileWriter("fw.txt"，true);
+      	// 写出字符串
+        fw.write("黑马");
+      	// 写出换行
+      	fw.write("\r\n");
+      	// 写出字符串
+  		fw.write("程序员");
+      	// 关闭资源
+        fw.close();
+    }
+}
+输出结果:
+黑马
+程序员
+```
+
+> 小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
+>
+> 当我们单纯读或者写文本文件时  使用字符流 其他情况使用字节流
+
+## 4.5练习：键盘录入数据并写到文件
+
+需求：
+
+​	从控制台循环接收用户录入的学生信息，
+
+​	输入格式为：学号-学生名字
+
+​	将学生信息保存到C盘下面的stu.txt文件中，
+
+​	一个学生信息占据一行数据。
+
+​	当用户输入end时停止输入。
+
+代码示例：
+
+```java
+//如果使用字节流不符合我们使用的规范
+//字节流：只做拷贝
+
+//字符流：做纯文本文件的读 和 写
+
+FileWriter fw = new FileWriter("day09-code\\a.txt");
+Scanner sc = new Scanner(System.in);
+while (true) {
+    System.out.println("请输入学生信息");
+    String str = sc.nextLine();
+    if("end".equals(str)){
+        break;
+    }
+    fw.write(str);
+    fw.write("\r\n");
+}
+
+fw.close();
+```
+
+# 第五章 缓冲流
+
+缓冲流,也叫高效流，按照数据类型分类：
+
+* **字节缓冲流**：`BufferedInputStream`，`BufferedOutputStream`
+* **字符缓冲流**：`BufferedReader`，`BufferedWriter`
+
+缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
+
+## 5.1 构造方法
+
+* `public BufferedInputStream(InputStream in)` ：创建一个 新的缓冲输入流。
+* `public BufferedOutputStream(OutputStream out)`： 创建一个新的缓冲输出流。
+
+构造举例，代码如下：
+
+```java
+// 创建字节缓冲输入流
+BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
+// 创建字节缓冲输出流
+BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
+```
+
+* `public BufferedReader(Reader in)` ：创建一个 新的缓冲输入流。
+* `public BufferedWriter(Writer out)`： 创建一个新的缓冲输出流。
+
+构造举例，代码如下：
+
+```java
+// 创建字符缓冲输入流
+BufferedReader br = new BufferedReader(new FileReader("br.txt"));
+// 创建字符缓冲输出流
+BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
+```
+
+## 5.2 效率测试
+
+查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.*;
+
+public class BufferedIO {
+    @Test
+    public void testNoBuffer() throws IOException {
+        // 记录开始时间
+        long start = System.currentTimeMillis();
+        // 创建流对象
+        FileInputStream fis = new FileInputStream("jdk8.exe");
+        FileOutputStream fos = new FileOutputStream("copy.exe");
+        // 读写数据
+        byte[] data = new byte[1024];
+        int len;
+        while ((len = fis.read(data)) != -1) {
+            fos.write(data,0,len);
+        }
+
+        fos.close();
+        fis.close();
+
+        // 记录结束时间
+        long end = System.currentTimeMillis();
+        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
+    }
+
+    @Test
+    public void testUseBuffer() throws IOException {
+        // 记录开始时间
+        long start = System.currentTimeMillis();
+        // 创建流对象
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk8.exe"));
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
+        // 读写数据
+        int len;
+        byte[] data = new byte[1024];
+        while ((len = bis.read(data)) != -1) {
+            bos.write(data, 0 , len);
+        }
+
+        bos.close();
+        bis.close();
+        // 记录结束时间
+        long end = System.currentTimeMillis();
+        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
+    }
+}
+```
+
+
+
+## 5.3 字符缓冲流特有方法
+
+字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。
+
+* BufferedReader：`public String readLine()`: 读一行文字。
+* BufferedWriter：`public void newLine()`: 写一行行分隔符,由系统属性定义符号。
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.*;
+
+public class BufferedIOLine {
+    @Test
+    public void testReadLine()throws IOException {
+        // 创建流对象
+        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
+        // 定义字符串,保存读取的一行文字
+        String line;
+        // 循环读取,读取到最后返回null
+        while ((line = br.readLine())!=null) {
+            System.out.println(line);
+        }
+        // 释放资源
+        br.close();
+    }
+
+    @Test
+    public void testNewLine()throws IOException{
+        // 创建流对象
+        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
+        // 写出数据
+        bw.write("尚");
+        // 写出换行
+        bw.newLine();
+        bw.write("硅");
+        bw.newLine();
+        bw.write("谷");
+        bw.newLine();
+        // 释放资源
+        bw.close();
+    }
+}
+
+```
+
+## 5.4 流的关闭顺序
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class IOClose {
+    @Test
+    public void test01() throws IOException {
+        FileWriter fw = new FileWriter("d:/1.txt");
+        BufferedWriter bw = new BufferedWriter(fw);
+
+        bw.write("hello");
+
+        fw.close();
+        bw.close();//java.io.IOException: Stream closed
+        /*
+        先写到bw（缓冲区）=>fw =>"文件"
+        先把fw关闭了，bw的数据无法输出了
+        1221 的顺序
+         */
+    }
+}
+```
+
+## 练习:文本排序
+
+请将文本信息恢复顺序。
+
+```
+3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+9.今当远离，临表涕零，不知所言。
+6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
+```
+
+实现步骤
+
+1. 逐行读取文本信息。
+2. 解析文本信息到集合中。
+3. 遍历集合，按顺序，写出文本信息。
+
+```java
+public class Test07 {
+    public static void main(String[] args) throws IOException {
+        //1.定义一个TreeMap  键：序号  值：内容
+        //默认是按照键来排序的
+        //Integer默认的排序规则：升序
+        TreeMap<Integer, String> tm = new TreeMap<>();
+        //2.把所有的数据读到内存中
+        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
+        //3.循环读取，并存入集合
+        //细节：readLine在读取的时候，遇到回车换行符就停止了。
+        //但是不会读回车换行
+        String line;
+        while ((line = br.readLine()) != null) {
+            String[] info = line.split("\\.");
+            int key = Integer.parseInt(info[0]);
+            String value = info[1];
+            tm.put(key, value);
+        }
+        //4.释放资源
+        //什么时候不用了，随手就释放掉
+        br.close();
+        //5.遍历集合，把数据写到新的文件中
+        BufferedWriter bw = new BufferedWriter(new FileWriter("result.txt"));
+        Set<Integer> keys = tm.keySet();
+        for (int key : keys) {
+            String value = tm.get(key);
+            bw.write(key + "." + value);
+            bw.newLine();
+            //写一行就刷新一下
+            bw.flush();
+        }
+        //6.释放资源
+        bw.close();
+
+    }
+}
+```
+
+
+
+# 第六章 转换流
+
+## 6.1 字符编码和字符集
+
+### 1、编码与解码
+
+计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为**编码** 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为**解码** 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。
+
+* **字符编码`Character Encoding`** : 就是一套自然语言的字符与二进制数之间的对应规则。
+* **编码表**:生活中文字和计算机中二进制的对应规则
+
+### 2、字符编码与字符集
+
+* **字符集 `Charset`**：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
+
+计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
+
+* **Unicode字符集** ：
+
+  ![image-20240116083105299](imgs/image-20240116083105299.png)
+
+  * Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
+  * 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
+  * UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
+    1. 128个US-ASCII字符，只需一个字节编码。
+    2. 拉丁文等字符，需要二个字节编码。
+    3. 大部分常用字（含中文），使用三个字节编码。
+    4. 其他极少使用的Unicode辅助字符，使用四字节编码。
+
+
+
+## 6.2 编码引出的问题
+
+使用`FileReader` 读取项目中的文本文件。由于项目设置了UTF-8编码，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。
+
+```java
+package com.lc.transfer;
+
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Problem {
+    public static void main(String[] args) throws IOException {
+        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
+        int read;
+        while ((read = fileReader.read()) != -1) {
+            System.out.print((char)read);
+        }
+        fileReader.close();
+    }
+}
+
+输出结果：
+���
+```
+
+那么如何读取GBK编码的文件呢？
+
+## 6.3 InputStreamReader类
+
+转换流`java.io.InputStreamReader`，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
+
+* `InputStreamReader(InputStream in)`: 创建一个使用默认字符集的字符流。
+* `InputStreamReader(InputStream in, String charsetName)`: 创建一个指定字符集的字符流。
+
+构造举例，代码如下：
+
+```java
+InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
+InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
+```
+
+示例代码：
+
+```java
+package com.lc.transfer;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class InputStreamReaderDemo {
+    public static void main(String[] args) throws IOException {
+        // 定义文件路径,文件为gbk编码
+        String fileName = "E:\\file_gbk.txt";
+        // 创建流对象,默认UTF8编码
+        InputStreamReader isr1 = new InputStreamReader(new FileInputStream(fileName));
+        // 定义变量,保存字符
+        int charData;
+        // 使用默认编码字符流读取,乱码
+        while ((charData = isr1.read()) != -1) {
+            System.out.print((char)charData); // ��Һ�
+        }
+        isr1.close();
+
+        // 创建流对象,指定GBK编码
+        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(fileName) , "GBK");
+        // 使用指定编码字符流读取,正常解析
+        while ((charData = isr2.read()) != -1) {
+            System.out.print((char)charData);// 大家好
+        }
+        isr2.close();
+    }
+}
+```
+
+## 6.4 OutputStreamWriter类
+
+转换流`java.io.OutputStreamWriter` ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
+
+- `OutputStreamWriter(OutputStream in)`: 创建一个使用默认字符集的字符流。
+- `OutputStreamWriter(OutputStream in, String charsetName)`: 创建一个指定字符集的字符流。
+
+构造举例，代码如下：
+
+```java
+OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
+OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
+```
+
+示例代码：
+
+```java
+package com.lc.transfer;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+
+public class OutputStreamWriterDemo {
+    public static void main(String[] args) throws IOException {
+        // 定义文件路径
+        String FileName = "E:\\out_utf8.txt";
+        // 创建流对象,默认UTF8编码
+        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
+        // 写出数据
+        osw.write("你好"); // 保存为6个字节
+        osw.close();
+
+        // 定义文件路径
+        String FileName2 = "E:\\out_gbk.txt";
+        // 创建流对象,指定GBK编码
+        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
+        // 写出数据
+        osw2.write("你好");// 保存为4个字节
+        osw2.close();
+    }
+}
+```
+
+## 6.5 转换流理解图解
+
+**转换流是字节与字符间的桥梁！**
+
+![image-20240116082704476](imgs/image-20240116082704476.png)
+
+
+
+# 第七章 序列化 了解
+
+## 7.1 概述
+
+Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的数据`、`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。
+
+反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。
+
+## 7.2 ObjectOutputStream类
+
+`java.io.ObjectOutputStream ` 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
+
+### 构造方法
+
+* `public ObjectOutputStream(OutputStream out) `： 创建一个指定OutputStream的ObjectOutputStream。
+
+构造举例，代码如下：
+
+```java
+FileOutputStream fileOut = new FileOutputStream("employee.txt");
+ObjectOutputStream out = new ObjectOutputStream(fileOut);
+```
+
+### 序列化操作
+
+1. 一个对象要想序列化，必须满足两个条件:
+
+* 该类必须实现`java.io.Serializable ` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。
+* 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。
+
+```java
+public class Employee implements java.io.Serializable {
+    public String name;
+    public String address;
+    public transient int age; // transient瞬态修饰成员,不会被序列化
+    public void addressCheck() {
+      	System.out.println("Address  check : " + name + " -- " + address);
+    }
+}
+```
+
+2.写出对象方法
+
+* `public final void writeObject (Object obj)` : 将指定的对象写出。
+
+```java
+//第一步：
+//创建对象
+User u = new User("zhangsan","123");
+
+//第二步：
+//创建对象操作流，把整个对象写到本地文件
+ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
+
+//第三步：
+//写出数据
+oos.writeObject(u);
+
+//第三步：
+//释放资源
+oos.close();
+```
+
+## 7.3 ObjectInputStream类
+
+ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
+
+### 构造方法
+
+* `public ObjectInputStream(InputStream in) `： 创建一个指定InputStream的ObjectInputStream。
+
+### 反序列化操作1
+
+如果能找到一个对象的class文件，我们可以进行反序列化操作，调用`ObjectInputStream`读取对象的方法：
+
+- `public final Object readObject ()` : 读取一个对象。
+
+```java
+//读取
+ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
+
+//读取数据
+User o = (User) ois.readObject();
+System.out.println(o);
+
+//释放资源
+ois.close();
+```
+
+**对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 `ClassNotFoundException` 异常。**
+
+### **反序列化操作2**
+
+**另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个`InvalidClassException`异常。**发生这个异常的原因如下：
+
+* 该类的序列版本号与从流中读取的类描述符的版本号不匹配
+* 该类包含未知数据类型
+* 该类没有可访问的无参数构造方法
+
+`Serializable` 接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID` 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
+
+```java
+public class Employee implements java.io.Serializable {
+     // 加入序列版本号
+     private static final long serialVersionUID = 1L;
+     public String name;
+     public String address;
+     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
+     public int eid;
+
+     public void addressCheck() {
+         System.out.println("Address  check : " + name + " -- " + address);
+     }
+}
+```
+
+
+
+### 13.8.2 JDK1.7之后引入新try..catch
+
+语法格式：
+
+```java
+try(需要关闭的资源对象的声明){
+    业务逻辑代码
+}catch(异常类型 e){
+    处理异常代码
+}catch(异常类型 e){
+    处理异常代码
+}
+....
+```
+
+它没有finally，也不需要程序员去关闭资源对象，无论是否发生异常，都会关闭资源对象。
+
+需要指出的是，为了保证try语句可以正常关闭资源，这些资源实现类必须实现AutoCloseable或Closeable接口，实现这两个接口就必须实现close方法。Closeable是AutoCloseable的子接口。Java7几乎把所有的“资源类”（包括文件IO的各种类、JDBC编程的Connection、Statement等接口…）进行了改写，改写后资源类都是实现了AutoCloseable或Closeable接口，并实现了close方法。
+
+写到try()中的资源类的变量默认是final声明的，不能修改。
+
+示例代码：
+
+```java
+	@Test
+	public void test03() {
+		//从d:/1.txt(GBK)文件中，读取内容，写到项目根目录下1.txt(UTF-8)文件中
+		try(
+			FileInputStream fis = new FileInputStream("d:/1.txt");
+			InputStreamReader isr = new InputStreamReader(fis,"GBK");
+			BufferedReader br = new BufferedReader(isr);
+
+			FileOutputStream fos = new FileOutputStream("1.txt");
+			OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
+			BufferedWriter bw = new BufferedWriter(osw);
+		){
+			String str;
+			while((str = br.readLine()) != null){
+				bw.write(str);
+				bw.newLine();
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+```
+
+# 第八章 Properties属性集
+
+## 8.1 概述
+
+`java.util.Properties ` 继承于` Hashtable` ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，`System.getProperties` 方法就是返回一个`Properties`对象。
+
+## 8.2 Properties类
+
+### 构造方法
+
+- `public Properties()` :创建一个空的属性列表。
+
+### 基本的存储方法
+
+* 一般下面的这些方法不用，用Map集合里面的put等方法
+
+- `public Object setProperty(String key, String value)` ： 保存一对属性。
+- `public String getProperty(String key) ` ：使用此属性列表中指定的键搜索属性值。
+- `public Set<String> stringPropertyNames() ` ：所有键的名称的集合。
+
+```java
+//Java 1.0 的时候，是没有集合体系的。
+//单列集合： Vector
+//双列集合：Hashtable
+//上面的类和Properties 都是1.0的时候出来的。
+
+//之后，发现集合挺好用的，而且在大量的场景中，都能用到集合
+//所以，在JDK1.2的时候，推出了集合体系。
+//Properties就开始使用集合体系里面的共有方法，而原来的特有方法就不用了。
+
+public class PropertiesDemo1 {
+    public static void main(String[] args) {
+        //1，Properties本身在Java中，是Map体系中的一员
+        //本身也是一个双列集合
+
+        //创建对象的时候，不用写泛型
+        //不写泛型，表示可以往集合中存储任意的数据类型
+        //但是我们一般不会这么干，一般只会把字符串存入。
+        Properties prop = new Properties();
+
+        //2.添加
+        prop.put("zhangsan","123");
+        prop.put("lisi","1234");
+        prop.put("wangwu","12345");
+
+        //3.遍历
+        Set<Object> keys = prop.keySet();
+        for (Object key : keys) {
+            String value =  prop.get(key) + "";
+            System.out.println(key + ", " + value);
+        }
+    }
+}
+```
+
+### 与流相关的方法
+
+- `public void load(InputStream inStream)`： 从字节输入流中读取键值对。
+
+参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:
+
+```properties
+filename=a.txt
+length=209385038
+location=D:\a.txt
+```
+
+### 加载代码
+
+```java
+//1.创建对象
+Properties prop = new Properties();
+
+//2.加载
+//Properties集合的本地文件，有一个命名规则：XXX.properties
+//会把本地properties文件当中的键值对，直接读到内存中，并存入到集合里面
+//省得我们自己读取再切割了。
+//细节1：
+//如果配置文件中，有中文，那么需要用FileReader
+//细节2：
+//在实际开发中，一般来讲，我们不会在properties文件里面写中文，一般都写英文
+FileInputStream fis = new FileInputStream("day10-code\\prop.properties");
+prop.load(fis);
+
+//3.打印集合
+System.out.println(prop);
+//用完之后，关流
+fis.close();
+```
+
+####
+
+> 小贴士：文本中的数据，必须是键值对形式，不可以使用空格、等号、冒号等符号分隔。
+
+# 第九章 综合练习
+
+## 练习1：按照层级目录拷贝文件夹
+
+需求：
+
+​	将某个磁盘的文件夹拷贝到另一个文件夹下去，包括文件夹中的全部信息
+
+​	需要考虑子文件夹
+
+代码示例：
+
+```java
+public class Test1 {
+    public static void main(String[] args) throws IOException {
+        /*需求：将某个磁盘的文件夹拷贝到另一个文件夹下去，
+        包括文件夹中的全部信息,需要考虑子文件夹*/
+        //要拷贝的文件夹：C:\Users\moon\Desktop\aaa
+
+        //技术选型：
+        //字节流:拷贝
+        //字符流：读和写
+        //缓冲流：提高效率
+
+        //转换流：指定编码读写
+        //对象操作流/序列化流、反序列化流:把对象写到本地，读取本地文件中的对象
+
+        //因为本题是拷贝：所以选择字节流或缓冲流
+        //因为要考虑子文件夹，所以需要用到递归
+
+        //数据源
+        File src = new File("C:\\Users\\moon\\Desktop\\aaa");
+        //目的地
+        File dest = new File("C:\\Users\\moon\\Desktop\\bbb");
+
+        copyDir(src,dest);
+    }
+
+    //数据源 src
+    //目的地 dest
+    public static void copyDir(File src, File dest) throws IOException {
+        //创建目的地文件夹
+        //此时不需要判断，如果目的地文件夹存在，大不了创建失败。
+        dest.mkdirs();
+        File[] files = src.listFiles();
+        for (File file : files) {
+            if(file.isFile()){
+                //如果是文件，就拷贝
+                FileInputStream fis = new FileInputStream(file);//src里面的a.txt
+                FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));//dest 里面的a.txt
+                byte[] bytes = new byte[1024];
+                int len;
+                while((len = fis.read(bytes)) != -1){
+                    fos.write(bytes,0,len);
+                }
+                fos.close();
+                fis.close();
+
+            }else{
+                //如果是文件夹，就递归
+                //把第一个参数里面的内容，拷贝到第二个参数里面去
+                //file:src --- aaa
+                //目的地：dest里面的aaa
+                copyDir(file, new File(dest,file.getName()));
+            }
+        }
+    }
+}
+```
+
+## 练习2：点名器升级版
+
+需求：
+
+有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器。
+
+第三次必定是张三同学
+
+核心思路：
+
+​	1.定义一个文件存储学生的姓名
+
+​	2.定义第二个文件记录程序运行的次数
+
+​	3.先读取次数，如果是第三次，直接打印
+
+​	4.如果不是第三次，则读取存储学生姓名的文件，并随机姓名
+
+​	5.再把当前运行的次数写会文件，永久保存
+
+代码示例：
+
+```java
+//1.获取当前程序运行的次数
+BufferedReader br = new BufferedReader(new FileReader("day10-code\\count.txt"));
+String line = br.readLine();
+int count = Integer.parseInt(line);
+//count表示程序已经运行了多少次
+//表示程序又运行了一次
+count++;
+if (count == 3) {
+    System.out.println("何江");
+} else {
+    //随机
+    //1.把文件中所有同学的名字都读到内存中。
+    ArrayList<String> list = new ArrayList<>();
+    BufferedReader br2 = new BufferedReader(new FileReader("day10-code\\studentname.txt"));
+    String line2;
+    while ((line2 = br2.readLine()) != null) {
+        list.add(line2);
+    }
+    br2.close();
+    //当循环结束之后，表示文件中所有同学的名字都读到集合中了
+    System.out.println(list);
+    Random r = new Random();
+    int randomIndex = r.nextInt(list.size());
+    String name1 = list.get(randomIndex);
+    System.out.println(name1);
+}
+//把count再写会文件
+BufferedWriter bw = new BufferedWriter(new FileWriter("day10-code\\count.txt"));
+bw.write(count + "");
+bw.close();
+``

JavaSE/day19/file/b.txt

@@ -0,0 +1,9 @@
+3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+9.今当远离，临表涕零，不知所言。
+6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

JavaSE/day19/file/c.txt

@@ -0,0 +1 @@
+abcdABCDabcdABCD

JavaSE/day19/file/d.txt

@@ -0,0 +1 @@
+�й�

JavaSE/day19/file/e.txt

@@ -0,0 +1,2 @@
+你好  世界
+	 hello world

JavaSE/day19/file/f.txt

@@ -0,0 +1,1599 @@
+# 第一章 File类
+
+`java.io.File` 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
+
+File类是java.io包下代表与平台无关的文件和目录
+
+## 1.1 构造方法
+
+| 构造器                              | 描述                                                         |
+| ----------------------------------- | ------------------------------------------------------------ |
+| `File(File parent, String child)`   | 从父抽象路径名和子路径名字符串创建新的 `File`实例。          |
+| `File(String pathname)`             | 通过将给定的路径名字符串转换为抽象路径名来创建新的 `File`实例。 |
+| `File(String parent, String child)` | 从父路径名字符串和子路径名字符串创建新的 `File`实例。        |
+| `File(URI uri)`                     | 通过将给定的 `file:` URI转换为抽象路径名来创建新的 `File`实例。 |
+
+注意：
+
+- 一个File对象代表硬盘或网络中可能存在的一个文件或者目录。
+- 无论该路径下是否存在文件或者目录，都不影响File对象的创建。
+
+示例代码如下：
+
+```java
+package com.lc.file;
+
+import java.io.File;
+
+public class FileObjectTest {
+    public static void main(String[] args) {
+        // 文件路径名
+        String pathname = "D:\\aaa.txt";
+        File file1 = new File(pathname);
+
+        // 文件路径名
+        String pathname2 = "D:\\aaa\\bbb.txt";
+        File file2 = new File(pathname2);
+
+        // 通过父路径和子路径字符串
+        String parent = "d:\\aaa";
+        String child = "bbb.txt";
+        File file3 = new File(parent, child);
+
+        // 通过父级File对象和子路径字符串
+        File parentDir = new File("d:\\aaa");
+        String childFile = "bbb.txt";
+        File file4 = new File(parentDir, childFile);
+    }
+}
+```
+
+## 1.2 常用方法
+
+### 获取判断方法
+
+| 方法                         | 描述                                                         |
+| ---------------------------- | ------------------------------------------------------------ |
+| public String getName()      | 返回由此File表示的文件或目录的名称。                         |
+| public long length()         | 返回由此File表示的文件的长度。 如果此路径名表示一个目录，则返回值是不确定的。 |
+| public long lastModified()   | 返回File对象对应的文件或目录的最后修改时间（毫秒值）。       |
+| public boolean exists()      | 此File表示的文件或目录是否实际存在。                         |
+| public boolean isDirectory() | 此File表示的是否为目录。                                     |
+| public boolean isFile()      | 此File表示的是否为文件。                                     |
+| public boolean isHidden()    | 此File表示的是否为隐藏文件或目录。                           |
+
+注意：如果File对象代表的文件或目录存在，则File对象实例初始化时，就会用硬盘中对应文件或目录的属性信息（例如，时间、类型等）为File对象的属性赋值，否则除了路径和名称，File对象的其他属性将会保留默认值。
+
+示例代码如下：
+
+```java
+
+```
+
+### 创建删除方法
+
+| 方法                               | 描述                                                     |
+| ---------------------------------- | -------------------------------------------------------- |
+| public boolean createNewFile**()   | 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。 |
+| public boolean **delete**()        | 删除由此File表示的文件或==空==目录。                     |
+| public boolean mkdir()             | 创建由此File表示的目录。                                 |
+| public boolean mkdirs()            | 创建由此File表示的目录，包括任何必需但不存在的父目录。   |
+| public boolean renameTo(File dest) | 重新命名此抽象路径名表示的文件或目录。                   |
+
+方法演示，代码如下：
+
+```java
+
+```
+
+### 文件列表
+
+| 方法                                           | 描述                                                         |
+| ---------------------------------------------- | ------------------------------------------------------------ |
+| public File getParentFile()                    | 返回此抽象路径名父目录的抽象路径名                           |
+| public File[] listFiles()                      | 返回一个File数组，所有的子文件或目录。                       |
+| public File[] listFiles(FileFilter filter)     | 返回所有满足指定过滤器的文件和目录。<br>如果给定 filter 为 null，则接受所有路径名。 |
+| public File[] listFiles(FilenameFilter filter) | 路径名满足过滤器返回true。                                   |
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        //打印一个文件夹里面所有的内容，打印所有文件的名字
+        File file = new File("C:\\Users\\Desktop\\aaa");
+        printFileName(file);
+    }
+
+    public static void printFileName(File src) {
+        //1.进入文件夹
+        //2，遍历数组
+        //3.判断，是否为文件，如果是文件，打印名字
+        //4.判断，是否为文件夹，如果是文件夹，递归
+        File[] files = src.listFiles();
+        for (File file : files) {
+            if (file.isFile()) {
+                System.out.println(file.getName());
+            } else {
+                //再次调用的时候，参数一定是src里面的子文件夹
+                printFileName(file);
+            }
+        }
+    }
+}
+```
+
+
+
+### 路径问题
+
+| 方法                            | 描述                           |
+| ------------------------------- | ------------------------------ |
+| public String getPath()         | 将此File转换为路径名字符串。   |
+| public String getAbsolutePath() | 返回此File的绝对路径名字符串。 |
+
+File类可以使用文件路径字符串来创建File实例，该文件路径字符串既可以是绝对路径，也可以是相对路径。
+
+默认情况下，系统总是依据用户的工作路径来解释相对路径，这个路径由系统属性“user.dir”指定，通常也就是运行Java虚拟机时所作的路径。
+
+* **构造路径**：使用File构造器创建File对象时指定的路径名。它可以是绝对路径，也可以是相对路径。
+* **绝对路径**：从盘符开始的路径，这是一个完整的路径。当构造路径是绝对路径时，那么getPath和getAbsolutePath结果一样。
+* **相对路径**：相对于**项目目录**的路径，这是一个便捷的路径，开发中经常使用。当构造路径是相对路径时，那么getAbsolutePath的路径 = user.dir的路径 + 构造路径
+* window的路径分隔符使用“\”，而Java程序中的“\”表示转义字符，所以在Windows中表示路径，需要用“\\”。或者直接使用“/”也可以，Java程序支持将“/”当成平台无关的路径分隔符。或者直接使用File.separator常量值表示。
+
+```java
+
+```
+
+
+
+# 第二章 IO概述
+
+## 2.1 什么是IO
+
+Java中I/O操作主要是指使用`java.io`包下的内容，进行输入、输出操作。**输入**也叫做**读取**数据，**输出**也叫做作**写出**数据。File对象不能直接读取和写入数据，如果要操作数据，需要IO流。File对象好比是到水库的“路线地址”以及水库的描述信息（包括水库的大小、位置、建造时间等），要“存取”里面的水到你“家里”，需要“管道”，IO流就好比是管道。
+
+
+
+## 2.2 IO的分类
+
+根据数据的流向分为：**输入流**和**输出流**。
+
+- **输入流** ：把数据从`其他设备`上读取到`内存`中的流。
+- **输出流** ：把数据从`内存` 中写出到`其他设备`上的流。
+
+格局数据的类型分为：**字节流**和**字符流**。
+
+- **字节流** ：以字节为单位，读写数据的流。
+- **字符流** ：以字符为单位，读写数据的流。
+
+## 2.3 四大顶级抽象父类
+
+|            |        **输入流**         |           输出流           |
+| :--------: | :-----------------------: | :------------------------: |
+| **字符流** |   字符输入流**Reader**    |    字符输出流**Writer**    |
+| **字节流** | 字节输入流**InputStream** | 字节输出流**OutputStream** |
+
+# 第三章 字节流
+
+## 3.1 一切皆为字节
+
+一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
+
+## 3.2 字节输出流【OutputStream抽象类】
+
+`java.io.OutputStream `抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
+
+- `public void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
+- `public void flush() ` ：刷新此输出流并强制任何缓冲的输出字节被写出。
+- `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
+- `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
+- `public abstract void write(int b)` ：将指定的字节输出流。
+
+> 小贴士：
+>
+> close方法，当完成流的操作时，必须调用此方法，释放系统资源。
+
+
+
+## 3.3 FileOutputStream类（实现类）
+
+`OutputStream`有很多子类，我们从最简单的一个子类开始。
+
+`java.io.FileOutputStream `类是文件输出流，用于将数据写出到文件。
+
+### 构造方法
+
+- `public FileOutputStream(File file)`：创建文件输出流以写入由指定的 File对象表示的文件。
+- `public FileOutputStream(String name)`： 创建文件输出流以指定的名称写入文件。
+
+当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
+
+- 构造举例，代码如下：
+
+```java
+public class FileOutputStreamConstructor throws IOException {
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileOutputStream fos = new FileOutputStream(file);
+
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("b.txt");
+    }
+}
+```
+
+### 写出字节数据
+
+1. **写出字节**：`write(int b)` 方法，每次可以写出一个字节数据，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 写出数据
+      	fos.write(97); // 写出第1个字节
+      	fos.write(98); // 写出第2个字节
+      	fos.write(99); // 写出第3个字节
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+abc
+
+```
+
+> 小贴士：
+>
+> 1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
+> 2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
+
+1. **写出字节数组**：`write(byte[] b)`，每次可以写出数组中的数据，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 字符串转换为字节数组
+      	byte[] b = "爱扣钉".getBytes();
+      	// 写出字节数组数据
+      	fos.write(b);
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+爱扣钉
+```
+
+1. **写出指定长度字节数组**：`write(byte[] b, int off, int len)` ,每次写出从off索引开始，len个字节，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt");
+      	// 字符串转换为字节数组
+      	byte[] b = "abcde".getBytes();
+		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
+        fos.write(b,2,2);
+      	// 关闭资源
+        fos.close();
+    }
+}
+输出结果：
+cd
+```
+
+### 数据追加
+
+经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
+
+- `public FileOutputStream(File file, boolean append)`： 创建文件输出流以写入由指定的 File对象表示的文件。
+- `public FileOutputStream(String name, boolean append)`： 创建文件输出流以指定的名称写入文件。
+
+这两个构造方法，参数中都需要传入一个boolean类型的值，`true` 表示追加数据，`false` 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：
+
+```java
+public class FOSWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileOutputStream fos = new FileOutputStream("fos.txt"，true);
+      	// 字符串转换为字节数组
+      	byte[] b = "abcde".getBytes();
+		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
+        fos.write(b);
+      	// 关闭资源
+        fos.close();
+    }
+}
+文件操作前：cd
+文件操作后：cdabcde
+```
+
+
+
+## 3.4 字节输入流【InputStream】
+
+`java.io.InputStream `抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
+
+- `public void close()` ：关闭此输入流并释放与此流相关联的任何系统资源。
+- `public abstract int read()`： 从输入流读取数据的下一个字节。
+- `public int read(byte[] b)`： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
+
+> 小贴士：
+>
+> close方法，当完成流的操作时，必须调用此方法，释放系统资源。
+
+## 3.5 FileInputStream类
+
+`java.io.FileInputStream `类是文件输入流，从文件中读取字节。
+
+### 构造方法
+
+- `FileInputStream(File file)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
+- `FileInputStream(String name)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
+
+当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出`FileNotFoundException`
+
+- 构造举例，代码如下：
+
+```java
+public class FileInputStreamConstructor throws IOException{
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileInputStream fos = new FileInputStream(file);
+
+        // 使用文件名称创建流对象
+        FileInputStream fos = new FileInputStream("b.txt");
+    }
+}
+```
+
+### 读取字节数据
+
+1. **读取字节**：`read`方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回`-1`，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象
+       	FileInputStream fis = new FileInputStream("read.txt");
+      	// 读取数据，返回一个字节
+        int read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+        read = fis.read();
+        System.out.println((char) read);
+      	// 读取到末尾,返回-1
+       	read = fis.read();
+        System.out.println( read);
+		// 关闭资源
+        fis.close();
+    }
+}
+输出结果：
+a
+b
+c
+d
+e
+-1
+```
+
+循环改进读取方式，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象
+       	FileInputStream fis = new FileInputStream("read.txt");
+      	// 定义变量，保存数据
+        int b ；
+        // 循环读取
+        while ((b = fis.read())!=-1) {
+            System.out.println((char)b);
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+输出结果：
+a
+b
+c
+d
+e
+```
+
+> 小贴士：
+>
+> 1. 虽然读取了一个字节，但是会自动提升为int类型。
+> 2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
+
+1. **使用字节数组读取**：`read(byte[] b)`，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回`-1` ，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象.
+       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
+      	// 定义变量，作为有效个数
+        int len ；
+        // 定义字节数组，作为装字节数据的容器
+        byte[] b = new byte[2];
+        // 循环读取
+        while (( len= fis.read(b))!=-1) {
+           	// 每次读取后,把数组变成字符串打印
+            System.out.println(new String(b));
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+
+输出结果：
+ab
+cd
+ed
+```
+
+错误数据`d`，是由于最后一次读取时，只读取一个字节`e`，数组中，上次读取的数据没有被完全替换，所以要通过`len` ，获取有效的字节，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException{
+      	// 使用文件名称创建流对象.
+       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
+      	// 定义变量，作为有效个数
+        int len ；
+        // 定义字节数组，作为装字节数据的容器
+        byte[] b = new byte[2];
+        // 循环读取
+        while (( len= fis.read(b))!=-1) {
+           	// 每次读取后,把数组的有效字节部分，变成字符串打印
+            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
+        }
+		// 关闭资源
+        fis.close();
+    }
+}
+
+输出结果：
+ab
+cd
+e
+```
+
+> 小贴士：
+>
+> 使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。
+
+
+
+## 3.6 复制文件
+
+一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
+
+![](imgs/2_copy.jpg)
+
+复制图片文件，代码使用演示：
+
+```java
+package com.lc.fileio;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class FileCopy {
+    public static void main(String[] args) throws IOException {
+        // 1.创建流对象
+        // 1.1 指定数据源
+        FileInputStream fis = new FileInputStream("D:\\test.jpg");
+        // 1.2 指定目的地
+        FileOutputStream fos = new FileOutputStream("test_copy.jpg");
+
+        // 2.读写数据
+        // 2.1 定义数组
+        byte[] b = new byte[1024];
+        // 2.2 定义长度
+        int len;
+        // 2.3 循环读取
+        while ((len = fis.read(b))!=-1) {
+            // 2.4 写出数据
+            fos.write(b, 0 , len);
+        }
+
+        // 3.关闭资源
+        fos.close();
+        fis.close();
+    }
+}
+```
+
+# 第四章 字符流
+
+当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。
+
+## 4.1 字符输入流【Reader】
+
+`java.io.Reader`抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
+
+- `public void close()` ：关闭此流并释放与此流相关联的任何系统资源。
+- `public int read()`： 从输入流读取一个字符。
+- `public int read(char[] cbuf)`： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
+
+## 4.2 FileReader类
+
+`java.io.FileReader `类是读取字符文件的便利类。构造时使用系统默认的字符编码。
+
+> 小贴士：
+>
+> 1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
+>
+> idea中UTF-8
+
+### 构造方法
+
+- `FileReader(File file)`： 创建一个新的 FileReader ，给定要读取的File对象。
+- `FileReader(String fileName)`： 创建一个新的 FileReader ，给定要读取的文件的名称。
+
+当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
+
+- 构造举例，代码如下：
+
+```java
+public class FileReaderConstructor throws IOException{
+    public static void main(String[] args) {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileReader fr = new FileReader(file);
+
+        // 使用文件名称创建流对象
+        FileReader fr = new FileReader("b.txt");
+    }
+}
+```
+
+### 读取字符数据
+
+1. **读取字符**：`read`方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回`-1`，循环读取，代码使用演示：
+
+```java
+public class FRRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存数据
+        int b ；
+        // 循环读取
+        while ((b = fr.read())!=-1) {
+            System.out.println((char)b);
+        }
+		// 关闭资源
+        fr.close();
+    }
+}
+输出结果：
+黑
+马
+程
+序
+员
+```
+
+> 小贴士：虽然读取了一个字符，但是会自动提升为int类型。
+
+1. **使用字符数组读取**：`read(char[] cbuf)`，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回`-1` ，代码使用演示：
+
+```java
+public class FRRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存有效字符个数
+        int len ；
+        // 定义字符数组，作为装字符数据的容器
+         char[] cbuf = new char[2];
+        // 循环读取
+        while ((len = fr.read(cbuf))!=-1) {
+            System.out.println(new String(cbuf));
+        }
+		// 关闭资源
+        fr.close();
+    }
+}
+输出结果：
+黑马
+程序
+员序
+```
+
+获取有效的字符改进，代码使用演示：
+
+```java
+public class FISRead {
+    public static void main(String[] args) throws IOException {
+      	// 使用文件名称创建流对象
+       	FileReader fr = new FileReader("read.txt");
+      	// 定义变量，保存有效字符个数
+        int len ；
+        // 定义字符数组，作为装字符数据的容器
+        char[] cbuf = new char[2];
+        // 循环读取
+        while ((len = fr.read(cbuf))!=-1) {
+            System.out.println(new String(cbuf,0,len));
+        }
+    	// 关闭资源
+        fr.close();
+    }
+}
+
+输出结果：
+黑马
+程序
+员
+```
+
+## 4.3 字符输出流【Writer】
+
+`java.io.Writer `抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
+
+- `public abstract void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
+- `public abstract void flush() ` ：刷新此输出流并强制任何缓冲的输出字符被写出。
+- `public void write(int c)` ：写出一个字符。
+- `public void write(char[] cbuf)`：将 b.length字符从指定的字符数组写出此输出流。
+- `public abstract void write(char[] b, int off, int len)` ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
+- `public void write(String str)` ：写出一个字符串。
+
+## 4.4 FileWriter类
+
+`java.io.FileWriter `类是写出字符到文件的便利类。构造时使用系统默认的字符编码。
+
+### 构造方法
+
+- `FileWriter(File file)`： 创建一个新的 FileWriter，给定要读取的File对象。
+- `FileWriter(String fileName)`： 创建一个新的 FileWriter，给定要读取的文件的名称。
+
+当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。
+
+- 构造举例，代码如下：
+
+```java
+public class FileWriterConstructor {
+    public static void main(String[] args) throws IOException {
+   	 	// 使用File对象创建流对象
+        File file = new File("a.txt");
+        FileWriter fw = new FileWriter(file);
+
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("b.txt");
+    }
+}
+```
+
+### 基本写出数据
+
+**写出字符**：`write(int b)` 方法，每次可以写出一个字符数据，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 写出数据
+      	fw.write(97); // 写出第1个字符
+      	fw.write('b'); // 写出第2个字符
+      	fw.write('C'); // 写出第3个字符
+      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
+
+      	/*
+        【注意】流最后都要释放资源
+        */
+         fw.close();
+    }
+}
+输出结果：
+abC田
+```
+
+> 小贴士：
+>
+> 1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
+
+### 写出其他数据
+
+1. **写出字符数组** ：`write(char[] cbuf)` 和 `write(char[] cbuf, int off, int len)` ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 字符串转换为字节数组
+      	char[] chars = "黑马程序员".toCharArray();
+
+      	// 写出字符数组
+      	fw.write(chars); // 黑马程序员
+
+		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
+        fw.write(b,2,2); // 程序
+
+      	// 关闭资源
+        fos.close();
+    }
+}
+```
+
+1. **写出字符串**：`write(String str)` 和 `write(String str, int off, int len)` ，每次可以写出字符串中的数据，更为方便，代码使用演示：
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象
+        FileWriter fw = new FileWriter("fw.txt");
+      	// 字符串
+      	String msg = "黑马程序员";
+
+      	// 写出字符数组
+      	fw.write(msg); //黑马程序员
+
+		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
+        fw.write(msg,2,2);	// 程序
+
+        // 关闭资源
+        fos.close();
+    }
+}
+```
+
+1. **续写和换行**：操作类似于FileOutputStream。
+
+```java
+public class FWWrite {
+    public static void main(String[] args) throws IOException {
+        // 使用文件名称创建流对象，可以续写数据
+        FileWriter fw = new FileWriter("fw.txt"，true);
+      	// 写出字符串
+        fw.write("黑马");
+      	// 写出换行
+      	fw.write("\r\n");
+      	// 写出字符串
+  		fw.write("程序员");
+      	// 关闭资源
+        fw.close();
+    }
+}
+输出结果:
+黑马
+程序员
+```
+
+> 小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
+>
+> 当我们单纯读或者写文本文件时  使用字符流 其他情况使用字节流
+
+## 4.5练习：键盘录入数据并写到文件
+
+需求：
+
+​	从控制台循环接收用户录入的学生信息，
+
+​	输入格式为：学号-学生名字
+
+​	将学生信息保存到C盘下面的stu.txt文件中，
+
+​	一个学生信息占据一行数据。
+
+​	当用户输入end时停止输入。
+
+代码示例：
+
+```java
+//如果使用字节流不符合我们使用的规范
+//字节流：只做拷贝
+
+//字符流：做纯文本文件的读 和 写
+
+FileWriter fw = new FileWriter("day09-code\\a.txt");
+Scanner sc = new Scanner(System.in);
+while (true) {
+    System.out.println("请输入学生信息");
+    String str = sc.nextLine();
+    if("end".equals(str)){
+        break;
+    }
+    fw.write(str);
+    fw.write("\r\n");
+}
+
+fw.close();
+```
+
+# 第五章 缓冲流
+
+缓冲流,也叫高效流，按照数据类型分类：
+
+* **字节缓冲流**：`BufferedInputStream`，`BufferedOutputStream`
+* **字符缓冲流**：`BufferedReader`，`BufferedWriter`
+
+缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
+
+## 5.1 构造方法
+
+* `public BufferedInputStream(InputStream in)` ：创建一个 新的缓冲输入流。
+* `public BufferedOutputStream(OutputStream out)`： 创建一个新的缓冲输出流。
+
+构造举例，代码如下：
+
+```java
+// 创建字节缓冲输入流
+BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
+// 创建字节缓冲输出流
+BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
+```
+
+* `public BufferedReader(Reader in)` ：创建一个 新的缓冲输入流。
+* `public BufferedWriter(Writer out)`： 创建一个新的缓冲输出流。
+
+构造举例，代码如下：
+
+```java
+// 创建字符缓冲输入流
+BufferedReader br = new BufferedReader(new FileReader("br.txt"));
+// 创建字符缓冲输出流
+BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
+```
+
+## 5.2 效率测试
+
+查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.*;
+
+public class BufferedIO {
+    @Test
+    public void testNoBuffer() throws IOException {
+        // 记录开始时间
+        long start = System.currentTimeMillis();
+        // 创建流对象
+        FileInputStream fis = new FileInputStream("jdk8.exe");
+        FileOutputStream fos = new FileOutputStream("copy.exe");
+        // 读写数据
+        byte[] data = new byte[1024];
+        int len;
+        while ((len = fis.read(data)) != -1) {
+            fos.write(data,0,len);
+        }
+
+        fos.close();
+        fis.close();
+
+        // 记录结束时间
+        long end = System.currentTimeMillis();
+        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
+    }
+
+    @Test
+    public void testUseBuffer() throws IOException {
+        // 记录开始时间
+        long start = System.currentTimeMillis();
+        // 创建流对象
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk8.exe"));
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
+        // 读写数据
+        int len;
+        byte[] data = new byte[1024];
+        while ((len = bis.read(data)) != -1) {
+            bos.write(data, 0 , len);
+        }
+
+        bos.close();
+        bis.close();
+        // 记录结束时间
+        long end = System.currentTimeMillis();
+        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
+    }
+}
+```
+
+
+
+## 5.3 字符缓冲流特有方法
+
+字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。
+
+* BufferedReader：`public String readLine()`: 读一行文字。
+* BufferedWriter：`public void newLine()`: 写一行行分隔符,由系统属性定义符号。
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.*;
+
+public class BufferedIOLine {
+    @Test
+    public void testReadLine()throws IOException {
+        // 创建流对象
+        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
+        // 定义字符串,保存读取的一行文字
+        String line;
+        // 循环读取,读取到最后返回null
+        while ((line = br.readLine())!=null) {
+            System.out.println(line);
+        }
+        // 释放资源
+        br.close();
+    }
+
+    @Test
+    public void testNewLine()throws IOException{
+        // 创建流对象
+        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
+        // 写出数据
+        bw.write("尚");
+        // 写出换行
+        bw.newLine();
+        bw.write("硅");
+        bw.newLine();
+        bw.write("谷");
+        bw.newLine();
+        // 释放资源
+        bw.close();
+    }
+}
+
+```
+
+## 5.4 流的关闭顺序
+
+```java
+package com.lc.buffer;
+
+import org.junit.Test;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class IOClose {
+    @Test
+    public void test01() throws IOException {
+        FileWriter fw = new FileWriter("d:/1.txt");
+        BufferedWriter bw = new BufferedWriter(fw);
+
+        bw.write("hello");
+
+        fw.close();
+        bw.close();//java.io.IOException: Stream closed
+        /*
+        先写到bw（缓冲区）=>fw =>"文件"
+        先把fw关闭了，bw的数据无法输出了
+        1221 的顺序
+         */
+    }
+}
+```
+
+## 练习:文本排序
+
+请将文本信息恢复顺序。
+
+```
+3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+9.今当远离，临表涕零，不知所言。
+6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
+```
+
+实现步骤
+
+1. 逐行读取文本信息。
+2. 解析文本信息到集合中。
+3. 遍历集合，按顺序，写出文本信息。
+
+```java
+public class Test07 {
+    public static void main(String[] args) throws IOException {
+        //1.定义一个TreeMap  键：序号  值：内容
+        //默认是按照键来排序的
+        //Integer默认的排序规则：升序
+        TreeMap<Integer, String> tm = new TreeMap<>();
+        //2.把所有的数据读到内存中
+        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
+        //3.循环读取，并存入集合
+        //细节：readLine在读取的时候，遇到回车换行符就停止了。
+        //但是不会读回车换行
+        String line;
+        while ((line = br.readLine()) != null) {
+            String[] info = line.split("\\.");
+            int key = Integer.parseInt(info[0]);
+            String value = info[1];
+            tm.put(key, value);
+        }
+        //4.释放资源
+        //什么时候不用了，随手就释放掉
+        br.close();
+        //5.遍历集合，把数据写到新的文件中
+        BufferedWriter bw = new BufferedWriter(new FileWriter("result.txt"));
+        Set<Integer> keys = tm.keySet();
+        for (int key : keys) {
+            String value = tm.get(key);
+            bw.write(key + "." + value);
+            bw.newLine();
+            //写一行就刷新一下
+            bw.flush();
+        }
+        //6.释放资源
+        bw.close();
+
+    }
+}
+```
+
+
+
+# 第六章 转换流
+
+## 6.1 字符编码和字符集
+
+### 1、编码与解码
+
+计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为**编码** 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为**解码** 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。
+
+* **字符编码`Character Encoding`** : 就是一套自然语言的字符与二进制数之间的对应规则。
+* **编码表**:生活中文字和计算机中二进制的对应规则
+
+### 2、字符编码与字符集
+
+* **字符集 `Charset`**：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
+
+计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
+
+* **Unicode字符集** ：
+
+  ![image-20240116083105299](imgs/image-20240116083105299.png)
+
+  * Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
+  * 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
+  * UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
+    1. 128个US-ASCII字符，只需一个字节编码。
+    2. 拉丁文等字符，需要二个字节编码。
+    3. 大部分常用字（含中文），使用三个字节编码。
+    4. 其他极少使用的Unicode辅助字符，使用四字节编码。
+
+
+
+## 6.2 编码引出的问题
+
+使用`FileReader` 读取项目中的文本文件。由于项目设置了UTF-8编码，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。
+
+```java
+package com.lc.transfer;
+
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Problem {
+    public static void main(String[] args) throws IOException {
+        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
+        int read;
+        while ((read = fileReader.read()) != -1) {
+            System.out.print((char)read);
+        }
+        fileReader.close();
+    }
+}
+
+输出结果：
+���
+```
+
+那么如何读取GBK编码的文件呢？
+
+## 6.3 InputStreamReader类
+
+转换流`java.io.InputStreamReader`，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
+
+* `InputStreamReader(InputStream in)`: 创建一个使用默认字符集的字符流。
+* `InputStreamReader(InputStream in, String charsetName)`: 创建一个指定字符集的字符流。
+
+构造举例，代码如下：
+
+```java
+InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
+InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
+```
+
+示例代码：
+
+```java
+package com.lc.transfer;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class InputStreamReaderDemo {
+    public static void main(String[] args) throws IOException {
+        // 定义文件路径,文件为gbk编码
+        String fileName = "E:\\file_gbk.txt";
+        // 创建流对象,默认UTF8编码
+        InputStreamReader isr1 = new InputStreamReader(new FileInputStream(fileName));
+        // 定义变量,保存字符
+        int charData;
+        // 使用默认编码字符流读取,乱码
+        while ((charData = isr1.read()) != -1) {
+            System.out.print((char)charData); // ��Һ�
+        }
+        isr1.close();
+
+        // 创建流对象,指定GBK编码
+        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(fileName) , "GBK");
+        // 使用指定编码字符流读取,正常解析
+        while ((charData = isr2.read()) != -1) {
+            System.out.print((char)charData);// 大家好
+        }
+        isr2.close();
+    }
+}
+```
+
+## 6.4 OutputStreamWriter类
+
+转换流`java.io.OutputStreamWriter` ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
+
+- `OutputStreamWriter(OutputStream in)`: 创建一个使用默认字符集的字符流。
+- `OutputStreamWriter(OutputStream in, String charsetName)`: 创建一个指定字符集的字符流。
+
+构造举例，代码如下：
+
+```java
+OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
+OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
+```
+
+示例代码：
+
+```java
+package com.lc.transfer;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+
+public class OutputStreamWriterDemo {
+    public static void main(String[] args) throws IOException {
+        // 定义文件路径
+        String FileName = "E:\\out_utf8.txt";
+        // 创建流对象,默认UTF8编码
+        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
+        // 写出数据
+        osw.write("你好"); // 保存为6个字节
+        osw.close();
+
+        // 定义文件路径
+        String FileName2 = "E:\\out_gbk.txt";
+        // 创建流对象,指定GBK编码
+        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
+        // 写出数据
+        osw2.write("你好");// 保存为4个字节
+        osw2.close();
+    }
+}
+```
+
+## 6.5 转换流理解图解
+
+**转换流是字节与字符间的桥梁！**
+
+![image-20240116082704476](imgs/image-20240116082704476.png)
+
+
+
+# 第七章 序列化 了解
+
+## 7.1 概述
+
+Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的数据`、`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。
+
+反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。
+
+## 7.2 ObjectOutputStream类
+
+`java.io.ObjectOutputStream ` 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
+
+### 构造方法
+
+* `public ObjectOutputStream(OutputStream out) `： 创建一个指定OutputStream的ObjectOutputStream。
+
+构造举例，代码如下：
+
+```java
+FileOutputStream fileOut = new FileOutputStream("employee.txt");
+ObjectOutputStream out = new ObjectOutputStream(fileOut);
+```
+
+### 序列化操作
+
+1. 一个对象要想序列化，必须满足两个条件:
+
+* 该类必须实现`java.io.Serializable ` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。
+* 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。
+
+```java
+public class Employee implements java.io.Serializable {
+    public String name;
+    public String address;
+    public transient int age; // transient瞬态修饰成员,不会被序列化
+    public void addressCheck() {
+      	System.out.println("Address  check : " + name + " -- " + address);
+    }
+}
+```
+
+2.写出对象方法
+
+* `public final void writeObject (Object obj)` : 将指定的对象写出。
+
+```java
+//第一步：
+//创建对象
+User u = new User("zhangsan","123");
+
+//第二步：
+//创建对象操作流，把整个对象写到本地文件
+ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
+
+//第三步：
+//写出数据
+oos.writeObject(u);
+
+//第三步：
+//释放资源
+oos.close();
+```
+
+## 7.3 ObjectInputStream类
+
+ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
+
+### 构造方法
+
+* `public ObjectInputStream(InputStream in) `： 创建一个指定InputStream的ObjectInputStream。
+
+### 反序列化操作1
+
+如果能找到一个对象的class文件，我们可以进行反序列化操作，调用`ObjectInputStream`读取对象的方法：
+
+- `public final Object readObject ()` : 读取一个对象。
+
+```java
+//读取
+ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
+
+//读取数据
+User o = (User) ois.readObject();
+System.out.println(o);
+
+//释放资源
+ois.close();
+```
+
+**对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 `ClassNotFoundException` 异常。**
+
+### **反序列化操作2**
+
+**另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个`InvalidClassException`异常。**发生这个异常的原因如下：
+
+* 该类的序列版本号与从流中读取的类描述符的版本号不匹配
+* 该类包含未知数据类型
+* 该类没有可访问的无参数构造方法
+
+`Serializable` 接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID` 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
+
+```java
+public class Employee implements java.io.Serializable {
+     // 加入序列版本号
+     private static final long serialVersionUID = 1L;
+     public String name;
+     public String address;
+     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
+     public int eid;
+
+     public void addressCheck() {
+         System.out.println("Address  check : " + name + " -- " + address);
+     }
+}
+```
+
+
+
+### 13.8.2 JDK1.7之后引入新try..catch
+
+语法格式：
+
+```java
+try(需要关闭的资源对象的声明){
+    业务逻辑代码
+}catch(异常类型 e){
+    处理异常代码
+}catch(异常类型 e){
+    处理异常代码
+}
+....
+```
+
+它没有finally，也不需要程序员去关闭资源对象，无论是否发生异常，都会关闭资源对象。
+
+需要指出的是，为了保证try语句可以正常关闭资源，这些资源实现类必须实现AutoCloseable或Closeable接口，实现这两个接口就必须实现close方法。Closeable是AutoCloseable的子接口。Java7几乎把所有的“资源类”（包括文件IO的各种类、JDBC编程的Connection、Statement等接口…）进行了改写，改写后资源类都是实现了AutoCloseable或Closeable接口，并实现了close方法。
+
+写到try()中的资源类的变量默认是final声明的，不能修改。
+
+示例代码：
+
+```java
+	@Test
+	public void test03() {
+		//从d:/1.txt(GBK)文件中，读取内容，写到项目根目录下1.txt(UTF-8)文件中
+		try(
+			FileInputStream fis = new FileInputStream("d:/1.txt");
+			InputStreamReader isr = new InputStreamReader(fis,"GBK");
+			BufferedReader br = new BufferedReader(isr);
+
+			FileOutputStream fos = new FileOutputStream("1.txt");
+			OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
+			BufferedWriter bw = new BufferedWriter(osw);
+		){
+			String str;
+			while((str = br.readLine()) != null){
+				bw.write(str);
+				bw.newLine();
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+```
+
+# 第八章 Properties属性集
+
+## 8.1 概述
+
+`java.util.Properties ` 继承于` Hashtable` ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，`System.getProperties` 方法就是返回一个`Properties`对象。
+
+## 8.2 Properties类
+
+### 构造方法
+
+- `public Properties()` :创建一个空的属性列表。
+
+### 基本的存储方法
+
+* 一般下面的这些方法不用，用Map集合里面的put等方法
+
+- `public Object setProperty(String key, String value)` ： 保存一对属性。
+- `public String getProperty(String key) ` ：使用此属性列表中指定的键搜索属性值。
+- `public Set<String> stringPropertyNames() ` ：所有键的名称的集合。
+
+```java
+//Java 1.0 的时候，是没有集合体系的。
+//单列集合： Vector
+//双列集合：Hashtable
+//上面的类和Properties 都是1.0的时候出来的。
+
+//之后，发现集合挺好用的，而且在大量的场景中，都能用到集合
+//所以，在JDK1.2的时候，推出了集合体系。
+//Properties就开始使用集合体系里面的共有方法，而原来的特有方法就不用了。
+
+public class PropertiesDemo1 {
+    public static void main(String[] args) {
+        //1，Properties本身在Java中，是Map体系中的一员
+        //本身也是一个双列集合
+
+        //创建对象的时候，不用写泛型
+        //不写泛型，表示可以往集合中存储任意的数据类型
+        //但是我们一般不会这么干，一般只会把字符串存入。
+        Properties prop = new Properties();
+
+        //2.添加
+        prop.put("zhangsan","123");
+        prop.put("lisi","1234");
+        prop.put("wangwu","12345");
+
+        //3.遍历
+        Set<Object> keys = prop.keySet();
+        for (Object key : keys) {
+            String value =  prop.get(key) + "";
+            System.out.println(key + ", " + value);
+        }
+    }
+}
+```
+
+### 与流相关的方法
+
+- `public void load(InputStream inStream)`： 从字节输入流中读取键值对。
+
+参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:
+
+```properties
+filename=a.txt
+length=209385038
+location=D:\a.txt
+```
+
+### 加载代码
+
+```java
+//1.创建对象
+Properties prop = new Properties();
+
+//2.加载
+//Properties集合的本地文件，有一个命名规则：XXX.properties
+//会把本地properties文件当中的键值对，直接读到内存中，并存入到集合里面
+//省得我们自己读取再切割了。
+//细节1：
+//如果配置文件中，有中文，那么需要用FileReader
+//细节2：
+//在实际开发中，一般来讲，我们不会在properties文件里面写中文，一般都写英文
+FileInputStream fis = new FileInputStream("day10-code\\prop.properties");
+prop.load(fis);
+
+//3.打印集合
+System.out.println(prop);
+//用完之后，关流
+fis.close();
+```
+
+####
+
+> 小贴士：文本中的数据，必须是键值对形式，不可以使用空格、等号、冒号等符号分隔。
+
+# 第九章 综合练习
+
+## 练习1：按照层级目录拷贝文件夹
+
+需求：
+
+​	将某个磁盘的文件夹拷贝到另一个文件夹下去，包括文件夹中的全部信息
+
+​	需要考虑子文件夹
+
+代码示例：
+
+```java
+public class Test1 {
+    public static void main(String[] args) throws IOException {
+        /*需求：将某个磁盘的文件夹拷贝到另一个文件夹下去，
+        包括文件夹中的全部信息,需要考虑子文件夹*/
+        //要拷贝的文件夹：C:\Users\moon\Desktop\aaa
+
+        //技术选型：
+        //字节流:拷贝
+        //字符流：读和写
+        //缓冲流：提高效率
+
+        //转换流：指定编码读写
+        //对象操作流/序列化流、反序列化流:把对象写到本地，读取本地文件中的对象
+
+        //因为本题是拷贝：所以选择字节流或缓冲流
+        //因为要考虑子文件夹，所以需要用到递归
+
+        //数据源
+        File src = new File("C:\\Users\\moon\\Desktop\\aaa");
+        //目的地
+        File dest = new File("C:\\Users\\moon\\Desktop\\bbb");
+
+        copyDir(src,dest);
+    }
+
+    //数据源 src
+    //目的地 dest
+    public static void copyDir(File src, File dest) throws IOException {
+        //创建目的地文件夹
+        //此时不需要判断，如果目的地文件夹存在，大不了创建失败。
+        dest.mkdirs();
+        File[] files = src.listFiles();
+        for (File file : files) {
+            if(file.isFile()){
+                //如果是文件，就拷贝
+                FileInputStream fis = new FileInputStream(file);//src里面的a.txt
+                FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));//dest 里面的a.txt
+                byte[] bytes = new byte[1024];
+                int len;
+                while((len = fis.read(bytes)) != -1){
+                    fos.write(bytes,0,len);
+                }
+                fos.close();
+                fis.close();
+
+            }else{
+                //如果是文件夹，就递归
+                //把第一个参数里面的内容，拷贝到第二个参数里面去
+                //file:src --- aaa
+                //目的地：dest里面的aaa
+                copyDir(file, new File(dest,file.getName()));
+            }
+        }
+    }
+}
+```
+
+## 练习2：点名器升级版
+
+需求：
+
+有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器。
+
+第三次必定是张三同学
+
+核心思路：
+
+​	1.定义一个文件存储学生的姓名
+
+​	2.定义第二个文件记录程序运行的次数
+
+​	3.先读取次数，如果是第三次，直接打印
+
+​	4.如果不是第三次，则读取存储学生姓名的文件，并随机姓名
+
+​	5.再把当前运行的次数写会文件，永久保存
+
+代码示例：
+
+```java
+//1.获取当前程序运行的次数
+BufferedReader br = new BufferedReader(new FileReader("day10-code\\count.txt"));
+String line = br.readLine();
+int count = Integer.parseInt(line);
+//count表示程序已经运行了多少次
+//表示程序又运行了一次
+count++;
+if (count == 3) {
+    System.out.println("何江");
+} else {
+    //随机
+    //1.把文件中所有同学的名字都读到内存中。
+    ArrayList<String> list = new ArrayList<>();
+    BufferedReader br2 = new BufferedReader(new FileReader("day10-code\\studentname.txt"));
+    String line2;
+    while ((line2 = br2.readLine()) != null) {
+        list.add(line2);
+    }
+    br2.close();
+    //当循环结束之后，表示文件中所有同学的名字都读到集合中了
+    System.out.println(list);
+    Random r = new Random();
+    int randomIndex = r.nextInt(list.size());
+    String name1 = list.get(randomIndex);
+    System.out.println(name1);
+}
+//把count再写会文件
+BufferedWriter bw = new BufferedWriter(new FileWriter("day10-code\\count.txt"));
+bw.write(count + "");
+bw.close();
+``

JavaSE/day19/file/h.txt

@@ -0,0 +1,2 @@
+张三
+李四

JavaSE/day19/file/jdbc.properties

@@ -0,0 +1,2 @@
+username=root
+password=123456

JavaSE/day19/file/出师表.txt

@@ -0,0 +1,9 @@
+1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
+6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+9.今当远离，临表涕零，不知所言。

JavaSE/day19/file/成绩单.txt

@@ -0,0 +1,501 @@
+年级,姓名,软件工程,大数据,人工智能,专业
+二年级,李四78,81,42,30,软件工程
+二年级,钱十三81,62,97,30,大数据
+一年级,吴二十八51,52,24,95,软件工程
+二年级,钱七79,17,47,85,软件工程
+二年级,钱七29,22,69,33,人工智能
+一年级,郑二十三78,46,92,95,大数据
+二年级,李四34,89,54,7,大数据
+二年级,李四98,98,96,29,大数据
+一年级,钱二十五82,0,24,51,软件工程
+二年级,钱十三60,87,24,37,大数据
+一年级,郑十56,19,13,16,软件工程
+二年级,吴十41,86,11,27,软件工程
+二年级,王十二76,67,93,60,人工智能
+二年级,钱三十93,29,38,2,人工智能
+二年级,钱三十1,46,52,89,人工智能
+一年级,钱十九78,71,51,33,软件工程
+二年级,钱二十五0,49,68,99,大数据
+二年级,钱十三76,20,17,0,人工智能
+二年级,吴二十二20,40,36,29,软件工程
+一年级,赵六4,88,75,17,人工智能
+一年级,钱二十五22,2,57,67,人工智能
+一年级,吴十六30,63,80,11,软件工程
+二年级,钱十三14,7,41,84,大数据
+一年级,吴十73,99,71,56,大数据
+二年级,李四51,60,30,80,软件工程
+二年级,郑十七49,80,92,2,大数据
+二年级,孙八74,44,24,42,大数据
+一年级,钱三十57,61,5,47,人工智能
+一年级,孙八17,89,24,95,大数据
+二年级,钱三十57,48,20,70,人工智能
+一年级,王十八45,91,66,10,人工智能
+一年级,钱七88,86,12,6,大数据
+二年级,郑十84,5,49,68,软件工程
+一年级,张三43,4,17,11,人工智能
+二年级,钱七68,50,86,91,软件工程
+二年级,钱七2,88,72,26,人工智能
+二年级,周二十94,14,84,90,人工智能
+一年级,吴二十二71,76,40,8,大数据
+一年级,钱十三84,71,25,70,人工智能
+二年级,赵六3,28,1,4,大数据
+二年级,赵六88,19,81,4,人工智能
+二年级,钱三十38,18,14,32,大数据
+一年级,孙二十六32,85,17,15,大数据
+二年级,张三2,83,75,11,大数据
+二年级,钱二十五94,17,54,64,人工智能
+二年级,郑二十九84,83,28,90,软件工程
+一年级,吴二十二81,67,64,14,人工智能
+二年级,孙二十六61,21,12,11,大数据
+一年级,钱二十五25,87,44,27,软件工程
+二年级,张三46,25,99,32,大数据
+一年级,吴二十八52,50,75,51,人工智能
+二年级,孙十四43,63,88,35,软件工程
+二年级,钱三十34,86,52,35,人工智能
+二年级,周十五16,22,83,88,大数据
+二年级,张三74,49,34,97,大数据
+一年级,郑十73,69,15,87,人工智能
+二年级,钱十九31,79,7,6,软件工程
+二年级,钱二十五56,10,65,48,人工智能
+二年级,周九24,40,81,74,软件工程
+一年级,钱三十50,68,48,66,大数据
+二年级,孙八71,16,25,7,人工智能
+一年级,周二十七49,21,86,12,人工智能
+二年级,周二十七59,9,8,71,人工智能
+二年级,周二十七99,25,49,8,软件工程
+一年级,郑十97,45,26,70,大数据
+二年级,吴十六75,45,16,74,软件工程
+二年级,王五20,77,41,29,人工智能
+一年级,周二十14,57,16,22,大数据
+一年级,钱二十五95,40,77,51,大数据
+一年级,吴十55,17,92,52,软件工程
+一年级,钱十三16,49,60,67,人工智能
+二年级,王十二44,91,61,59,大数据
+一年级,郑十70,54,92,89,人工智能
+二年级,吴二十二81,22,91,92,软件工程
+一年级,周二十53,58,14,22,大数据
+二年级,郑二十九95,34,26,38,大数据
+二年级,孙二十93,16,80,57,人工智能
+一年级,钱二十五17,60,20,15,人工智能
+一年级,郑十七8,40,55,40,人工智能
+一年级,钱七12,53,86,5,软件工程
+一年级,吴二十二93,97,3,53,软件工程
+二年级,王十二55,77,57,59,软件工程
+二年级,钱七9,15,83,75,软件工程
+二年级,周二十七94,75,58,12,人工智能
+一年级,吴二十八69,3,65,33,人工智能
+一年级,张三84,94,55,55,人工智能
+二年级,钱十三27,34,83,30,人工智能
+二年级,吴十92,6,39,15,软件工程
+二年级,郑二十九2,86,58,35,人工智能
+一年级,周九18,19,74,92,人工智能
+二年级,李四63,16,65,92,软件工程
+一年级,周九84,45,75,41,大数据
+一年级,吴二十八54,69,14,42,软件工程
+一年级,郑十92,43,35,19,大数据
+二年级,吴十六22,31,54,91,软件工程
+二年级,李四57,63,6,41,人工智能
+一年级,孙十四54,99,11,1,人工智能
+一年级,吴十97,3,47,41,大数据
+一年级,周二十七66,90,54,10,软件工程
+二年级,王十八44,79,50,25,软件工程
+一年级,王十八29,64,17,21,人工智能
+一年级,钱十三92,53,5,27,人工智能
+二年级,郑二十三68,47,92,62,软件工程
+一年级,吴十六51,40,83,86,人工智能
+二年级,王十八51,20,80,43,软件工程
+二年级,钱二十五9,17,62,92,软件工程
+一年级,钱十九0,71,56,52,软件工程
+一年级,钱十九28,84,85,73,大数据
+一年级,孙十四51,64,99,83,大数据
+一年级,王五65,93,93,38,软件工程
+一年级,孙八41,73,43,79,人工智能
+一年级,周十五59,87,27,49,软件工程
+二年级,张三83,40,70,90,软件工程
+一年级,王十二58,0,46,29,大数据
+二年级,王五72,82,2,4,软件工程
+一年级,吴十六16,74,66,55,大数据
+一年级,钱七53,33,95,86,人工智能
+一年级,钱三十91,59,22,81,软件工程
+二年级,周二十89,34,18,3,人工智能
+一年级,周九27,97,52,40,软件工程
+二年级,孙二十94,86,8,0,大数据
+二年级,孙二十32,6,12,88,人工智能
+一年级,钱十九51,92,76,5,大数据
+一年级,钱三十50,83,7,33,软件工程
+二年级,吴二十八82,13,30,96,人工智能
+一年级,钱三十26,42,94,54,大数据
+一年级,周二十七38,58,52,59,软件工程
+一年级,郑十七92,48,5,42,大数据
+二年级,钱三十84,63,32,14,软件工程
+一年级,张三78,86,68,32,大数据
+二年级,钱七72,55,31,14,软件工程
+一年级,钱三十26,84,92,67,大数据
+一年级,王十二43,0,43,63,大数据
+二年级,孙二十六95,30,59,17,人工智能
+二年级,郑二十三73,58,93,58,大数据
+一年级,吴十79,57,10,3,人工智能
+一年级,吴十11,87,19,68,软件工程
+一年级,王二十四4,45,28,43,大数据
+二年级,周二十七25,13,43,20,大数据
+一年级,吴二十二12,14,48,11,软件工程
+二年级,周二十67,88,61,7,人工智能
+一年级,王五15,6,56,88,软件工程
+二年级,钱三十88,87,52,14,人工智能
+二年级,郑十七81,15,73,4,人工智能
+一年级,孙十四31,77,67,45,软件工程
+二年级,孙二十74,0,43,60,软件工程
+一年级,钱十九88,23,74,54,软件工程
+二年级,孙二十六45,17,98,75,软件工程
+二年级,王十八33,57,17,87,人工智能
+一年级,吴二十二5,83,29,37,大数据
+一年级,张三43,84,62,88,人工智能
+二年级,钱七42,57,18,53,大数据
+一年级,王二十四87,39,82,0,大数据
+一年级,郑十15,99,44,19,大数据
+二年级,吴二十二4,21,27,14,大数据
+一年级,孙二十六40,44,14,2,人工智能
+一年级,吴二十二84,98,36,42,软件工程
+一年级,孙二十44,57,99,46,软件工程
+一年级,王二十四0,24,95,60,软件工程
+一年级,周九45,79,72,64,软件工程
+一年级,周十五37,68,40,18,人工智能
+一年级,钱二十五28,66,11,32,大数据
+一年级,郑十7,87,43,18,软件工程
+二年级,孙二十六66,63,12,30,人工智能
+二年级,周十五48,94,0,44,大数据
+一年级,周九85,4,23,49,人工智能
+二年级,周二十七22,76,11,11,大数据
+二年级,周二十72,91,30,44,人工智能
+一年级,钱二十五9,14,69,41,软件工程
+一年级,钱十九25,12,26,57,大数据
+一年级,孙八84,79,71,14,大数据
+一年级,张三65,49,31,21,大数据
+一年级,周二十七10,7,57,12,大数据
+二年级,孙八71,93,97,28,大数据
+二年级,周九1,60,52,7,大数据
+二年级,王二十四73,58,27,2,大数据
+一年级,张三35,7,87,61,软件工程
+一年级,郑十七46,71,17,99,大数据
+二年级,张三33,85,50,75,软件工程
+一年级,周二十29,78,55,85,人工智能
+一年级,吴二十二26,13,98,1,大数据
+二年级,孙二十六79,53,73,18,软件工程
+一年级,周九3,30,67,71,软件工程
+二年级,郑十33,92,44,65,人工智能
+二年级,钱二十五19,75,28,82,大数据
+二年级,孙十四47,72,31,14,软件工程
+一年级,钱二十五91,83,1,47,人工智能
+一年级,孙二十57,58,42,89,软件工程
+二年级,钱七64,13,6,46,大数据
+一年级,吴十12,31,11,98,软件工程
+一年级,钱七99,8,79,30,大数据
+二年级,郑二十三12,17,29,87,大数据
+二年级,周二十89,73,60,88,人工智能
+二年级,赵六26,18,14,13,人工智能
+二年级,吴二十二28,74,87,11,人工智能
+二年级,吴二十八79,51,5,72,软件工程
+二年级,张三96,76,98,70,人工智能
+一年级,王五50,28,65,83,软件工程
+一年级,吴十六83,18,30,71,人工智能
+一年级,郑二十三41,6,52,66,软件工程
+一年级,钱十三43,74,94,13,软件工程
+二年级,周十五11,20,52,30,大数据
+一年级,吴十21,19,88,25,软件工程
+一年级,孙二十六79,21,15,9,人工智能
+二年级,郑二十九51,78,5,3,软件工程
+二年级,钱七14,31,78,17,大数据
+一年级,孙八36,21,3,9,软件工程
+二年级,郑十七26,27,90,55,软件工程
+一年级,王二十四56,17,31,2,人工智能
+一年级,郑十77,88,67,95,软件工程
+一年级,郑二十三49,14,74,61,软件工程
+一年级,王五28,84,38,60,大数据
+一年级,郑二十三52,22,44,72,人工智能
+二年级,吴十六99,42,37,55,人工智能
+二年级,周二十七4,91,50,80,人工智能
+二年级,钱十三88,40,92,43,大数据
+一年级,吴十六24,17,66,59,大数据
+一年级,孙十四46,29,71,4,大数据
+一年级,张三1,81,67,44,人工智能
+二年级,钱二十五49,30,28,54,人工智能
+二年级,张三85,70,94,58,人工智能
+二年级,张三4,41,32,93,人工智能
+二年级,钱三十34,86,84,99,软件工程
+二年级,张三86,17,0,65,人工智能
+一年级,张三49,35,7,44,软件工程
+二年级,吴十六90,14,83,11,大数据
+二年级,吴十六33,87,71,31,人工智能
+一年级,周九40,83,29,67,人工智能
+一年级,郑十97,0,15,0,人工智能
+二年级,李四2,74,58,15,人工智能
+二年级,郑二十九47,27,22,69,人工智能
+一年级,赵六20,17,56,7,人工智能
+一年级,周十五50,82,78,8,大数据
+二年级,钱十三5,11,42,5,软件工程
+二年级,孙二十六80,60,58,18,人工智能
+一年级,郑二十九84,43,55,33,大数据
+二年级,吴十21,88,63,19,人工智能
+一年级,孙二十32,95,4,24,人工智能
+一年级,孙二十六39,44,97,62,软件工程
+一年级,钱十九80,37,14,68,人工智能
+二年级,郑十七5,79,60,90,大数据
+二年级,孙二十六19,31,21,13,软件工程
+二年级,赵六94,56,2,37,软件工程
+一年级,吴二十二18,21,62,36,人工智能
+一年级,吴十六70,25,30,27,软件工程
+一年级,孙二十六63,73,16,31,大数据
+一年级,王二十四2,65,74,71,软件工程
+一年级,李四78,55,52,95,软件工程
+一年级,孙八77,85,20,44,软件工程
+二年级,钱十三28,21,3,93,大数据
+一年级,孙二十85,91,70,53,人工智能
+二年级,王十八78,22,37,26,大数据
+二年级,王五46,75,54,2,软件工程
+二年级,孙二十六77,41,31,19,人工智能
+一年级,王五79,83,88,82,人工智能
+一年级,郑十18,0,0,81,软件工程
+一年级,孙八75,45,39,84,人工智能
+一年级,钱十三91,44,15,45,大数据
+二年级,周十五3,82,26,79,软件工程
+二年级,周九67,90,9,45,人工智能
+二年级,孙二十99,10,41,68,大数据
+一年级,孙八37,75,48,40,人工智能
+二年级,钱十九71,90,84,65,大数据
+一年级,郑二十三84,3,11,57,人工智能
+二年级,钱三十66,71,31,53,人工智能
+一年级,周二十20,26,21,51,大数据
+二年级,钱三十84,45,57,28,软件工程
+二年级,郑二十三79,23,80,45,人工智能
+一年级,郑十16,35,29,51,大数据
+一年级,赵六21,83,80,16,大数据
+一年级,周十五52,2,37,6,人工智能
+二年级,吴二十八85,44,30,91,软件工程
+二年级,王十八76,40,14,96,人工智能
+一年级,郑十七97,54,90,0,软件工程
+二年级,王十八72,55,6,16,大数据
+一年级,钱十三0,80,95,78,人工智能
+一年级,孙八43,26,55,46,软件工程
+二年级,郑十七37,84,49,22,大数据
+一年级,孙八80,76,16,27,大数据
+二年级,郑十七41,29,38,8,软件工程
+二年级,张三41,96,72,91,人工智能
+二年级,郑二十三50,23,41,20,软件工程
+一年级,钱十九69,12,14,88,人工智能
+二年级,王十二9,5,82,72,人工智能
+二年级,郑十61,56,8,44,软件工程
+二年级,王二十四90,75,8,29,人工智能
+二年级,钱七81,93,87,84,软件工程
+二年级,王二十四77,90,21,26,人工智能
+一年级,吴二十八25,97,91,97,大数据
+一年级,郑二十三22,53,1,51,人工智能
+二年级,周九10,11,1,53,人工智能
+一年级,王二十四69,63,30,38,大数据
+一年级,周九12,96,95,6,人工智能
+一年级,周二十七68,65,62,98,软件工程
+一年级,王十八93,85,98,77,人工智能
+一年级,周二十七46,37,83,23,人工智能
+二年级,钱七54,85,75,91,大数据
+二年级,郑十七57,64,26,72,大数据
+一年级,王五14,84,16,48,软件工程
+一年级,钱三十36,84,21,51,大数据
+二年级,吴十25,29,15,92,大数据
+二年级,赵六59,34,0,34,人工智能
+一年级,周二十七56,27,30,62,人工智能
+二年级,周二十七22,2,85,37,大数据
+一年级,郑二十九70,61,71,12,软件工程
+二年级,李四83,40,56,77,人工智能
+一年级,王二十四31,24,19,41,大数据
+二年级,郑二十三42,16,61,84,大数据
+一年级,钱二十五14,65,94,90,大数据
+一年级,吴二十八3,47,5,98,人工智能
+二年级,张三48,18,89,68,大数据
+一年级,郑十44,0,25,59,大数据
+二年级,吴二十二1,50,56,11,软件工程
+二年级,钱三十10,23,29,11,大数据
+一年级,李四61,87,25,21,软件工程
+一年级,吴十77,63,85,33,人工智能
+一年级,张三49,73,37,97,大数据
+一年级,郑十七34,95,55,62,人工智能
+二年级,吴二十八14,18,96,95,大数据
+一年级,李四19,68,58,63,软件工程
+二年级,钱十九59,90,74,43,大数据
+一年级,周九7,93,67,64,人工智能
+一年级,钱十九28,99,29,0,软件工程
+一年级,孙二十18,0,36,64,人工智能
+二年级,周十五35,45,72,24,人工智能
+二年级,孙八79,83,32,58,软件工程
+二年级,郑十58,81,82,83,人工智能
+二年级,郑二十九16,9,0,86,人工智能
+一年级,周二十44,41,22,32,大数据
+一年级,孙二十六67,52,3,93,人工智能
+一年级,张三77,10,57,52,软件工程
+二年级,郑十98,40,18,46,大数据
+二年级,王二十四63,45,3,53,软件工程
+二年级,郑十23,15,5,67,软件工程
+一年级,郑十35,74,75,67,大数据
+二年级,孙二十92,26,64,51,人工智能
+二年级,吴二十八35,76,25,82,人工智能
+二年级,孙八85,72,21,33,大数据
+二年级,张三60,56,78,46,大数据
+一年级,郑十七7,56,61,38,人工智能
+一年级,王十八30,90,23,41,大数据
+二年级,钱十九19,42,50,49,大数据
+一年级,周二十7,81,86,46,软件工程
+二年级,王十八10,15,2,86,大数据
+一年级,孙二十98,37,72,1,人工智能
+二年级,吴二十八38,44,7,70,软件工程
+二年级,钱十三73,42,55,10,大数据
+二年级,王五18,75,74,61,人工智能
+一年级,孙二十76,70,29,33,人工智能
+二年级,钱七97,5,15,33,人工智能
+二年级,孙二十六82,74,8,74,大数据
+一年级,赵六46,76,17,42,人工智能
+二年级,孙八38,82,63,6,人工智能
+一年级,孙十四5,13,2,16,软件工程
+二年级,周二十七36,1,6,87,大数据
+一年级,王五19,98,10,19,软件工程
+一年级,吴二十二59,43,6,51,大数据
+一年级,周十五4,2,15,58,人工智能
+二年级,王十二15,23,24,87,软件工程
+一年级,孙十四26,55,89,56,大数据
+一年级,吴十六73,21,31,3,人工智能
+一年级,孙二十87,67,99,19,人工智能
+二年级,吴十66,91,88,95,人工智能
+二年级,周二十14,24,20,26,人工智能
+一年级,张三17,77,5,43,人工智能
+二年级,周九72,23,36,32,大数据
+二年级,郑十78,20,24,98,大数据
+二年级,孙八35,52,95,21,软件工程
+二年级,吴二十八47,65,90,86,人工智能
+一年级,李四67,88,59,40,大数据
+二年级,郑十55,56,10,50,大数据
+一年级,赵六82,37,19,3,软件工程
+二年级,赵六6,10,73,56,人工智能
+一年级,孙八2,87,84,51,软件工程
+一年级,郑二十九27,63,97,55,人工智能
+一年级,王十二75,33,48,19,软件工程
+一年级,李四84,14,16,17,大数据
+二年级,吴二十八6,13,81,83,人工智能
+二年级,钱十三53,35,45,46,大数据
+二年级,吴二十二20,59,9,69,大数据
+二年级,郑二十三94,10,98,98,大数据
+一年级,吴二十二44,41,79,91,软件工程
+二年级,吴二十八89,55,12,97,大数据
+二年级,孙二十48,40,64,84,大数据
+一年级,钱十九26,20,29,3,大数据
+二年级,钱十三44,9,43,32,软件工程
+二年级,钱二十五4,42,57,61,人工智能
+一年级,郑十七15,12,87,22,大数据
+一年级,钱七63,59,67,61,软件工程
+二年级,孙二十0,77,1,74,软件工程
+一年级,吴十六16,47,75,82,大数据
+二年级,钱十九21,77,65,66,软件工程
+二年级,王十二94,29,42,96,人工智能
+一年级,周二十七69,83,42,90,人工智能
+二年级,周二十七62,97,23,9,大数据
+一年级,周二十七86,70,22,22,大数据
+二年级,孙二十16,93,16,41,人工智能
+二年级,王十八43,34,5,86,人工智能
+一年级,吴十10,8,13,37,大数据
+一年级,钱二十五85,83,11,21,人工智能
+一年级,王十八97,17,75,16,人工智能
+一年级,王五78,83,33,45,人工智能
+二年级,吴十六11,85,75,20,人工智能
+二年级,孙二十六92,41,26,44,人工智能
+一年级,孙二十76,93,88,24,人工智能
+二年级,郑二十九22,18,70,74,大数据
+一年级,周二十71,95,59,78,大数据
+二年级,钱七33,97,50,23,软件工程
+一年级,王十八55,54,79,45,人工智能
+一年级,李四68,35,26,45,人工智能
+一年级,王二十四67,51,65,49,软件工程
+二年级,王十二44,4,7,45,人工智能
+二年级,王十二28,59,83,42,人工智能
+二年级,钱三十45,31,2,56,人工智能
+一年级,郑十七10,84,20,41,软件工程
+一年级,吴十31,63,50,69,人工智能
+二年级,张三50,99,70,77,大数据
+二年级,张三89,74,98,37,软件工程
+一年级,郑二十九42,24,4,93,人工智能
+一年级,赵六14,70,89,59,大数据
+二年级,钱二十五85,85,68,41,大数据
+一年级,孙二十28,81,71,3,大数据
+一年级,钱七98,25,99,12,人工智能
+一年级,吴十六17,26,52,65,人工智能
+二年级,王十二90,81,60,80,软件工程
+二年级,郑二十三33,34,73,67,软件工程
+二年级,周十五41,22,39,53,软件工程
+二年级,孙十四68,89,46,34,人工智能
+二年级,郑二十九40,25,34,47,大数据
+一年级,孙十四86,90,97,22,软件工程
+一年级,王十八0,22,85,2,人工智能
+二年级,周二十58,92,36,34,人工智能
+一年级,钱二十五50,61,0,28,大数据
+二年级,钱二十五78,72,68,77,软件工程
+二年级,郑二十九47,75,17,61,软件工程
+一年级,王二十四73,71,66,40,大数据
+二年级,钱七78,79,6,2,人工智能
+二年级,孙十四46,48,14,24,人工智能
+二年级,孙十四51,30,71,17,大数据
+一年级,李四73,21,70,47,大数据
+二年级,王五35,68,44,17,软件工程
+一年级,钱二十五5,59,62,45,大数据
+二年级,孙八86,13,69,16,大数据
+一年级,钱二十五39,44,18,88,大数据
+二年级,钱二十五23,59,3,62,人工智能
+一年级,赵六66,15,75,77,人工智能
+一年级,钱二十五3,25,85,10,大数据
+二年级,孙十四4,58,82,10,大数据
+一年级,张三31,5,29,89,大数据
+一年级,王十二45,49,67,70,大数据
+二年级,钱三十53,46,97,18,软件工程
+一年级,孙二十六67,26,70,60,软件工程
+二年级,周二十17,63,87,45,人工智能
+二年级,吴十70,84,67,60,人工智能
+一年级,钱三十46,8,78,88,人工智能
+二年级,孙八10,4,95,40,大数据
+一年级,赵六74,26,59,79,人工智能
+一年级,张三68,3,15,95,大数据
+一年级,郑十七59,90,0,67,人工智能
+二年级,吴二十二83,61,23,32,人工智能
+一年级,孙八91,37,2,85,大数据
+一年级,钱十三35,57,5,59,软件工程
+一年级,郑十七70,18,27,92,人工智能
+一年级,吴十2,69,24,9,大数据
+一年级,周九59,60,50,26,软件工程
+一年级,吴二十八89,85,41,68,软件工程
+一年级,周二十七81,98,91,33,人工智能
+二年级,吴十49,91,44,58,人工智能
+一年级,王二十四73,82,69,80,大数据
+二年级,王五55,26,49,97,软件工程
+二年级,郑二十九52,70,30,3,软件工程
+二年级,吴二十八7,26,38,92,软件工程
+一年级,郑二十九79,27,26,85,人工智能
+二年级,王五6,64,29,39,大数据
+一年级,吴十六57,13,61,7,软件工程
+一年级,王十二3,1,29,38,大数据
+二年级,孙十四20,11,24,82,人工智能
+一年级,周十五28,10,33,3,人工智能
+一年级,吴十六63,89,69,65,软件工程
+一年级,周九79,69,58,92,大数据
+二年级,李四24,11,49,27,大数据
+二年级,钱三十97,96,79,33,软件工程
+一年级,周十五41,61,87,3,软件工程
+一年级,张三90,32,43,90,大数据
+二年级,孙十四57,41,91,1,人工智能
+一年级,王五86,96,10,99,人工智能
+一年级,赵六21,40,59,27,人工智能
+一年级,郑二十九79,10,18,86,软件工程
+一年级,王五79,40,71,54,软件工程
+一年级,孙八51,9,12,54,软件工程
+一年级,王十二75,93,50,93,软件工程
+二年级,周二十七19,44,16,43,人工智能
+二年级,钱二十五52,11,18,32,大数据
+一年级,郑二十九25,99,58,34,大数据
+二年级,钱十九84,74,12,29,大数据
+二年级,周二十62,96,34,78,人工智能
+一年级,周十五44,41,94,2,软件工程
+一年级,王二十四78,41,14,88,大数据
+一年级,吴十48,6,25,90,大数据
+一年级,王五18,35,19,85,软件工程

JavaSE/day19/src/com/day19/io01/Test01.java

@@ -0,0 +1,24 @@
+package com.day19.io01;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 9:44
+ * @Version 1.0
+ */
+public class Test01 {
+
+    public static void main(String[] args) throws FileNotFoundException {
+        //文件字节输入
+        //fiel
+        FileInputStream fis = new FileInputStream(new File("day19\\file\\a.txt"));
+
+        //字符串
+        FileInputStream fis1 = new FileInputStream("day19\\file\\a.txt");
+    }
+}

JavaSE/day19/src/com/day19/io01/Test02.java

@@ -0,0 +1,36 @@
+package com.day19.io01;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 9:44
+ * @Version 1.0
+ */
+public class Test02 {
+
+    public static void main(String[] args) throws IOException {
+        //文件字节输入
+        FileInputStream fis = new FileInputStream("day19\\file\\a.txt");
+
+        //读取
+        // 为什么返回int类型值。而不是byte类型?
+        int i = fis.read();
+        System.out.println(i); // 97
+        int i1 = fis.read();
+        System.out.println(i1);
+        int i2 = fis.read();
+        System.out.println(i2);
+
+        int i3 = fis.read();
+        System.out.println(i3); //  读取不到 返回 -1
+
+        //释放资源
+        fis.close();
+    }
+}

JavaSE/day19/src/com/day19/io01/Test03.java

@@ -0,0 +1,48 @@
+package com.day19.io01;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 9:44
+ * @Version 1.0
+ */
+public class Test03 {
+
+    public static void main(String[] args) throws IOException {
+        //循环读取文件
+        FileInputStream fis = new FileInputStream("day19\\file\\a.txt");
+
+        //数组
+        byte[] bytes = new byte[1024];
+        int len = 0;
+        while (  (len = fis.read(bytes) ) != -1 ){
+            //转化 字符串
+            System.out.print(new String(bytes , 0 , len));
+        }
+
+        //释放资源
+        fis.close();
+    }
+    public static void main1(String[] args) throws IOException {
+        //文件字节输入
+        FileInputStream fis = new FileInputStream("day19\\file\\a.txt");
+
+        //数组
+        byte[] bytes = new byte[1024];
+
+        int i = fis.read(bytes);
+        System.out.println(i);
+
+        //字节怎么转换为String
+        String s = new String(bytes);
+        System.out.println(s);
+
+        //释放资源
+        fis.close();
+    }
+}

JavaSE/day19/src/com/day19/io01/Test04.java

@@ -0,0 +1,37 @@
+package com.day19.io01;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 9:44
+ * @Version 1.0
+ */
+public class Test04 {
+
+    public static void main(String[] args) throws IOException {
+        //循环读取文件
+        FileInputStream fis = new FileInputStream("day19\\file\\b.txt");
+
+        //数组
+        byte[] bytes = new byte[2];
+
+        int l1 = fis.read(bytes);
+        System.out.println(l1);
+        System.out.println(Arrays.toString(bytes));
+
+        int l2 = fis.read(bytes);
+        System.out.println(l2); //读取到一个
+        System.out.println(Arrays.toString(bytes));
+
+        new String(bytes,0,1);
+
+        //释放资源
+        fis.close();
+    }
+
+}

JavaSE/day19/src/com/day19/io02/Test01.java

@@ -0,0 +1,32 @@
+package com.day19.io02;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 10:33
+ * @Version 1.0
+ */
+public class Test01 {
+    public static void main(String[] args) throws IOException {
+        //输入流
+        FileOutputStream fos = new FileOutputStream("day19\\file\\c.txt",true); //追加
+
+        //写出
+        fos.write(97);
+        fos.write(98);
+        fos.write(99);
+        fos.write(100); // abcd  覆盖
+
+        //写出数组
+        byte[] bytes = {65, 66, 67, 68, 69};
+
+        fos.write(bytes,0,4);
+
+        fos.close();
+    }
+}

JavaSE/day19/src/com/day19/io02/Test02.java

@@ -0,0 +1,35 @@
+package com.day19.io02;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/**
+ * ClassName: Test02
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 10:39
+ * @Version 1.0
+ */
+public class Test02 {
+    public static void main(String[] args) throws Exception {
+        //实现复制效果
+        // 将a.txt 复制到 桌面 a.md
+        FileInputStream fis = new FileInputStream("day19\\file\\a.txt");
+        FileOutputStream fos = new FileOutputStream("C:\\Users\\erga\\Desktop\\file123\\a.md");
+
+        //数组
+        byte[] bytes = new byte[1024];
+        int len;
+
+        while ( ( len = fis.read(bytes) ) != -1 ){
+            //循环输出
+            fos.write(bytes, 0, len);
+        }
+
+        System.out.println(len);
+        //关闭流
+        fos.close();
+        fis.close();
+
+    }
+}

JavaSE/day19/src/com/day19/io03/Test01.java

@@ -0,0 +1,27 @@
+package com.day19.io03;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 11:32
+ * @Version 1.0
+ */
+public class Test01 {
+
+    public static void main(String[] args) throws IOException {
+        // 创建流对象
+        FileReader fr = new FileReader("day19\\file\\a.txt");
+        // 数组
+        char[] chars = new char[1024];
+        fr.read(chars);
+
+        System.out.println(new String(chars));
+
+        fr.close();
+    }
+}

JavaSE/day19/src/com/day19/io03/Test02.java

@@ -0,0 +1,28 @@
+package com.day19.io03;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 11:32
+ * @Version 1.0
+ */
+public class Test02 {
+
+    public static void main(String[] args) throws IOException {
+        // 创建流对象
+        FileReader fr = new FileReader("day19\\file\\d.txt") ;// 指定字符编码
+        // 数组
+        char[] chars = new char[1024];
+        fr.read(chars);
+
+        System.out.println(new String(chars));
+
+        fr.close();
+    }
+}

JavaSE/day19/src/com/day19/io03/Test03.java

@@ -0,0 +1,24 @@
+package com.day19.io03;
+
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 11:32
+ * @Version 1.0
+ */
+public class Test03 {
+
+    public static void main(String[] args) throws IOException {
+        //写出
+        FileWriter fw = new FileWriter("day19\\file\\e.txt");
+
+        fw.write("你好  世界\n\t");
+        fw.write(" hello world");
+        fw.close();
+    }
+}

JavaSE/day19/src/com/day19/io04/Test01.java

@@ -0,0 +1,37 @@
+package com.day19.io04;
+
+import java.io.*;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 13:41
+ * @Version 1.0
+ */
+public class Test01 {
+    public static void main(String[] args) throws Exception {
+
+        long start = System.currentTimeMillis();
+
+        //缓冲流
+        FileInputStream fis = new FileInputStream("C:\\Users\\erga\\Desktop\\video\\1.mp4");
+        BufferedInputStream bis = new BufferedInputStream(fis);
+        FileOutputStream fos = new FileOutputStream("C:\\Users\\erga\\Desktop\\file123\\2.msp4");
+        BufferedOutputStream bos = new BufferedOutputStream(fos);
+
+        int  l = 0;
+        byte[] bytes = new byte[1024];
+
+        while ( (l = bis.read(bytes) ) != -1){
+            bos.write(bytes,0,l);
+        }
+
+        bos.close();
+        bis.close();
+
+        long end = System.currentTimeMillis();
+
+        System.out.println(end - start);
+    }
+}

JavaSE/day19/src/com/day19/io04/Test02.java

@@ -0,0 +1,40 @@
+package com.day19.io04;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 13:41
+ * @Version 1.0
+ */
+public class Test02 {
+    public static void main(String[] args) throws Exception {
+        //实现复制效果
+        long start = System.currentTimeMillis();
+        FileInputStream fis = new FileInputStream("C:\\Users\\erga\\Desktop\\video\\1.mp4");
+        FileOutputStream fos = new FileOutputStream("C:\\Users\\erga\\Desktop\\file123\\2.mp4");
+
+        //数组
+        byte[] bytes = new byte[2];
+        int len;
+
+        while ( ( len = fis.read(bytes) ) != -1 ){
+            //循环输出
+            fos.write(bytes, 0, len);
+            //fos.write(len);
+        }
+
+        long end = System.currentTimeMillis();
+
+        System.out.println(end - start);
+        //关闭流
+        fos.close();
+        fis.close();
+
+    }
+}

JavaSE/day19/src/com/day19/io05/Test.java

@@ -0,0 +1,32 @@
+package com.day19.io05;
+
+import java.io.*;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 14:32
+ * @Version 1.0
+ */
+public class Test {
+
+    public static void main(String[] args) throws Exception {
+        //缓冲字符流
+        BufferedReader br = new BufferedReader(new FileReader("day19\\file\\a.txt"));
+        BufferedWriter bw = new BufferedWriter(new FileWriter("day19\\file\\f.txt"));
+
+        String str = null;
+
+        //循环读写
+        while ( (str = br.readLine()) != null ){
+            bw.write(str);
+            bw.newLine();
+        }
+
+        bw.close();
+        br.close();
+
+    }
+
+}

JavaSE/day19/src/com/day19/io05/Test02.java

@@ -0,0 +1,51 @@
+package com.day19.io05;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * ClassName: Test02
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:00
+ * @Version 1.0
+ */
+public class Test02 {
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new FileReader("day19\\file\\b.txt"));
+        BufferedWriter bw = new BufferedWriter(new FileWriter("day19\\file\\出师表.txt"));
+
+        //集合
+        List<String> list = new ArrayList<>();
+
+        String str = null;
+        while (  (str = br.readLine() ) != null   ){
+            list.add(str);
+        }
+
+        //排序
+        Collections.sort(list,new Comparator<String>(){
+            @Override
+            public int compare(String o1, String o2) {
+                return o1.charAt(0) - o2.charAt(0);
+            }
+        });
+
+        //输出
+        for (String s : list) {
+            bw.write(s);
+            bw.newLine();
+
+        }
+
+        bw.close();
+        br.close();
+
+    }
+}

JavaSE/day19/src/com/day19/io05/Test03.java

@@ -0,0 +1,23 @@
+package com.day19.io05;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.*;
+
+/**
+ * ClassName: Test02
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:00
+ * @Version 1.0
+ */
+public class Test03 {
+    public static void main(String[] args) throws Exception {
+       String s = "123a12314235";
+        String[] split = s.split("a");//特殊符号
+        System.out.println(Arrays.toString(split));
+
+    }
+}

JavaSE/day19/src/com/day19/io06/Test01.java

@@ -0,0 +1,36 @@
+package com.day19.io06;
+
+import java.io.FileWriter;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:32
+ * @Version 1.0
+ */
+public class Test01 {
+
+    public static void main(String[] args) throws Exception {
+
+        String s1 = "123";
+        String s2 = "123";
+        String s3 = "123";
+        String s4 = "123";
+
+        FileWriter fw = new FileWriter("day19\\file\\h.txt");
+
+        fw.write(s1);
+        fw.flush(); //刷新缓冲区
+        fw.write(s2);
+        fw.flush();
+        fw.write(s3);
+        fw.flush();
+
+        //写出到缓冲区
+
+        fw.close();
+        //在关闭时  看缓冲区是否有内容，有内容 刷出。
+
+    }
+}

JavaSE/day19/src/com/day19/io06/Test02.java

@@ -0,0 +1,33 @@
+package com.day19.io06;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:32
+ * @Version 1.0
+ */
+public class Test02 {
+
+    public static void main(String[] args) throws Exception {
+
+
+        FileWriter fw = new FileWriter("day19\\file\\h.txt");
+
+        BufferedWriter bw = new BufferedWriter(fw);
+
+        bw.write("hello");
+
+        //fw.close();
+        bw.close();
+
+        //流的关闭顺序。 开 内 外  关  外 内
+        // 12 21;
+
+        //关闭最外边的流。
+
+    }
+}

JavaSE/day19/src/com/day19/io07/Test01.java

@@ -0,0 +1,29 @@
+package com.day19.io07;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:45
+ * @Version 1.0
+ */
+public class Test01 {
+
+
+    public static void main(String[] args) throws Exception {
+
+        FileReader fr = new FileReader("C:\\Users\\erga\\Desktop\\file\\a.txt");
+        BufferedReader br = new BufferedReader(fr);
+
+        String s = br.readLine();
+
+        //UTF-8
+        System.out.println(s);
+
+
+    }
+}

JavaSE/day19/src/com/day19/io07/Test02.java

@@ -0,0 +1,36 @@
+package com.day19.io07;
+
+import java.io.*;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 15:45
+ * @Version 1.0
+ */
+public class Test02 {
+
+
+    public static void main(String[] args) throws Exception {
+        //字节流
+        FileInputStream fis = new FileInputStream("C:\\Users\\erga\\Desktop\\file\\a.txt");
+        //字符流
+        InputStreamReader isr = new InputStreamReader(fis,"GBK");
+        //缓冲流
+        BufferedReader br = new BufferedReader(isr);
+
+        String s = br.readLine();
+
+        br.close();
+
+        //写出
+        FileOutputStream fos = new FileOutputStream("C:\\Users\\erga\\Desktop\\file\\b.txt");
+        OutputStreamWriter osw = new OutputStreamWriter(fos);
+
+        osw.write(s);
+        osw.close();
+
+
+    }
+}

JavaSE/day19/src/com/day19/io08/Test01.java

@@ -0,0 +1,31 @@
+package com.day19.io08;
+
+import java.io.FileInputStream;
+import java.util.Properties;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 16:06
+ * @Version 1.0
+ */
+public class Test01 {
+    public static void main(String[] args) throws Exception {
+        //输入流
+        FileInputStream fis = new FileInputStream("day19\\file\\jdbc.properties");
+
+        Properties properties = new Properties();
+        //读取
+        properties.load(fis);
+
+        //获取
+        String username = properties.getProperty("username");
+        String password = properties.getProperty("password");
+
+        System.out.println(username);
+        System.out.println(password);
+
+        fis.close();
+    }
+}

JavaSE/day19/src/com/day19/io08/Test02.java

@@ -0,0 +1,35 @@
+package com.day19.io08;
+
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.util.Properties;
+import java.util.Random;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/17 16:06
+ * @Version 1.0
+ */
+public class Test02 {
+    public static void main(String[] args) throws Exception {
+        FileWriter fw = new FileWriter("day19\\file\\成绩单.txt");
+
+        fw.write("年级,姓名,软件工程,大数据,人工智能,专业"+"\n");
+
+        char[] s = {'一','二','三'};
+
+        String[] majoy = {"软件工程","大数据","人工智能"};
+
+        String[] student = {"张三","李四","王五","赵六","钱七","孙八","周九","吴十","郑十","王十二","钱十三","孙十四","周十五","吴十六","郑十七","王十八","钱十九","孙二十","周二十","吴二十二","郑二十三","王二十四","钱二十五","孙二十六","周二十七","吴二十八","郑二十九","钱三十"};
+
+        for (int i = 0; i < 500; i++) {
+            fw.write(
+                    s[(new Random().nextInt(2))]+"年级,"+student[new Random().nextInt(student.length)]+""+new Random().nextInt(100)+  ","+new Random().nextInt(100)+","+new Random().nextInt(100)+","+new Random().nextInt(100)+","+majoy[new Random().nextInt(3)]+"\n");
+        }
+
+        fw.close();
+
+    }
+}

JavaSE/day20/day20.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library" exported="">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13.1/junit-4.13.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

JavaSE/day20/src/com/lc/day20/anno05/MyAnnotion.java

@@ -0,0 +1,19 @@
+package com.lc.day20.anno05;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * ClassName: MyAnnotion
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 16:46
+ * @Version 1.0
+ */
+
+
+public @interface MyAnnotion {
+    String value() default  "";
+}

JavaSE/day20/src/com/lc/day20/anno05/Person.java

@@ -0,0 +1,17 @@
+package com.lc.day20.anno05;
+
+/**
+ * ClassName: Person
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 16:47
+ * @Version 1.0
+ */
+
+@MyAnnotion(value = "t_person")
+public class Person {
+
+    @MyAnnotion(value = "zhangsan")
+    public String name;
+
+}

JavaSE/day20/src/com/lc/day20/anno05/Test01.java

@@ -0,0 +1,58 @@
+package com.lc.day20.anno05;
+
+import org.junit.Test;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 16:42
+ * @Version 1.0
+ */
+public class Test01 {
+
+    @Test
+    public void test01() throws Exception{
+        Class<Person> personClass = Person.class;
+
+        //获取
+        Field name = personClass.getDeclaredField("name");
+        //现在获取不到 没有加 原注解 在 jdbc讲
+        MyAnnotion annotation = name.getAnnotation(MyAnnotion.class);
+        System.out.println(annotation);
+    }
+
+    @Test
+    public void test8(){
+        /*
+          <R> Stream<R> map(Function<? super T, ? extends R> mapper);
+                T类型->R类型对象
+         <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
+                T类型->Stream<R>流
+         */
+        Stream.of("hello","java","world")  //把所有单词的每一个字母取出来
+//                .flatMap(s-> Arrays.stream(s.split("|")))
+                //.flatMap(s -> )
+                .forEach(t-> System.out.println(t));
+
+
+        String s = "hello";
+        String[] split = s.split("|");
+        System.out.println(Arrays.toString(split));
+    }
+
+    /**
+     * 展示方法
+     * @param a int类型
+     * @param b String 代表名称
+     * @return
+     */
+    public int show(int a, String b){
+        return 0;
+    }
+}

JavaSE/day20/src/com/lc/day20/recf02/Person.java

@@ -0,0 +1,12 @@
+package com.lc.day20.recf02;
+
+/**
+ * ClassName: Person
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 10:49
+ * @Version 1.0
+ */
+public class Person {
+
+}

JavaSE/day20/src/com/lc/day20/recf02/Test01.java

@@ -0,0 +1,54 @@
+package com.lc.day20.recf02;
+
+import org.junit.Test;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 10:49
+ * @Version 1.0
+ */
+public class Test01 {
+
+    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
+
+        //CLass.forName
+        Class clazz = Class.forName("com.lc.day20.recf02.Person");
+
+        Object o = clazz.newInstance();
+
+        //Person对象
+        System.out.println(o);
+    }
+
+    @Test
+    public void test01() throws Exception{
+        //获取class
+        Class clazz = Test01.class;
+
+        InputStream is = clazz.getClassLoader().getResourceAsStream("jdbc.properties");
+
+        Properties properties = new Properties();
+        properties.load(is);
+
+        String property = properties.getProperty("person");
+
+        Class clazz1 = Class.forName(property);
+        Object o = clazz1.newInstance();
+
+        System.out.println(o);
+    }
+
+    @Test
+    public void test03(){
+        Person person = new Person();
+        //getClass
+        Class aClass = person.getClass();
+
+        System.out.println(aClass);
+    }
+}

JavaSE/day20/src/com/lc/day20/recf02/Test02.java

@@ -0,0 +1,15 @@
+package com.lc.day20.recf02;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 10:49
+ * @Version 1.0
+ */
+public class Test02 {
+
+    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
+
+    }
+}

JavaSE/day20/src/com/lc/day20/recf03/Person.java

@@ -0,0 +1,46 @@
+package com.lc.day20.recf03;
+
+import java.util.Comparator;
+
+/**
+ * ClassName: Person
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 13:37
+ * @Version 1.0
+ */
+public class Person extends Object implements Comparable<Person> , Comparator<Person> {
+
+    private String name;
+    private int age;
+
+    public Person() {
+    }
+
+    public Person(String name) {
+        this.name = name;
+    }
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    @Override
+    public int compareTo(Person o) {
+        return 0;
+    }
+
+    @Override
+    public int compare(Person o1, Person o2) {
+        return 0;
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                '}';
+    }
+}

JavaSE/day20/src/com/lc/day20/recf03/Test01.java

@@ -0,0 +1,115 @@
+package com.lc.day20.recf03;
+
+import org.junit.Test;
+
+import java.lang.reflect.*;
+import java.util.Arrays;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 13:39
+ * @Version 1.0
+ */
+public class Test01 {
+
+    @Test
+    public void test01() throws Exception {
+
+        Class<Person> clazz = Person.class;
+
+        //class api
+        String name = clazz.getName();
+        System.out.println("类名："+name);
+
+        //Constructor api
+        Constructor<Person> constructorName = clazz.getConstructor(String.class);
+
+        //修饰符
+        int modifiers = constructorName.getModifiers();
+        System.out.println(Modifier.toString(modifiers));
+
+        Person kunkun = constructorName.newInstance("坤坤");
+        System.out.println(kunkun);
+
+
+        //获取所有的构造
+        Constructor<?>[] constructors = clazz.getConstructors();
+
+        for (Constructor<?> constructor : constructors) {
+            System.out.println(constructor);
+        }
+
+        System.out.println("------------");
+
+
+        //属性 字段
+        //Field nameFiled = clazz.getField("name"); //获取私有的
+        Field nameFiled = clazz.getDeclaredField("name");
+        //暴力破解
+        nameFiled.setAccessible(true);
+        //获取
+        Object o = nameFiled.get(kunkun);
+        //值
+        System.out.println(o);
+
+
+        Field[] declaredFields = clazz.getDeclaredFields();
+
+        for (Field declaredField : declaredFields) {
+            System.out.println(declaredField);
+        }
+
+        System.out.println("------------");
+        Method compareTo = clazz.getDeclaredMethod("compareTo", Person.class);
+
+        System.out.println(compareTo);
+
+        Object num = compareTo.invoke(kunkun, new Person("凡凡"));
+        System.out.println(num);
+
+        //获取所有的方法
+        Method[] declaredMethods = clazz.getDeclaredMethods();
+
+        for (Method method : declaredMethods) {
+            System.out.println(method);
+        }
+
+        System.out.println("------------");
+        //父类
+        Class<? super Person> superclass = clazz.getSuperclass();
+        System.out.println(superclass);
+
+        //接口
+        Class<?>[] interfaces = clazz.getInterfaces();
+
+        for (Class<?> anInterface : interfaces) {
+            System.out.println(anInterface);
+
+        }
+
+        Type[] genericInterfaces = clazz.getGenericInterfaces();
+        for (Type genericInterface : genericInterfaces) {
+            Type t = ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
+            System.out.println(t.getTypeName());
+            //泛型
+            Class<?> aClass = Class.forName(t.getTypeName());
+
+            //System.out.println(Arrays.toString(aClass.getDeclaredFields()));
+
+        }
+
+        //反射创建数组
+        String[] o1 = (String[]) Array.newInstance(String.class, 10);
+
+        o1[0] = "坤坤";
+
+        //反射
+        Array.set(o1,1, "凡凡");
+        System.out.println(Arrays.toString(o1));
+
+
+    }
+
+}

JavaSE/day20/src/com/lc/day20/recf04/Person.java

@@ -0,0 +1,65 @@
+package com.lc.day20.recf04;
+
+/**
+ * ClassName: Person
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 15:09
+ * @Version 1.0
+ */
+public class Person {
+
+    private String name;
+    private int age;
+    private char sex;
+
+    private Object obj;
+
+    public Person() {
+    }
+
+    public Person(String name, int age, char sex) {
+        this.name = name;
+        this.age = age;
+        this.sex = sex;
+    }
+
+    public String getName() {
+        System.out.println("getName");
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public char getSex() {
+        return sex;
+    }
+
+    public void setSex(char sex) {
+        this.sex = sex;
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                ", sex=" + sex +
+                '}';
+    }
+
+
+    public static  void show(){
+        System.out.println("show");
+    }
+}

JavaSE/day20/src/com/lc/day20/recf04/Test01.java

@@ -0,0 +1,46 @@
+package com.lc.day20.recf04;
+
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 15:05
+ * @Version 1.0
+ */
+public class Test01 {
+    @Test
+    public void test02() throws Exception {
+        Class<Person> personClass = Person.class;
+
+        Person p = personClass.newInstance();
+        System.out.println(p);
+
+        //无参数
+        Constructor<Person> constructor = personClass.getConstructor();
+        //无参数
+        Person person = constructor.newInstance();
+
+        System.out.println(person);
+
+    }
+
+    @Test
+    public void test01() throws Exception{
+
+        Class<Person> personClass = Person.class;
+
+        //获取构造
+        Constructor<Person> constructor = personClass.getConstructor(String.class, int.class, char.class);
+
+        //执行
+        Person person = constructor.newInstance("", 0, '0');
+
+        System.out.println(person);
+
+    }
+}

JavaSE/day20/src/com/lc/day20/recf04/Test02.java

@@ -0,0 +1,80 @@
+package com.lc.day20.recf04;
+
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 15:05
+ * @Version 1.0
+ */
+public class Test02 {
+
+
+    @Test
+    public void test01() throws Exception{
+        //class
+        Class<Person> clazz = Person.class;
+
+        Person person = clazz.newInstance();
+
+        //获取属性
+        Field name = clazz.getDeclaredField("name");
+
+        //设置 可暴力反射
+        name.setAccessible(true);
+
+        //获取
+        Object o = name.get(person);
+        System.out.println(o);
+
+        //赋值
+        name.set(person, "kunkun");
+
+        //获取
+        String s1 = (String) name.get(person);
+        System.out.println(s1);
+    }
+
+
+    @Test
+    public void test02() throws Exception{
+        //class
+        Class<Person> clazz = Person.class;
+
+        Person person = clazz.newInstance();
+
+        //获取属性
+        Field obj = clazz.getDeclaredField("obj");
+
+        //设置 可暴力反射
+        obj.setAccessible(true);
+
+        //赋值
+        obj.set(person, new Object());
+
+        //获取
+        Object o = obj.get(person);
+        System.out.println(o);
+    }
+
+    @Test
+    public void test03() throws Exception {
+        Class<Person> clazz = Person.class;
+
+        Person person = clazz.newInstance();
+
+        //获取属性
+        Field[] obj = clazz.getDeclaredFields();
+
+        for (Field field : obj) {
+            //get 在数据库 获取 field.getName()
+            //循环 赋值
+        }
+
+    }
+}

JavaSE/day20/src/com/lc/day20/recf04/Test03.java

@@ -0,0 +1,49 @@
+package com.lc.day20.recf04;
+
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 15:05
+ * @Version 1.0
+ */
+public class Test03 {
+
+
+    @Test
+    public void test01() throws Exception{
+        Class<Person> personClass = Person.class;
+
+        Person person = personClass.newInstance();
+
+        //获取方法
+        Method getName = personClass.getDeclaredMethod("getName");
+
+        //执行
+        Object invoke = getName.invoke(person);
+
+        System.out.println(invoke);
+
+    }
+
+
+    @Test
+    public void test02() throws Exception{
+        Class<Person> personClass = Person.class;
+        //静态方法
+        Method show = personClass.getDeclaredMethod("show");
+        //执行
+        Object invoke = show.invoke(null);
+        System.out.println(invoke);
+    }
+
+    @Test
+    public void test03() throws Exception {
+
+    }
+}

JavaSE/day20/src/com/lc/day20/test01/Test01.java

@@ -0,0 +1,54 @@
+package com.lc.day20.test01;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.abc.String;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 9:21
+ * @Version 1.0
+ */
+public class Test01 {
+
+    //写 普通方法
+    //上 @Test  Alt + 回车  提示 junit4
+    // 右键 运行方法
+    @Test
+    public void test01(){
+        String a;
+        System.out.println("test01");
+    }
+
+    @Test
+    public void test02(){
+        System.out.println("test02");
+    }
+
+
+    /*
+    - @Test，用于修饰需要执行的测试方法
+    - @Before，修饰的方法会在测试方法之前被自动执行
+    - @After，修饰的方法会在测试方法执行之后自动被执行
+     */
+
+    @Test
+    public void test03(){
+        System.out.println("测试目标方法");
+    }
+
+    @Before
+    public void before(){
+        System.out.println("目标方法 前执行");
+    }
+
+    @After
+    public void after(){
+        System.out.println("目标方法 后执行");
+    }
+
+}

JavaSE/day20/src/com/lc/day20/test01/Test02.java

@@ -0,0 +1,34 @@
+package com.lc.day20.test01;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.abc.String;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 9:21
+ * @Version 1.0
+ */
+public class Test02 {
+
+
+    @Test
+    public void test01(){
+        //应用类
+        System.out.println( "应用类加载器："+ ClassLoader.getSystemClassLoader());
+
+        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
+
+        //扩展
+        ClassLoader parent = classLoader.getParent();
+        System.out.println(parent);
+
+        //跟
+        ClassLoader parentParent = parent.getParent();
+        System.out.println(parentParent);
+    }
+}

JavaSE/day20/src/com/lc/day20/test01/Test03.java

@@ -0,0 +1,28 @@
+package com.lc.day20.test01;
+
+import org.junit.Test;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 9:21
+ * @Version 1.0
+ */
+public class Test03 {
+
+    @Test
+    public void test01() throws Exception{
+        //应用类加载器 classpath
+        InputStream is = Test03.class.getClassLoader().getResourceAsStream("jdbc.properties");
+        //propertes
+        Properties properties = new Properties();
+
+        properties.load(is);
+        //配置文件
+        System.out.println(properties);
+    }
+}

JavaSE/day20/src/java/abc/String.java

@@ -0,0 +1,11 @@
+package java.abc;
+
+/**
+ * ClassName: String
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/18 9:50
+ * @Version 1.0
+ */
+public class String {
+}

JavaSE/day20/src/jdbc.properties

@@ -0,0 +1,3 @@
+username=root
+password=123456
+person=com.lc.day20.recf02.Person

JavaSE/day21/day21.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13.1/junit-4.13.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

JavaSE/day21/src/com/lc/day21/lambda01/Test01.java

@@ -0,0 +1,89 @@
+package com.lc.day21.lambda01;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 9:32
+ * @Version 1.0
+ */
+public class Test01 {
+
+    @Test
+    public void test01(){
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("runnable");
+            }
+        }).start();
+
+        // 更关注方法的实现逻辑。
+
+        // 箭头函数  ->
+        new Thread(() -> System.out.println("lambda")).start();
+
+    }
+
+    @Test
+    public void test02(){
+        String[] arr = {"hello","java","hi","python","c++"};
+
+        //按照长度怕排序
+        Arrays.sort(arr, (s1,s2) -> s1.length() - s2.length());
+
+        //输出
+        System.out.println(Arrays.toString(arr));
+
+    }
+
+
+    @Test
+    public void test03(){
+        String[] arr = {"hello","java","hi","python","c++"};
+
+        //按照长度怕排序
+//        Arrays.sort(arr, new Comparator<String>() {
+//            @Override
+//            public int compare(String o1, String o2) {
+//                return o1.length() - o2.length();
+//            }
+//        });
+
+        // lambda
+        Arrays.sort(arr, (String o1, String o2)  ->  {return o1.length() - o2.length();} );
+
+        //输出
+        System.out.println(Arrays.toString(arr));
+    }
+
+    @Test
+    public void test04(){
+        /*
+        - 当{Lambda体}中只有一句语句时，并且这个语句还是一个return语句，那么{、return、;}三者可以省略。
+        - (形参列表)的数据类型可以省略。
+        - 形参个数只有一个，()可以省略，形参名不能省略。
+        - (形参列表)是空参时，()不能省略
+         */
+
+        String[] arr = {"hello","java","hi","python","c++"};
+        // lambda
+        Arrays.sort(arr, (String o1, String o2)  ->  {return o1.length() - o2.length();} );
+
+        Arrays.sort(arr, (String o1, String o2)  ->   o1.length() - o2.length() );
+
+        Arrays.sort(arr, (o1, o2)  ->   o1.length() - o2.length() );
+
+        //输出
+        System.out.println(Arrays.toString(arr));
+
+        //一个参数
+        Comparable<Integer> comparable =  o -> o * 2;
+    }
+
+}

JavaSE/day21/src/com/lc/day21/lambda01/Test02.java

@@ -0,0 +1,42 @@
+package com.lc.day21.lambda01;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 9:32
+ * @Version 1.0
+ */
+public class Test02 {
+
+    @Test
+    public void test01(){
+        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8);
+
+        ArrayList<Integer> list = new ArrayList<>(integers);
+
+        //删除
+        list.removeIf( e -> e % 2 == 0);
+
+        /*
+            boolean test(T t);
+         */
+
+        // 有一个元素 返回结果 是 boolean。
+        // test( T t )  返回 boolean。
+        // e -> e % 2 == 0
+
+        // 断言型接口
+
+
+
+    }
+
+}

JavaSE/day21/src/com/lc/day21/lambda02/MathFuntion.java

@@ -0,0 +1,17 @@
+package com.lc.day21.lambda02;
+
+/**
+ * ClassName: MathFuntion
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 11:12
+ * @Version 1.0
+ */
+@FunctionalInterface
+public interface MathFuntion {
+
+    //计算两个数
+    int calculate(int a, int b);
+
+
+}

JavaSE/day21/src/com/lc/day21/lambda02/Test01.java

@@ -0,0 +1,102 @@
+package com.lc.day21.lambda02;
+
+import org.junit.Test;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 10:48
+ * @Version 1.0
+ */
+public class Test01 {
+
+    @Test
+    public void test01(){
+        Consumer<String> consumer = new Consumer<>() {
+            @Override
+            public void accept(String s) {
+
+            }
+        };
+
+
+        //遍历
+        List<String> list = Arrays.asList("java","c","python","c++","VB","C#");
+
+        //消费型
+        list.forEach( s -> System.out.println(s));
+
+        //声明
+        Consumer<String> consumer1 = s -> System.out.println(s);
+
+        list.forEach(consumer1);
+    }
+
+
+    @Test
+    public void test02(){
+
+        Supplier<Integer> supplier = () -> (int) (Math.random()*100);
+
+        //提供
+        Integer i = supplier.get();
+        System.out.println(i);
+
+    }
+
+
+    @Test
+    public void test03(){
+
+        BiPredicate<String,Integer> flag = (s,i) -> Integer.parseInt(s) == i;
+
+        boolean test = flag.test("1", 2);
+        System.out.println(test);
+
+    }
+
+
+
+    @Test
+    public void test04(){
+        ArrayList<String> list = new ArrayList<>();
+        list.add("hello");
+        list.add("java");
+        list.add("world");
+        list.add("haha");
+
+        list.replaceAll( s -> s.toUpperCase());
+
+        list.forEach(s-> System.out.println(s));
+
+    }
+
+    @Test
+    public void test05(){
+        int math1 = math((a, b) -> a + b, 1, 2);
+        System.out.println(math1);
+
+
+        int math2 = math((a, b) -> a * b, 1, 2);
+        System.out.println(math2);
+
+        int math3 = math((a, b) -> a*a + b * b, 1, 2);
+        System.out.println(math3);
+    }
+
+
+    public int math( MathFuntion m , int a , int b){
+        return m.calculate(a,b);
+    }
+
+}

JavaSE/day21/src/com/lc/day21/lambda03/EmpManager.java

@@ -0,0 +1,57 @@
+package com.lc.day21.lambda03;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * ClassName: EmpManager
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 11:37
+ * @Version 1.0
+ */
+public class EmpManager {
+
+    public List<Employee> list = new ArrayList<>();
+
+    public void add(Employee emp){
+        list.add(emp);
+    }
+
+    public List<Employee> get(Predicate<Employee> p){
+        //lsit
+        List<Employee> employeeList = new ArrayList<>();
+
+        //for 循环集合内容
+        for (Employee employee : list) {
+            //符合条件添加
+            boolean test = p.test(employee);
+            if (test){
+                employeeList.add(employee);
+            }
+        }
+        return employeeList;
+    }
+
+    public void remove(Predicate<Employee> p){
+
+        //for 循环集合内容
+        for (Employee employee : list) {
+            //符合条件删除
+            boolean test = p.test(employee);
+            if (test){
+                list.remove(employee);
+            }
+        }
+    }
+
+    public void update(Consumer<Employee> c ){
+        for (Employee employee : list) {
+            //执行c指定的操作
+            c.accept(employee);
+        }
+    }
+
+}

JavaSE/day21/src/com/lc/day21/lambda03/Employee.java

@@ -0,0 +1,80 @@
+package com.lc.day21.lambda03;
+
+/**
+ * ClassName: Employee
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 11:35
+ * @Version 1.0
+ */
+public class Employee {
+
+    //编号、姓名、薪资、年龄、性别
+    private Integer id;
+    private String name;
+    private Double salary;
+    private Integer age;
+    private String gender;
+
+    public Employee() {
+    }
+
+    public Employee(Integer id, String name, Double salary, Integer age, String gender) {
+        this.id = id;
+        this.name = name;
+        this.salary = salary;
+        this.age = age;
+        this.gender = gender;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(Double salary) {
+        this.salary = salary;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public String getGender() {
+        return gender;
+    }
+
+    public void setGender(String gender) {
+        this.gender = gender;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", salary=" + salary +
+                ", age=" + age +
+                ", gender='" + gender + '\'' +
+                '}';
+    }
+}

JavaSE/day21/src/com/lc/day21/lambda03/Test01.java

@@ -0,0 +1,40 @@
+package com.lc.day21.lambda03;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * ClassName: Test
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 11:44
+ * @Version 1.0
+ */
+public class Test01 {
+
+    EmpManager manager = null;
+    @Before
+    public void before(){
+        manager = new EmpManager();
+
+        manager.add(new Employee(1,"zs",20000.0,20,"男"));
+        manager.add(new Employee(2,"ls",1400.0,23,"女"));
+        manager.add(new Employee(3,"ww",2000.0,21,"男"));
+        manager.add(new Employee(4,"zl",8000.0,32,"女"));
+        manager.add(new Employee(5,"c7",18900.0,27,"男"));
+        manager.add(new Employee(6,"w8",2200.0,20,"女"));
+
+    }
+
+
+    @Test
+    public void test01(){
+
+        List<Employee> list = manager.get( e -> e.getId() % 2 == 0 && e.getSalary() < 10000 && e.getAge() > 30 && e.getName().startsWith("z") );
+
+        //输出
+        list.forEach(System.out::println);
+    }
+}

JavaSE/day21/src/com/lc/day21/stream04/Employee.java

@@ -0,0 +1,95 @@
+package com.lc.day21.stream04;
+
+import java.util.Objects;
+
+/**
+ * ClassName: Employee
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 11:35
+ * @Version 1.0
+ */
+public class Employee {
+
+    //编号、姓名、薪资、年龄、性别
+    private Integer id;
+    private String name;
+    private Double salary;
+    private Integer age;
+    private String gender;
+
+    public Employee() {
+    }
+
+    public Employee(Integer id, String name, Double salary, Integer age, String gender) {
+        this.id = id;
+        this.name = name;
+        this.salary = salary;
+        this.age = age;
+        this.gender = gender;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Employee employee = (Employee) o;
+        return Objects.equals(id, employee.id) && Objects.equals(name, employee.name) && Objects.equals(salary, employee.salary) && Objects.equals(age, employee.age) && Objects.equals(gender, employee.gender);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, salary, age, gender);
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(Double salary) {
+        this.salary = salary;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public String getGender() {
+        return gender;
+    }
+
+    public void setGender(String gender) {
+        this.gender = gender;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", salary=" + salary +
+                ", age=" + age +
+                ", gender='" + gender + '\'' +
+                '}';
+    }
+}

JavaSE/day21/src/com/lc/day21/stream04/Test01.java

@@ -0,0 +1,62 @@
+package com.lc.day21.stream04;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 13:47
+ * @Version 1.0
+ */
+public class Test01 {
+
+    @Test
+    public void test01(){
+        /*
+        Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
+
+        * public default Stream<E> stream() : 返回一个顺序流
+        * public default Stream<E> parallelStream() : 返回一个并行流
+         */
+
+
+        List<Integer> integers = List.of(123, 1, 2, 423, 435, 34, 64, 57, 564, 785, 678, 67);
+        ArrayList<Integer> list = new ArrayList<>(integers);
+
+        Stream<Integer> stream = list.stream();
+        //操作
+        Stream<Integer> integerStream = stream.filter(e -> e > 100);
+
+        //终止
+        List<Integer> collect = integerStream.collect(Collectors.toList());
+
+        System.out.println(collect);
+
+        //循环
+
+
+        //链式操作
+        list.stream().filter( e -> e % 2 == 0).forEach(System.out::println);
+
+
+    }
+
+    @Test
+    public void test02(){
+        List<Integer> integers = List.of(123, 1, 2, 423, 435, 34, 64, 57, 564, 785, 678, 67);
+        ArrayList<Integer> list = new ArrayList<>(integers);
+
+        //并行流
+        Stream<Integer> integerStream = list.parallelStream();
+
+        integerStream.filter(e -> e > 100).forEach(System.out::println);
+    }
+
+
+}

JavaSE/day21/src/com/lc/day21/stream04/Test02.java

@@ -0,0 +1,58 @@
+package com.lc.day21.stream04;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 13:47
+ * @Version 1.0
+ */
+public class Test02 {
+
+    @Test
+    public void test01(){
+
+        int[] ints = {1, 2, 3, 4, 5};
+
+        // 1. 创建流
+        IntStream stream = Arrays.stream(ints);
+        // 2 终止输出
+        stream.forEach(System.out::println);
+
+    }
+
+
+    @Test
+    public void test02(){
+        //Stream.of
+        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 65, 7, 78, 8);
+
+        //终止操作
+        Set<Integer> collect = integerStream.filter(e -> e > 20).collect(Collectors.toSet());
+
+        System.out.println(collect);
+    }
+
+    @Test
+    public void test03(){
+        //无限流
+        //Stream.generate( ()->Math.random() ).forEach(System.out::println);
+
+        //iterate(final T seed, final UnaryOperator<T> f)
+
+        //seed 种子 0，
+        // UnaryOperator
+        Stream.iterate(1,e -> e + 2).limit(10).forEach(System.out::println);
+    }
+
+}

JavaSE/day21/src/com/lc/day21/stream04/Test03.java

@@ -0,0 +1,61 @@
+package com.lc.day21.stream04;
+
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 13:47
+ * @Version 1.0
+ */
+public class Test03 {
+
+    @Test
+    public void test01(){
+        List<Employee> employees = new ArrayList<>();
+        employees.add(new Employee(1,"zs",20000.0,20,"男"));
+        employees.add(new Employee(2,"ls",1400.0,23,"女"));
+        employees.add(new Employee(3,"ww",2000.0,21,"男"));
+        employees.add(new Employee(4,"zl",8000.0,32,"女"));
+        employees.add(new Employee(5,"c7",18900.0,27,"男"));
+        employees.add(new Employee(6,"w8",2200.0,20,"女"));
+        employees.add(new Employee(6,"w8",2200.0,20,"女"));
+
+
+        //Stream filter(Predicate p)接收 Lambda ， 从流中排除某些元素
+        //Stream distinct()筛选，通过流所生成元素的equals() 去除重复元素
+        //Stream limit(long maxSize)截断流，使其元素不超过给定数量
+        //Stream skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
+        //Stream peek(Consumer action)接收Lambda，对流中的每个数据执行Lambda体操作
+        //Stream sorted()产生一个新流，其中按自然顺序排序
+        //Stream map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
+        employees.stream()
+                .filter( e->e.getSalary() > 2000)
+                .distinct()
+                //.limit(3)
+                //.skip(2)
+                //.peek( e -> e.setSalary(e.getSalary() * 1.1))
+                .sorted( (e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary()))
+                //.map( e -> e.getName() )
+                .mapToInt( e -> e.getAge() )
+                .forEach(System.out::println);
+
+    }
+
+    @Test
+    public void test02(){
+
+        //把所有单词的每一个字母取出来
+        Stream.of("hello","java","c++","python","php")
+                .flatMap( s -> Arrays.stream(s.split("|"))  )
+                .forEach(System.out::println);
+    }
+
+}

JavaSE/day21/src/com/lc/day21/stream04/Test04.java

@@ -0,0 +1,80 @@
+package com.lc.day21.stream04;
+
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * ClassName: Test01
+ *
+ * @Author 爱扣钉-陈晨
+ * @Create 2024/1/19 13:47
+ * @Version 1.0
+ */
+public class Test04 {
+
+    /*
+    boolean**allMatch(Predicate p)**检查是否匹配所有元素
+    boolean**anyMatch**(**Predicate p**)检查是否至少匹配一个元素
+    boolean**noneMatch(Predicate  p)**检查是否没有匹配所有元素
+     */
+    @Test
+    public void test01(){
+        boolean b = Stream.of(2, 4, 6, 8)
+                //.allMatch(n -> n % 2 == 0);
+                //.anyMatch(n -> n == 2 );
+                .noneMatch(n -> n== 10);
+        System.out.println(b);
+
+    }
+
+    /*
+    Optional<T>**findFirst()**返回第一个元素
+    Optional<T>**findAny()**返回当前流中的任意元素
+     */
+    @Test
+    public void test02(){
+        //Optional解决空指针
+//        Optional<Integer> first = Stream.of(2, 4, 6, 8)
+//                .findFirst();
+
+        Optional<Integer> any = Stream.of(2, 4, 6, 8)
+                .findAny();
+
+        System.out.println(any);
+    }
+
+    /*
+    long**count()**返回流中元素总数
+     */
+    @Test
+    public void test03(){
+        long count = Stream.of(2, 4, 6, 8).count();
+        System.out.println(count);
+    }
+
+    /*
+    T**reduce(T iden, BinaryOperator b)**将流中元素反复结合起来，得到一个值。返回 T
+     */
+    @Test
+    public void test04(){
+        Integer reduce = Stream.of(2, 4, 6, 8).reduce(0, (n1, n2) -> n1 + n2);
+        System.out.println(reduce);
+    }
+
+
+    //**collect
+
+    @Test
+    public void test05(){
+        Map<Integer, String> collect = Stream.of(1, 2, 3, 4, 5, 6)
+                .collect(Collectors.toMap(i -> i, i -> "第" + i + "个元素"));
+
+        System.out.println(collect);
+    }
+
+
+}