diff --git a/IO流.md b/IO流.md
new file mode 100644
index 0000000..07454e0
--- /dev/null
+++ b/IO流.md
@@ -0,0 +1,236 @@
+# IO流体系结构
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251223143732944.png" alt="image-20251223143723814" style="zoom: 50%;" />
+
+# 字节流：
+
+## FileOutPutStream 字节输出流
+
+### 构造方法和成员方法和注意事项：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251223145353953.png" alt="image-20251223145352942" style="zoom:67%;" />
+
+### 成员方法
+
+![image-20251223145424559](https://gitee.com/icecat2233/picture/raw/master/20251223145427575.png)
+
+### IO流的异常处理方式
+
+![image-20251223151208770](https://gitee.com/icecat2233/picture/raw/master/20251223151210250.png)
+
+示例：
+
+```JAVA
+public static void main(String[] args) throws IOException {
+    //记住输出流一定要关闭，使用try catch保证不管如何都会执行关闭
+    //创建字节输出流对象是，可以传两个参数第一个是字符串或者是file对象，第二个是打开或关闭复写的开关
+    //try小括号里的对象必须实现了AutoCloseAble接口
+    try (FileOutputStream fos = new FileOutputStream("D:\\A.txt",true);){
+        fos.write(97);
+        fos.write(97);
+        fos.write("八奈见杏菜".getBytes());
+    }catch (IOException e){
+        e.printStackTrace();
+    }
+}
+```
+
+## FileInPutStream字节输入流：
+
+### 构造和成员方法：
+
+![image-20251223162029993](https://gitee.com/icecat2233/picture/raw/master/20251223162031046.png)
+
+## 案例：copy数据：
+
+```Java
+/**
+拷贝文件
+ */
+public static void main(String[] args) throws IOException {
+    //创建输入流对象读取要复制的数据
+    FileInputStream fis = new FileInputStream("C:\\Users\\asus\\Pictures\\老八.jpg");
+    byte[] bys= new byte[1024];//定义一个空字节数组用来装数据
+    //创建输出流对象粘贴读取的数据
+    FileOutputStream fos= new FileOutputStream("D:\\老八.jpg");
+    int len;
+    while ((len = fis.read(bys)) != -1){
+        fos.write(bys,0, len);
+    }
+    //记得关闭流
+        fis.close();
+        fos.close();
+}
+```
+
+## 字节缓冲流：（未听）
+
+# 小知识点：字符编码：
+
+![image-20251223171153656](https://gitee.com/icecat2233/picture/raw/master/20251223171154676.png)
+
+## 编码和解码：
+
+![image-20251223171247753](https://gitee.com/icecat2233/picture/raw/master/20251223171249689.png)
+
+## 总结：（可记）
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251223171936927.png" alt="image-20251223171919671" style="zoom:50%;" />
+
+# FileWriter字符输出流
+
+## **成员方法**：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251223173014161.png" alt="image-20251223173006416" style="zoom: 50%;" />
+
+# 字符缓冲流：
+
+## 构造方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224164934256.png" alt="image-20251224164929596" style="zoom: 50%;" />
+
+## 特有成员方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224165014103.png" alt="image-20251224165012852" style="zoom:50%;" />
+
+## 重点：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224164902592.png" alt="image-20251224164854046" style="zoom:50%;" />
+
+## 案例：
+
+三组对象写入文件后读取文件并封装成对象打印
+
+```Java
+public static void main(String[] args) throws IOException {
+    Student stu1 = new Student("杏菜",15);
+    Student stu2 = new Student("梦子",16);
+    Student stu3 = new Student("佳树",17);
+    BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\测试.txt"));
+    bw.write(stu1.getName()+"-"+stu1.getAge());
+    bw.newLine();
+    bw.write(stu2.getName()+"-"+stu2.getAge());
+    bw.newLine();
+    bw.write(stu3.getName()+"-"+stu3.getAge());
+    bw.newLine();
+    //写入程序三组数据
+    bw.close();
+    //读取三组数据
+    BufferedReader br = new BufferedReader(new FileReader("D:\\测试.txt"));
+    String line;
+    while ((line = br.readLine()) != null){
+        String[] split = line.split("-");
+        Student stu = new Student(split[0],Integer.parseInt(split[1]));
+        System.out.println(stu);
+    }
+}
+```
+
+# 转换流：
+
+## 作用：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224171828583.png" alt="image-20251224171827438" style="zoom:50%;" />
+
+## 总结：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224171551986.png" alt="image-20251224171550851" style="zoom:50%;" />
+
+# 序列化流：
+
+## 构造方法：
+
+![image-20251224172353234](https://gitee.com/icecat2233/picture/raw/master/20251224172354411.png)
+
+## 序列化流的操作：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224173737299.png" alt="image-20251224173735968" style="zoom: 50%;" />
+
+## 注意事项：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224173938954.png" alt="image-20251224173937811" style="zoom:50%;" />
+
+**transient 瞬态关键字类中某些成员变量不想被序列化操作即可加上此关键字**
+
+## 注意：要是序列化多次对象，有两种方式
+
+**try catch捕获异常，来结束循环**
+
+```Java
+public static void main(String[] args) throws IOException, ClassNotFoundException {
+    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
+    while (true){
+
+        try {
+            Object o = ois.readObject();
+            System.out.println(o);
+        } catch (EOFException O) {
+            break;
+        }
+    }
+    ois.close();
+}
+
+private static void write() throws IOException {
+    Student stu1 = new Student("杏菜",15);
+    Student stu2 = new Student("佳树",16);
+    Student stu3 = new Student("梦子",17);
+    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
+    oos.writeObject(stu1);
+    oos.writeObject(stu2);
+    oos.writeObject(stu3);
+    oos.close();
+}
+```
+
+**只序列化一次，将对象装入一个集合中，读取和写入只进行一次**
+
+```java
+public static void main(String[] args) throws IOException, ClassNotFoundException {
+    //运用集合，使其只读取（序列化和反序列化一次）
+    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
+    ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
+    for (Student student : list) {
+        System.out.println(student);
+    }
+    ois.close();
+}
+
+private static void write() throws IOException {
+    Student stu1 = new Student("杏菜", 15);
+    Student stu2 = new Student("佳树", 16);
+    Student stu3 = new Student("梦子", 17);
+    //创建一个集合将对象装入集合并序列化操作一次写入文件
+    ArrayList<Student> list = new ArrayList<>();
+    Collections.addAll(list, stu1, stu2, stu3);
+    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt", true));
+    oos.writeObject(list);
+    oos.close();
+}
+```
+
+# 打印流：
+
+## 基本使用：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251224184742093.png" alt="image-20251224184740951" style="zoom: 67%;" />
+
+ 
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226154205072.png" alt="image-20251226154156446" style="zoom:50%;" />
+
+## 字符打印流：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226154313700.png" alt="image-20251226154307707" style="zoom:50%;" />
+
+# properties
+
+## 和io有关的方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226162808390.png" alt="image-20251226162807035" style="zoom: 67%;" />
+
+**本质是一个map集合**
+
+## 总结： 
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226162640827.png" alt="image-20251226162638992" style="zoom: 50%;" />
\ No newline at end of file
diff --git a/Stream流.md b/Stream流.md
new file mode 100644
index 0000000..008caf6
--- /dev/null
+++ b/Stream流.md
@@ -0,0 +1,226 @@
+# **Stream流介绍：**
+
+**配合lambda表达式，简化集合和数组操作**
+
+## **获取Stream流对象**
+
+![image-20251221181445689](https://gitee.com/icecat2233/picture/raw/master/20251221181446881.png)
+
+## **Stream流中间操作方法：**
+
+![image-20251221182850306](https://gitee.com/icecat2233/picture/raw/master/20251221182851889.png)
+
+## 获取对象流演示：
+
+![image-20251221194116622](https://gitee.com/icecat2233/picture/raw/master/20251221194131811.png)
+
+### **示例：**
+
+```Java
+ArrayList<String> list = new ArrayList<>();
+        list.add("杏菜");
+        list.add("佳树");
+        list.add("小鞠");
+        list.add("梦子");
+        //集合Stream流对象
+        list.stream().filter(s -> s.startsWith("杏")).forEach(s -> System.out.println(s));
+        //数组流对象
+        int[] arr = {1, 2, 3};
+        Arrays.stream(arr).forEach(s-> System.out.println(s));
+        HashSet<Integer> hs = new HashSet<>();
+        hs.add(1);
+        hs.add(4);
+        hs.add(3);
+        hs.add(5);
+        //map集合流对象，需要间接获取 - map.entrySet().stream
+        HashMap<String,Integer> hm = new HashMap<>();
+        hm.put("张",13);
+        hm.put("李",14);
+        hm.put("王",15);
+        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
+        entries.stream()
+                .filter(entry -> !entry.getKey().startsWith("张"))
+                .forEach(entry -> System.out.println(entry.getKey()+"---"+entry.getValue()));
+        //零散数据获取Stream流对象
+        Stream.of("1","e",3).forEach(s-> System.out.println(s));
+```
+
+## 中间操作方法
+
+![image-20251221200537334](https://gitee.com/icecat2233/picture/raw/master/20251221200538411.png)
+
+示例：
+
+```java
+ArrayList<Integer> list = new ArrayList<>();
+        Stream<Integer> s2 = list.stream();
+        ArrayList<Integer> list1= new ArrayList<>();
+        Stream<Integer> s1 = list1.stream();
+        Collections.addAll(list1,5,6,7);
+        Collections.addAll(list,1,2,3,4);
+        //filter过滤方法
+        list.stream().filter(s -> s!=2).forEach(s-> System.out.print(s));
+        System.out.println('\n');
+        //limit获取前几个元素
+        list.stream().limit(2).forEach(integer -> System.out.print(integer));
+        System.out.println('\n');
+        //skip跳过几个元素
+        System.out.println("跳过之后的元素");
+        list.stream().skip(1).forEach(s-> System.out.print(s));
+        System.out.println('\n');
+        //concat(Stream a,Stream b)合并ab为一个流
+        Stream<Integer> s3 = Stream.concat(s1, s2);
+        s3.forEach(new Consumer<Integer>() {
+            @Override
+            public void accept(Integer s) {
+                System.out.println(s);
+            }
+        });
+        //distinct方法去除流中重复的元素依赖(hashCode 和 equals方法)
+        //在此会报错，因为上面已经消费过了不能重新使用
+        list.stream().distinct().forEach(s-> System.out.println(s));
+```
+
+![image-20251221203020331](https://gitee.com/icecat2233/picture/raw/master/20251221203021575.png)
+
+**注意：若流已经被使用过，或已使用终结方法，就不允许再次使用**
+
+## 终结方法
+
+![image-20251221203822185](https://gitee.com/icecat2233/picture/raw/master/20251221203823266.png)
+
+**示例：**
+
+```java
+//count方法，返回元素个数
+Stream<Integer> s1 = Stream.of(2, 3, 4, 5, 6, 7, 8).filter(integer -> integer % 2 == 0);
+long count = s1.count();
+System.out.println(count);
+```
+
+## 重点：收集操作
+
+为何：因为Stream流操作是不会修改数据源的，图为示例：
+
+![image-20251221203945267](https://gitee.com/icecat2233/picture/raw/master/20251221203946590.png)
+
+### **如何收集：**
+
+![image-20251221205629800](https://gitee.com/icecat2233/picture/raw/master/20251221205631348.png)
+
+**示例：**
+
+```java
+//Stream流收集操作
+Stream<Integer> s1 = Stream.of(1, 2, 3, 4, 5, 6, 7);
+List list1 = s1.limit(3).collect(Collectors.toList());//JDK17版本之后可以将Collectors去除
+System.out.println(list1);
+```
+
+### **转为map操作（较为复杂）**
+
+**重点示例**
+
+```java
+//    将ArrayList中年龄大于15的收集到一个新的map集合中去
+    public static void main(String[] args) {
+        //将Stream流收集到map所需操作
+        ArrayList<String> list = new ArrayList<>();
+        Collections.addAll(list,"杏菜,15","佳树,16","老马,17");
+        Map<String, Integer> map = list.stream().filter(new Predicate<String>() {
+            @Override
+            public boolean test(String s) {
+                //过滤操作，将字符串数据从逗号切割装入数组，0号索引为名字，1号为年龄
+                String[] split = s.split(",");
+                //将字符串转为int类型并比较年龄，返回大于等于16岁的
+                int age = Integer.parseInt(split[1]);
+                return age >= 16;
+            }
+        }).collect(Collectors.toMap(new Function<String, String>() {
+            //创建map集合，第一个匿名内部类为装入键值
+            @Override
+            public String apply(String s) {
+                return s.split(",")[0];
+            }
+        }, new Function<String, Integer>() {
+            //第二个为装入年龄值，并将类型从String改为int
+            @Override
+            public Integer apply(String s) {
+                return Integer.parseInt(s.split(",")[1]);
+            }
+        }));
+        System.out.println(map);
+```
+
+# Stream流综合案例
+
+```java
+package com.icacat.day12;
+
+import java.util.ArrayList;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public class StreamDemo6 {
+    public static void main(String[] args) {
+        ArrayList<String> manList = new ArrayList<>();
+        manList.add("温水和彦");
+        manList.add("社长");
+        manList.add("桐谷和人");
+        manList.add("勇太");
+        ArrayList<String> womanList = new ArrayList<>();
+        womanList.add("杏菜");
+        womanList.add("小鞠");
+        womanList.add("佳树");
+        womanList.add("千早");
+
+        Stream<String> s1 = manList.stream().filter(new Predicate<String>() {
+            @Override
+            public boolean test(String s) {
+                return s.length() == 4;
+            }
+        }).limit(2);
+        Stream<String> s2 = womanList.stream().skip(1).filter(s -> s.startsWith("佳"));
+        Stream<String> total = Stream.concat(s1, s2);
+        total.forEach(new Consumer<String>() {
+            @Override
+            public void accept(String name) {
+                Actor ac = new Actor(name);
+                System.out.println(ac);
+            }
+        });
+    }
+}
+
+class Actor{
+    private String name;
+
+    public Actor() {
+    }
+
+    public Actor(String name) {
+        this.name = name;
+    }
+
+    /**
+     * 获取
+     * @return name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * 设置
+     * @param name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String toString() {
+        return "Actor{name = " + name + "}";
+    }
+}
+```
\ No newline at end of file
diff --git a/file类.md b/file类.md
new file mode 100644
index 0000000..a75e57d
--- /dev/null
+++ b/file类.md
@@ -0,0 +1,129 @@
+# file类
+
+创建对象
+
+# 相对路径绝对路径：(重点)
+
+相对路径：相对于当前项目的路径
+
+# File类常用方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251222170009271.png" alt="image-20251222170000954" style="zoom:67%;" />
+
+# File类的创建和删除：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251222172801923.png" alt="image-20251222172800813" style="zoom:50%;" />
+
+# File类的遍历方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251222174209999.png" alt="image-20251222174208835" style="zoom: 50%;" />
+
+案例展示：
+
+寻找文件夹
+
+```java
+public class FileDemo2 {
+    public static void main(String[] args) {
+ getDir();
+    }
+    public static File getDir() {
+        System.out.println("请输入要找的文件夹");
+        Scanner sc = new Scanner(System.in);
+        while (true) {
+            String put = sc.nextLine();
+            File dir = new File(put);
+            if (!dir.exists()) {
+                System.out.println("你输入的文件夹不存在，请重新输入");
+            } else if (dir.isFile()) {
+                System.out.println("你输入的是一个文件不是文件夹，请重新输入");
+            } else {
+                return dir;
+            }
+        }
+    }
+}
+```
+
+```java
+//打印输入文件夹下所有的.java文件
+public class FileDemo3 {
+    public static void main(String[] args) {
+        File diry = FileDemo2.getDir();
+        find(diry);
+    }
+
+    private static void find(File dir) {
+        //获取当前文件夹下所有文件和文件夹对象，转化为file数组形式
+        File[] files = dir.listFiles();
+        for (File file : files) {
+            //若是文件，判断是否为.java后缀
+            if (file.isFile() && file.getName().endsWith(".java")){
+                System.out.println(file);
+                //若是文件夹则进到下一级继续判断
+            } else if (file.isDirectory()) {
+                //注意事项，可能遍历的数组会返回为null
+                if (file.listFiles() != null) {
+                    find(file);
+                }
+            }
+        }
+    }
+}
+```
+
+```java
+//删除文件夹
+public class FileDemo4 {
+    public static void main(String[] args) {
+        //谨慎测试
+        deleteDir(new File("D:\\测试Java1"));
+    }
+    public static void deleteDir(File dir){
+        File[] files = dir.listFiles();
+        //遍历当前flie数组获取到每一个文件对象
+        for (File file : files) {
+            if (file.isFile()){
+                file.delete();
+                //若是文件夹，则进到里面继续删文件，运用递归
+            }else if (file.isDirectory()){
+                //判断数组集合是否为空
+                if (file.listFiles()!=null){
+                deleteDir(file);
+                }
+            }
+        }
+        dir.delete();
+    }
+}
+```
+
+```java
+//统计文件大小
+public class FileDemo5 {
+
+    public static void main(String[] args) {
+        //键盘录入文件夹路径，统计文件大小
+        File dir = FileDemo2.getDir();
+        int i = fileSize(dir);
+        System.out.println(i);
+    }
+    public static int fileSize(File di){
+        int size = 0;
+        //遍历
+        File[] files = di.listFiles();
+        for (File file : files) {
+            //判断是否是文件
+            if (file.isFile()){
+           int a = (int)file.length();
+           size+=a;
+            }else {
+                if (file.listFiles() != null){
+                    size += fileSize(file);
+                }
+            }
+        }
+        return size;
+    }
+}
+```
\ No newline at end of file
diff --git a/imgh/20260106201532735.png b/imgh/20260106201532735.png
new file mode 100644
index 0000000..aa2b310
Binary files /dev/null and b/imgh/20260106201532735.png differ
diff --git a/imgh/image-20250428164753200.png b/imgh/image-20250428164753200.png
new file mode 100644
index 0000000..a232a23
Binary files /dev/null and b/imgh/image-20250428164753200.png differ
diff --git a/imgh/image-20250428164848721.png b/imgh/image-20250428164848721.png
new file mode 100644
index 0000000..4c97b41
Binary files /dev/null and b/imgh/image-20250428164848721.png differ
diff --git a/imgh/image-20250428165133488.png b/imgh/image-20250428165133488.png
new file mode 100644
index 0000000..f484256
Binary files /dev/null and b/imgh/image-20250428165133488.png differ
diff --git a/imgh/image-20250428165218560.png b/imgh/image-20250428165218560.png
new file mode 100644
index 0000000..2ffdbf8
Binary files /dev/null and b/imgh/image-20250428165218560.png differ
diff --git a/imgh/image-20250428165310376.png b/imgh/image-20250428165310376.png
new file mode 100644
index 0000000..f13d839
Binary files /dev/null and b/imgh/image-20250428165310376.png differ
diff --git a/imgh/image-20250509183446340.png b/imgh/image-20250509183446340.png
new file mode 100644
index 0000000..39b50c0
Binary files /dev/null and b/imgh/image-20250509183446340.png differ
diff --git a/imgh/image-20250509183934916.png b/imgh/image-20250509183934916.png
new file mode 100644
index 0000000..175f177
Binary files /dev/null and b/imgh/image-20250509183934916.png differ
diff --git a/imgh/image-20250509201524220.png b/imgh/image-20250509201524220.png
new file mode 100644
index 0000000..8813343
Binary files /dev/null and b/imgh/image-20250509201524220.png differ
diff --git a/imgh/image-20250510170052265.png b/imgh/image-20250510170052265.png
new file mode 100644
index 0000000..b60b7f2
Binary files /dev/null and b/imgh/image-20250510170052265.png differ
diff --git a/imgh/image-20250510170405367.png b/imgh/image-20250510170405367.png
new file mode 100644
index 0000000..0682e37
Binary files /dev/null and b/imgh/image-20250510170405367.png differ
diff --git a/imgh/image-20250510170513793.png b/imgh/image-20250510170513793.png
new file mode 100644
index 0000000..63805f1
Binary files /dev/null and b/imgh/image-20250510170513793.png differ
diff --git a/imgh/image-20250510170600150.png b/imgh/image-20250510170600150.png
new file mode 100644
index 0000000..115cd0c
Binary files /dev/null and b/imgh/image-20250510170600150.png differ
diff --git a/imgh/image-20251012170947546.png b/imgh/image-20251012170947546.png
new file mode 100644
index 0000000..eb8b8ea
Binary files /dev/null and b/imgh/image-20251012170947546.png differ
diff --git a/imgh/image-20251217162402752.png b/imgh/image-20251217162402752.png
new file mode 100644
index 0000000..a39d44d
Binary files /dev/null and b/imgh/image-20251217162402752.png differ
diff --git a/imgh/image-20251220165000000.png b/imgh/image-20251220165000000.png
new file mode 100644
index 0000000..75a83c5
Binary files /dev/null and b/imgh/image-20251220165000000.png differ
diff --git a/imgh/image-20251220165202216.png b/imgh/image-20251220165202216.png
new file mode 100644
index 0000000..b71f302
Binary files /dev/null and b/imgh/image-20251220165202216.png differ
diff --git a/imgh/image-20251220165543271.png b/imgh/image-20251220165543271.png
new file mode 100644
index 0000000..f9dc50c
Binary files /dev/null and b/imgh/image-20251220165543271.png differ
diff --git a/imgh/image-20251220171235311.png b/imgh/image-20251220171235311.png
new file mode 100644
index 0000000..b047f42
Binary files /dev/null and b/imgh/image-20251220171235311.png differ
diff --git a/imgh/image-20251220171433114.png b/imgh/image-20251220171433114.png
new file mode 100644
index 0000000..2adcf9d
Binary files /dev/null and b/imgh/image-20251220171433114.png differ
diff --git a/imgh/image-20251220173953237.png b/imgh/image-20251220173953237.png
new file mode 100644
index 0000000..00a8899
Binary files /dev/null and b/imgh/image-20251220173953237.png differ
diff --git a/imgh/image-20251220174214148.png b/imgh/image-20251220174214148.png
new file mode 100644
index 0000000..0e26c8d
Binary files /dev/null and b/imgh/image-20251220174214148.png differ
diff --git a/imgh/image-20251220175506487.png b/imgh/image-20251220175506487.png
new file mode 100644
index 0000000..f093f7c
Binary files /dev/null and b/imgh/image-20251220175506487.png differ
diff --git a/imgh/image-20251220201801335.png b/imgh/image-20251220201801335.png
new file mode 100644
index 0000000..833d181
Binary files /dev/null and b/imgh/image-20251220201801335.png differ
diff --git a/imgh/image-20251220201929102.png b/imgh/image-20251220201929102.png
new file mode 100644
index 0000000..e3257e1
Binary files /dev/null and b/imgh/image-20251220201929102.png differ
diff --git a/imgh/image-20251220202017714.png b/imgh/image-20251220202017714.png
new file mode 100644
index 0000000..3671aed
Binary files /dev/null and b/imgh/image-20251220202017714.png differ
diff --git a/imgh/image-20251220203224248.png b/imgh/image-20251220203224248.png
new file mode 100644
index 0000000..0a22303
Binary files /dev/null and b/imgh/image-20251220203224248.png differ
diff --git a/imgh/image-20251220205745452.png b/imgh/image-20251220205745452.png
new file mode 100644
index 0000000..61c5ae3
Binary files /dev/null and b/imgh/image-20251220205745452.png differ
diff --git a/imgh/image-20251220205749384.png b/imgh/image-20251220205749384.png
new file mode 100644
index 0000000..61c5ae3
Binary files /dev/null and b/imgh/image-20251220205749384.png differ
diff --git a/imgh/image-20251220205848087.png b/imgh/image-20251220205848087.png
new file mode 100644
index 0000000..901f0a9
Binary files /dev/null and b/imgh/image-20251220205848087.png differ
diff --git a/imgh/image-20251221153319738.png b/imgh/image-20251221153319738.png
new file mode 100644
index 0000000..3f89bdd
Binary files /dev/null and b/imgh/image-20251221153319738.png differ
diff --git a/imgh/image-20251221153329358.png b/imgh/image-20251221153329358.png
new file mode 100644
index 0000000..3f89bdd
Binary files /dev/null and b/imgh/image-20251221153329358.png differ
diff --git a/imgh/image-20251221174612093.png b/imgh/image-20251221174612093.png
new file mode 100644
index 0000000..fcf658e
Binary files /dev/null and b/imgh/image-20251221174612093.png differ
diff --git a/imgh/image-20251221181445689.png b/imgh/image-20251221181445689.png
new file mode 100644
index 0000000..d666225
Binary files /dev/null and b/imgh/image-20251221181445689.png differ
diff --git a/imgh/image-20251221182850306.png b/imgh/image-20251221182850306.png
new file mode 100644
index 0000000..cf8047e
Binary files /dev/null and b/imgh/image-20251221182850306.png differ
diff --git a/imgh/image-20251221194116622.png b/imgh/image-20251221194116622.png
new file mode 100644
index 0000000..d7b67f7
Binary files /dev/null and b/imgh/image-20251221194116622.png differ
diff --git a/imgh/image-20251221200537334.png b/imgh/image-20251221200537334.png
new file mode 100644
index 0000000..435c79a
Binary files /dev/null and b/imgh/image-20251221200537334.png differ
diff --git a/imgh/image-20251221203020331.png b/imgh/image-20251221203020331.png
new file mode 100644
index 0000000..60b8e06
Binary files /dev/null and b/imgh/image-20251221203020331.png differ
diff --git a/imgh/image-20251221203822185.png b/imgh/image-20251221203822185.png
new file mode 100644
index 0000000..fcb84d2
Binary files /dev/null and b/imgh/image-20251221203822185.png differ
diff --git a/imgh/image-20251221203945267.png b/imgh/image-20251221203945267.png
new file mode 100644
index 0000000..d8911bf
Binary files /dev/null and b/imgh/image-20251221203945267.png differ
diff --git a/imgh/image-20251221205629800.png b/imgh/image-20251221205629800.png
new file mode 100644
index 0000000..2aac1ea
Binary files /dev/null and b/imgh/image-20251221205629800.png differ
diff --git a/imgh/image-20251222170000954.png b/imgh/image-20251222170000954.png
new file mode 100644
index 0000000..dcde0be
Binary files /dev/null and b/imgh/image-20251222170000954.png differ
diff --git a/imgh/image-20251222172800813.png b/imgh/image-20251222172800813.png
new file mode 100644
index 0000000..26f0f26
Binary files /dev/null and b/imgh/image-20251222172800813.png differ
diff --git a/imgh/image-20251222174208835.png b/imgh/image-20251222174208835.png
new file mode 100644
index 0000000..5abc103
Binary files /dev/null and b/imgh/image-20251222174208835.png differ
diff --git a/imgh/image-20251223143723814.png b/imgh/image-20251223143723814.png
new file mode 100644
index 0000000..f6055b4
Binary files /dev/null and b/imgh/image-20251223143723814.png differ
diff --git a/imgh/image-20251223145352942.png b/imgh/image-20251223145352942.png
new file mode 100644
index 0000000..bba93e0
Binary files /dev/null and b/imgh/image-20251223145352942.png differ
diff --git a/imgh/image-20251223145424559.png b/imgh/image-20251223145424559.png
new file mode 100644
index 0000000..cca306e
Binary files /dev/null and b/imgh/image-20251223145424559.png differ
diff --git a/imgh/image-20251223151208770.png b/imgh/image-20251223151208770.png
new file mode 100644
index 0000000..78f12e1
Binary files /dev/null and b/imgh/image-20251223151208770.png differ
diff --git a/imgh/image-20251223162029993.png b/imgh/image-20251223162029993.png
new file mode 100644
index 0000000..8faff21
Binary files /dev/null and b/imgh/image-20251223162029993.png differ
diff --git a/imgh/image-20251223171153656.png b/imgh/image-20251223171153656.png
new file mode 100644
index 0000000..139eaf9
Binary files /dev/null and b/imgh/image-20251223171153656.png differ
diff --git a/imgh/image-20251223171247753.png b/imgh/image-20251223171247753.png
new file mode 100644
index 0000000..70b104b
Binary files /dev/null and b/imgh/image-20251223171247753.png differ
diff --git a/imgh/image-20251223171919671.png b/imgh/image-20251223171919671.png
new file mode 100644
index 0000000..80d1c68
Binary files /dev/null and b/imgh/image-20251223171919671.png differ
diff --git a/imgh/image-20251223173006416.png b/imgh/image-20251223173006416.png
new file mode 100644
index 0000000..1a3a418
Binary files /dev/null and b/imgh/image-20251223173006416.png differ
diff --git a/imgh/image-20251224164854046.png b/imgh/image-20251224164854046.png
new file mode 100644
index 0000000..baeee7d
Binary files /dev/null and b/imgh/image-20251224164854046.png differ
diff --git a/imgh/image-20251224164929596.png b/imgh/image-20251224164929596.png
new file mode 100644
index 0000000..0032af2
Binary files /dev/null and b/imgh/image-20251224164929596.png differ
diff --git a/imgh/image-20251224165012852.png b/imgh/image-20251224165012852.png
new file mode 100644
index 0000000..f625202
Binary files /dev/null and b/imgh/image-20251224165012852.png differ
diff --git a/imgh/image-20251224171550851.png b/imgh/image-20251224171550851.png
new file mode 100644
index 0000000..f86b4fb
Binary files /dev/null and b/imgh/image-20251224171550851.png differ
diff --git a/imgh/image-20251224171827438.png b/imgh/image-20251224171827438.png
new file mode 100644
index 0000000..b1f25c2
Binary files /dev/null and b/imgh/image-20251224171827438.png differ
diff --git a/imgh/image-20251224172240108.png b/imgh/image-20251224172240108.png
new file mode 100644
index 0000000..379c6d4
Binary files /dev/null and b/imgh/image-20251224172240108.png differ
diff --git a/imgh/image-20251224172353234.png b/imgh/image-20251224172353234.png
new file mode 100644
index 0000000..8a0df65
Binary files /dev/null and b/imgh/image-20251224172353234.png differ
diff --git a/imgh/image-20251224173735968.png b/imgh/image-20251224173735968.png
new file mode 100644
index 0000000..36834d2
Binary files /dev/null and b/imgh/image-20251224173735968.png differ
diff --git a/imgh/image-20251224173937811.png b/imgh/image-20251224173937811.png
new file mode 100644
index 0000000..12f374c
Binary files /dev/null and b/imgh/image-20251224173937811.png differ
diff --git a/imgh/image-20251224184740951.png b/imgh/image-20251224184740951.png
new file mode 100644
index 0000000..71054c1
Binary files /dev/null and b/imgh/image-20251224184740951.png differ
diff --git a/imgh/image-20251226154156446.png b/imgh/image-20251226154156446.png
new file mode 100644
index 0000000..84654d9
Binary files /dev/null and b/imgh/image-20251226154156446.png differ
diff --git a/imgh/image-20251226154307707.png b/imgh/image-20251226154307707.png
new file mode 100644
index 0000000..da9d23f
Binary files /dev/null and b/imgh/image-20251226154307707.png differ
diff --git a/imgh/image-20251226162638992.png b/imgh/image-20251226162638992.png
new file mode 100644
index 0000000..f0bcff7
Binary files /dev/null and b/imgh/image-20251226162638992.png differ
diff --git a/imgh/image-20251226162807035.png b/imgh/image-20251226162807035.png
new file mode 100644
index 0000000..6d98955
Binary files /dev/null and b/imgh/image-20251226162807035.png differ
diff --git a/imgh/image-20251226164954480.png b/imgh/image-20251226164954480.png
new file mode 100644
index 0000000..9d0d936
Binary files /dev/null and b/imgh/image-20251226164954480.png differ
diff --git a/imgh/image-20251226170130636.png b/imgh/image-20251226170130636.png
new file mode 100644
index 0000000..7671c64
Binary files /dev/null and b/imgh/image-20251226170130636.png differ
diff --git a/imgh/image-20251226175706557.png b/imgh/image-20251226175706557.png
new file mode 100644
index 0000000..79c81c8
Binary files /dev/null and b/imgh/image-20251226175706557.png differ
diff --git a/imgh/image-20251226195311173.png b/imgh/image-20251226195311173.png
new file mode 100644
index 0000000..3098120
Binary files /dev/null and b/imgh/image-20251226195311173.png differ
diff --git a/imgh/image-20251226195404148.png b/imgh/image-20251226195404148.png
new file mode 100644
index 0000000..6b77775
Binary files /dev/null and b/imgh/image-20251226195404148.png differ
diff --git a/imgh/image-20251226195657226.png b/imgh/image-20251226195657226.png
new file mode 100644
index 0000000..f81bec9
Binary files /dev/null and b/imgh/image-20251226195657226.png differ
diff --git a/imgh/image-20251226200310813.png b/imgh/image-20251226200310813.png
new file mode 100644
index 0000000..3b31395
Binary files /dev/null and b/imgh/image-20251226200310813.png differ
diff --git a/imgh/image-20251226200636908.png b/imgh/image-20251226200636908.png
new file mode 100644
index 0000000..cf41350
Binary files /dev/null and b/imgh/image-20251226200636908.png differ
diff --git a/imgh/image-20251227180059497.png b/imgh/image-20251227180059497.png
new file mode 100644
index 0000000..7a71d62
Binary files /dev/null and b/imgh/image-20251227180059497.png differ
diff --git a/imgh/image-20251227181232243.png b/imgh/image-20251227181232243.png
new file mode 100644
index 0000000..6302dd6
Binary files /dev/null and b/imgh/image-20251227181232243.png differ
diff --git a/imgh/image-20251227182957021.png b/imgh/image-20251227182957021.png
new file mode 100644
index 0000000..e6a335a
Binary files /dev/null and b/imgh/image-20251227182957021.png differ
diff --git a/imgh/image-20251227184706346.png b/imgh/image-20251227184706346.png
new file mode 100644
index 0000000..cef68c6
Binary files /dev/null and b/imgh/image-20251227184706346.png differ
diff --git a/imgh/image-20251228183248533.png b/imgh/image-20251228183248533.png
new file mode 100644
index 0000000..f3cd188
Binary files /dev/null and b/imgh/image-20251228183248533.png differ
diff --git a/imgh/image-20251228190234137.png b/imgh/image-20251228190234137.png
new file mode 100644
index 0000000..9724129
Binary files /dev/null and b/imgh/image-20251228190234137.png differ
diff --git a/imgh/image-20251228190304630.png b/imgh/image-20251228190304630.png
new file mode 100644
index 0000000..66c60d8
Binary files /dev/null and b/imgh/image-20251228190304630.png differ
diff --git a/imgh/image-20251228191729896.png b/imgh/image-20251228191729896.png
new file mode 100644
index 0000000..7df06a2
Binary files /dev/null and b/imgh/image-20251228191729896.png differ
diff --git a/imgh/image-20251228193308023.png b/imgh/image-20251228193308023.png
new file mode 100644
index 0000000..3888a1b
Binary files /dev/null and b/imgh/image-20251228193308023.png differ
diff --git a/imgh/image-20251228193330122.png b/imgh/image-20251228193330122.png
new file mode 100644
index 0000000..8fe0cef
Binary files /dev/null and b/imgh/image-20251228193330122.png differ
diff --git a/imgh/image-20251228193429569.png b/imgh/image-20251228193429569.png
new file mode 100644
index 0000000..201c7fa
Binary files /dev/null and b/imgh/image-20251228193429569.png differ
diff --git a/imgh/image-20251228194046082.png b/imgh/image-20251228194046082.png
new file mode 100644
index 0000000..1177374
Binary files /dev/null and b/imgh/image-20251228194046082.png differ
diff --git a/imgh/image-20251228200135970.png b/imgh/image-20251228200135970.png
new file mode 100644
index 0000000..a2462e3
Binary files /dev/null and b/imgh/image-20251228200135970.png differ
diff --git a/imgh/image-20251228200427425.png b/imgh/image-20251228200427425.png
new file mode 100644
index 0000000..a770509
Binary files /dev/null and b/imgh/image-20251228200427425.png differ
diff --git a/imgh/image-20251228200820075.png b/imgh/image-20251228200820075.png
new file mode 100644
index 0000000..cb7fa32
Binary files /dev/null and b/imgh/image-20251228200820075.png differ
diff --git a/imgh/image-20251228200929336.png b/imgh/image-20251228200929336.png
new file mode 100644
index 0000000..2d80fb5
Binary files /dev/null and b/imgh/image-20251228200929336.png differ
diff --git a/imgh/image-20251228204750037.png b/imgh/image-20251228204750037.png
new file mode 100644
index 0000000..355f56b
Binary files /dev/null and b/imgh/image-20251228204750037.png differ
diff --git a/imgh/image-20251228204926855.png b/imgh/image-20251228204926855.png
new file mode 100644
index 0000000..655f7cf
Binary files /dev/null and b/imgh/image-20251228204926855.png differ
diff --git a/imgh/image-20251229162046866.png b/imgh/image-20251229162046866.png
new file mode 100644
index 0000000..06a7330
Binary files /dev/null and b/imgh/image-20251229162046866.png differ
diff --git a/imgh/image-20251229162723116.png b/imgh/image-20251229162723116.png
new file mode 100644
index 0000000..f061abb
Binary files /dev/null and b/imgh/image-20251229162723116.png differ
diff --git a/imgh/image-20251229163018519.png b/imgh/image-20251229163018519.png
new file mode 100644
index 0000000..c14480b
Binary files /dev/null and b/imgh/image-20251229163018519.png differ
diff --git a/imgh/image-20251229164022824.png b/imgh/image-20251229164022824.png
new file mode 100644
index 0000000..88db6db
Binary files /dev/null and b/imgh/image-20251229164022824.png differ
diff --git a/imgh/image-20251229173457548.png b/imgh/image-20251229173457548.png
new file mode 100644
index 0000000..c070158
Binary files /dev/null and b/imgh/image-20251229173457548.png differ
diff --git a/imgh/image-20251229184654252.png b/imgh/image-20251229184654252.png
new file mode 100644
index 0000000..5954cef
Binary files /dev/null and b/imgh/image-20251229184654252.png differ
diff --git a/imgh/image-20251229185454457.png b/imgh/image-20251229185454457.png
new file mode 100644
index 0000000..21319bb
Binary files /dev/null and b/imgh/image-20251229185454457.png differ
diff --git a/imgh/image-20260104152029322.png b/imgh/image-20260104152029322.png
new file mode 100644
index 0000000..711b7bf
Binary files /dev/null and b/imgh/image-20260104152029322.png differ
diff --git a/imgh/image-20260104152046997.png b/imgh/image-20260104152046997.png
new file mode 100644
index 0000000..4f1bf0d
Binary files /dev/null and b/imgh/image-20260104152046997.png differ
diff --git a/imgh/image-20260104152756174.png b/imgh/image-20260104152756174.png
new file mode 100644
index 0000000..d7c26c8
Binary files /dev/null and b/imgh/image-20260104152756174.png differ
diff --git a/imgh/image-20260104153701814.png b/imgh/image-20260104153701814.png
new file mode 100644
index 0000000..5c175fe
Binary files /dev/null and b/imgh/image-20260104153701814.png differ
diff --git a/imgh/image-20260104153710216.png b/imgh/image-20260104153710216.png
new file mode 100644
index 0000000..5c175fe
Binary files /dev/null and b/imgh/image-20260104153710216.png differ
diff --git a/imgh/image-20260105160242903.png b/imgh/image-20260105160242903.png
new file mode 100644
index 0000000..7a89f9d
Binary files /dev/null and b/imgh/image-20260105160242903.png differ
diff --git a/imgh/image-20260105161129784.png b/imgh/image-20260105161129784.png
new file mode 100644
index 0000000..fcb1bdb
Binary files /dev/null and b/imgh/image-20260105161129784.png differ
diff --git a/imgh/image-20260105170936519.png b/imgh/image-20260105170936519.png
new file mode 100644
index 0000000..b8b48b0
Binary files /dev/null and b/imgh/image-20260105170936519.png differ
diff --git a/imgh/image-20260105171056746.png b/imgh/image-20260105171056746.png
new file mode 100644
index 0000000..cc35947
Binary files /dev/null and b/imgh/image-20260105171056746.png differ
diff --git a/imgh/image-20260105173059327.png b/imgh/image-20260105173059327.png
new file mode 100644
index 0000000..0ffabaf
Binary files /dev/null and b/imgh/image-20260105173059327.png differ
diff --git a/imgh/image-20260105173145296.png b/imgh/image-20260105173145296.png
new file mode 100644
index 0000000..88c3e0f
Binary files /dev/null and b/imgh/image-20260105173145296.png differ
diff --git a/imgh/image-20260106153259853.png b/imgh/image-20260106153259853.png
new file mode 100644
index 0000000..ada6e75
Binary files /dev/null and b/imgh/image-20260106153259853.png differ
diff --git a/imgh/image-20260106153751296.png b/imgh/image-20260106153751296.png
new file mode 100644
index 0000000..4c43d7a
Binary files /dev/null and b/imgh/image-20260106153751296.png differ
diff --git a/imgh/image-20260106154607624.png b/imgh/image-20260106154607624.png
new file mode 100644
index 0000000..656f63d
Binary files /dev/null and b/imgh/image-20260106154607624.png differ
diff --git a/imgh/image-20260106164151697.png b/imgh/image-20260106164151697.png
new file mode 100644
index 0000000..0f7a261
Binary files /dev/null and b/imgh/image-20260106164151697.png differ
diff --git a/imgh/image-20260106170911320.png b/imgh/image-20260106170911320.png
new file mode 100644
index 0000000..60cc684
Binary files /dev/null and b/imgh/image-20260106170911320.png differ
diff --git a/imgh/image-20260106170924376.png b/imgh/image-20260106170924376.png
new file mode 100644
index 0000000..ce42d2d
Binary files /dev/null and b/imgh/image-20260106170924376.png differ
diff --git a/imgh/image-20260106172045711.png b/imgh/image-20260106172045711.png
new file mode 100644
index 0000000..5ed1ef3
Binary files /dev/null and b/imgh/image-20260106172045711.png differ
diff --git a/imgh/image-20260106172208442.png b/imgh/image-20260106172208442.png
new file mode 100644
index 0000000..05b76ec
Binary files /dev/null and b/imgh/image-20260106172208442.png differ
diff --git a/imgh/image-20260106201531734.png b/imgh/image-20260106201531734.png
new file mode 100644
index 0000000..aa2b310
Binary files /dev/null and b/imgh/image-20260106201531734.png differ
diff --git a/imgh/image-20260106202425198.png b/imgh/image-20260106202425198.png
new file mode 100644
index 0000000..6a2a5c0
Binary files /dev/null and b/imgh/image-20260106202425198.png differ
diff --git a/imgh/image-20260106203337157.png b/imgh/image-20260106203337157.png
new file mode 100644
index 0000000..0038610
Binary files /dev/null and b/imgh/image-20260106203337157.png differ
diff --git a/imgh/image-20260106203756219.png b/imgh/image-20260106203756219.png
new file mode 100644
index 0000000..1f51a10
Binary files /dev/null and b/imgh/image-20260106203756219.png differ
diff --git a/xml讲解.md b/xml讲解.md
new file mode 100644
index 0000000..33cb034
--- /dev/null
+++ b/xml讲解.md
@@ -0,0 +1,85 @@
+# XML
+
+语法：
+
+## XML约束-schema约束
+
+本质还是一个xml文件
+
+![image-20260106164151697](https://gitee.com/icecat2233/picture/raw/master/20260106164155129.png)
+
+### 代码演示：
+
+**此为xsd文件**
+
+complexType:复杂属性
+
+sequence：序列  后可加maxOccurs来表示元素是否可为多个
+
+attribute：属性 后可加属性标签来约束xml标签属性有什么为什么类型是否是必需
+
+element：元素 后写名称来标识你在xml中应有的元素
+
+```xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+        targetNamespace="ice.cat.home"
+        elementFormDefault="qualified">
+<element name="students">
+    <complexType>
+        <sequence maxOccurs="unbounded">
+            <element name="Student">
+                <complexType>
+                    <sequence maxOccurs="unbounded">
+                        <element name="name"></element>
+                        <element name="age"></element>
+                    </sequence>
+                    <attribute name="id" type="string" use="required"/>
+                </complexType>
+            </element>
+        </sequence>
+    </complexType>
+</element>
+</schema>
+```
+
+**下方为约束效果**
+
+```xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<students xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
+          xmlns = "ice.cat.home"
+          xsi:schemaLocation="ice.cat.home schema.xsd">
+<Student id="1">
+    <name>张三</name>
+    <age>12</age>
+    <name>杏菜</name>
+    <age>14</age>
+</Student>
+</students>
+```
+
+## 解析：
+
+将xml文件读取到Java
+
+### SAX解析：
+
+![image-20260106170911320](https://gitee.com/icecat2233/picture/raw/master/20260106170912993.png)
+
+### DOM解析：
+
+![image-20260106170924376](https://gitee.com/icecat2233/picture/raw/master/20260106170928898.png)
+
+**一般用DOM**
+
+**首先导入DOM4j的jar包**
+
+方法：
+
+<img src="imgh/image-20260106172208442.png" alt="image-20260106172208442" style="zoom: 67%;" />
+
+### DOM解析代码：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260106172046827.png" alt="image-20260106172045711" style="zoom:150%;" />
+
diff --git a/日本語/【N2N1阅读】刷题练习100篇.pdf b/日本語/【N2N1阅读】刷题练习100篇.pdf
new file mode 100644
index 0000000..f779d56
Binary files /dev/null and b/日本語/【N2N1阅读】刷题练习100篇.pdf differ
diff --git a/日本語/【N2N1阅读】刷题练习100篇答案&译文.pdf b/日本語/【N2N1阅读】刷题练习100篇答案&译文.pdf
new file mode 100644
index 0000000..ef7097e
Binary files /dev/null and b/日本語/【N2N1阅读】刷题练习100篇答案&译文.pdf differ
diff --git a/日本語/日语TRY！N2语法必备140条汇总.pdf b/日本語/日语TRY！N2语法必备140条汇总.pdf
new file mode 100644
index 0000000..d5e9d33
Binary files /dev/null and b/日本語/日语TRY！N2语法必备140条汇总.pdf differ
diff --git a/日本語/日语TRY！N2语法必备140条默写版.pdf b/日本語/日语TRY！N2语法必备140条默写版.pdf
new file mode 100644
index 0000000..fd503b4
Binary files /dev/null and b/日本語/日语TRY！N2语法必备140条默写版.pdf differ
diff --git a/最后部分JavaSE加强.md b/最后部分JavaSE加强.md
new file mode 100644
index 0000000..6485f7b
--- /dev/null
+++ b/最后部分JavaSE加强.md
@@ -0,0 +1,139 @@
+# 日志
+
+## 日志框架
+
+![image-20260104152029322](https://gitee.com/icecat2233/picture/raw/master/20260104152038794.png)
+
+![image-20260104152046997](https://gitee.com/icecat2233/picture/raw/master/20260104152050886.png)
+
+# 枚举
+
+**一般用作信息的标记和分类**
+
+![image-20260104152756174](https://gitee.com/icecat2233/picture/raw/master/20260104152757423.png)
+
+## 枚举的特点
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260104153711421.png" alt="image-20260104153710216" style="zoom:50%;" />
+
+作用：
+
+代码优雅，可读性高，入参约束严谨
+
+# 类加载器
+
+**过程**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260105160250925.png" alt="image-20260105160242903" style="zoom: 50%;" />
+
+类加载器的分类
+
+![image-20260105161129784](https://gitee.com/icecat2233/picture/raw/master/20260105161131223.png)
+
+**双亲委派模型：**
+
+
+
+# 反射：
+
+## 如何创建类的字节码对象：
+
+
+
+## 反射类中的构造方法
+
+其中返回单个构造方法对象括号中给的参数是可变参数，给的是字节码文件参数，用来代表返回的是有参构造还是无参构造，可看下边例子
+
+![image-20260105170936519](https://gitee.com/icecat2233/picture/raw/master/20260105170937538.png)
+
+**反射到Constructor类中后的创建对象方法**
+
+![image-20260105171056746](https://gitee.com/icecat2233/picture/raw/master/20260105171057963.png)
+
+其中newInstance方法中的参数代表了是走的带参构造还是无参构造
+
+```Java
+public class Demo1 {
+    public static void main(String[] args) throws Exception{
+        //获取类的字节码对象
+        Class<?> class1 = Class.forName("com.ice.cat.domain.Student");
+        //反射构造方法对象
+        Constructor<?> constructor = class1.getDeclaredConstructor(String.class,int.class);//此方法无视权限返回单个所有权限的构造方法对象
+        //设置为true 表示取消访问检查
+        constructor.setAccessible(true);
+        //通过此方法实例化，创建对象
+        Object o = constructor.newInstance("杏菜",15);
+        System.out.println(o);
+    }
+}
+```
+
+## 反射类中的成员变量：
+
+![image-20260105173059327](https://gitee.com/icecat2233/picture/raw/master/20260105173100700.png)
+
+## 设置成员变量的方法
+
+![image-20260105173145296](https://gitee.com/icecat2233/picture/raw/master/20260105173146440.png)
+
+例子：
+
+```Java
+public class Demo2 {
+    public static void main(String[] args)throws Exception{
+        //获取Student的字节码文件
+        Class<Student> studentClass = Student.class;
+        //暴力获取单个所有权限无参构造方法
+        Constructor<Student> constructor = studentClass.getDeclaredConstructor();
+        //取消检查权限
+        constructor.setAccessible(true);
+        //实例化
+        Student stu1 = constructor.newInstance();
+        Student stu2 = constructor.newInstance();
+        //暴力反射内部成员变量
+        Field name = studentClass.getDeclaredField("name");
+        Field age = studentClass.getDeclaredField("age");
+        //因为是暴力获取，得设置访问权限
+        name.setAccessible(true);
+        age.setAccessible(true);
+        //通过set给成员变量赋值
+        name.set(stu1,"杏菜");
+        name.set(stu2,"佳树");
+        age.set(stu1,15);
+        age.set(stu2,13);
+        System.out.println(name.get(stu1));
+        System.out.println(name.get(stu2));
+    }
+}
+```
+
+## 反射的建议：禁止暴力反射
+
+小知识点：Java中的泛型是假的，只有在编译期间有效
+
+```Java
+public class Test1 {
+    //在一个泛型为Integer的集合里面添加一个字符串
+    //思路：Java中的泛型是假的，只有在编译期间有效
+    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        ArrayList<Integer> list = new ArrayList<>();
+        Collections.addAll(list,1,2,3,4);
+        Class<? extends ArrayList> class1 = list.getClass();
+        Method add = class1.getMethod("add", Object.class);
+        add.invoke(list,"hhh");
+        System.out.println(list);
+    }
+}
+```
+
+# 方法引用：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260106153308790.png" alt="image-20260106153259853" style="zoom:50%;" />
+
+# Junit单元测试：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260106153753082.png" alt="image-20260106153751296" style="zoom:50%;" />
+
+## 总结：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20260106154608910.png" alt="image-20260106154607624" style="zoom:50%;" />
\ No newline at end of file
diff --git a/泛型.md b/泛型.md
new file mode 100644
index 0000000..f8bfabd
--- /dev/null
+++ b/泛型.md
@@ -0,0 +1,33 @@
+# 泛型
+
+介绍：
+
+JDK5版本后引入，用处为编译阶段约束数据类型，并例行检查。
+
+好处：
+
+统一了数据类型，将运行期的错误提到了编译期。
+
+注意：
+
+泛型只能用引用数据类型
+
+## 泛型类
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250428164803021.png" alt="image-20250428164753200" style="zoom:80%;" />
+
+## 泛型方法
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250428164850644.png" alt="image-20250428164848721" style="zoom:67%;" />
+
+## 泛型接口
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250428165135118.png" alt="image-20250428165133488" style="zoom: 67%;" />
+
+## 泛型通配符
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250428165220144.png" alt="image-20250428165218560" style="zoom:67%;" />
+
+## 总结
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250428165312329.png" alt="image-20250428165310376" style="zoom: 60%;" />
\ No newline at end of file
diff --git a/注解.md b/注解.md
new file mode 100644
index 0000000..dbd047f
--- /dev/null
+++ b/注解.md
@@ -0,0 +1,15 @@
+# 注解：
+
+是为了jvm虚拟机做标记
+
+![image-20260106202425198](https://gitee.com/icecat2233/picture/raw/master/20260106202427265.png)
+
+![image-20260106201531734](imgh/20260106201532735.png)
+
+# 元注解
+
+用在注解上的注解
+
+![image-20260106203337157](https://gitee.com/icecat2233/picture/raw/master/20260106203338364.png)
+
+![image-20260106203756219](https://gitee.com/icecat2233/picture/raw/master/20260106203757735.png)
\ No newline at end of file
diff --git a/线程.md b/线程.md
new file mode 100644
index 0000000..70a3a49
--- /dev/null
+++ b/线程.md
@@ -0,0 +1,467 @@
+# 线程
+
+## 进程和线程
+
+### 进程介绍：
+
+![image-20251226164954480](https://gitee.com/icecat2233/picture/raw/master/20251226164956071.png)
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226170135578.png" alt="image-20251226170130636" style="zoom:50%;" />
+
+### 线程Thread介绍：
+
+进程可以同时执行多个任务，每个任务就是线程：
+
+### 多线程的作用：
+
+提升执行效率，使更多进程可以并行执行
+
+服务器必须用多线程
+
+## Java中开启线程的方式：
+
+### 1:继承Thread类：
+
+案例：
+
+```Java
+ public static void main(String[] args) {
+        /*
+         * 继承Thread类
+         *         重写run方法
+         *         将线程任务代码写在run方法
+         *         创建对象
+         *         对象名.start开启线程
+         * 只有调用start方法才会开启一个新线程
+         */
+        Demo d1 = new Demo();
+        Demo d2 = new Demo();
+        d1.start();
+        d2.start();
+    }
+}
+
+class Demo extends Thread {
+    @Override
+    public void run() {
+        for (int i = 1; i <= 200; i++) {
+            System.out.println("打印了" + i);
+        }
+    }
+}
+```
+
+### 注意：
+
+![image-20251226175706557](https://gitee.com/icecat2233/picture/raw/master/20251226175707664.png)
+
+### 2：实现Runnable接口
+
+```java
+/*
+    方法2 实现runnable接口
+    编写一个类实现接口
+    重写run方法
+    创建线程任务资源（就是创建对象）
+    然后创建线程对象，将任务资源传入，走构造方法
+    使用线程对象调用start方法
+     */
+    public static void main(String[] args) {
+        MyRunnable mr = new MyRunnable();
+        Thread tr = new Thread(mr);
+        tr.start();
+    }
+}
+
+class MyRunnable implements Runnable{
+
+    @Override
+    public void run() {
+        System.out.println("八奈见杏菜");
+    }
+}
+```
+
+### 3：实现Callable接口(有结果返回)
+
+```java
+public class ThreadDemo3 {
+    public static void main(String[] args) throws Exception {
+        /*
+        创建一个类实现Callable接口
+        重写call方法
+        创建线程任务资源对象
+        创建线程任务对象，封装线程任务资源（FutureTask）
+        创建线程对象传入线程任务
+        使用线程对象调用start方法开启线程
+         */
+        MyCallAble mc = new MyCallAble();
+        FutureTask<Integer> ft = new FutureTask<>(mc);
+        Thread t = new Thread(ft);
+        t.start();
+        Integer result = ft.get();
+        System.out.println(result);
+    }
+}
+
+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;
+    }
+}
+```
+
+### 尽量选择后两个，拓展性更好
+
+## 线程的方法
+
+![image-20251226195404148](https://gitee.com/icecat2233/picture/raw/master/20251226195406047.png)
+
+### 名字相关：
+
+![image-20251226195311173](https://gitee.com/icecat2233/picture/raw/master/20251226195312281.png)
+
+### 休眠线程：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226195658228.png" alt="image-20251226195657226" style="zoom: 67%;" />
+
+### 线程调度方法：
+
+Java是抢占式调度
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226200312037.png" alt="image-20251226200310813" style="zoom:67%;" />
+
+### 守护线程
+
+`final void setDaemon(boolean on );`
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251226200638217.png" alt="image-20251226200636908" style="zoom: 67%;" />
+
+如图代码所示，t2守护t1，t1线程任务结束，t2也结束(不是立刻结束，t2会在苟活一会儿)
+
+哪个线程对象调用setDaemon方法，这个线程就是守护线程
+
+## 线程的安全与同步
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251227180107783.png" alt="image-20251227180059497" style="zoom: 50%;" />
+
+### 1.同步代码块：
+
+![image-20251227181232243](https://gitee.com/icecat2233/picture/raw/master/20251227181233315.png)
+
+**使用同步代码块指定锁对象时，用类的字节码对象**
+
+**共享数据要用static修饰**
+
+### 2.同步方法：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251227182958488.png" alt="image-20251227182957021" style="zoom: 67%;" />
+
+### 3.Lock锁：
+
+```Java
+public static void main(String[] args) {
+        TicketShop1 ts = new TicketShop1();
+        Thread t1 = new Thread(ts);
+        Thread t2 = new Thread(ts);
+        Thread t3 = new Thread(ts);
+        t1.start();
+        t2.start();
+        t3.start();
+    }
+}
+
+class TicketShop1 implements Runnable{
+    private int ticket = 100;
+    private ReentrantLock lock = new ReentrantLock();
+    @Override
+    public void run() {
+        while (true){
+            //上锁
+            try {
+                lock.lock();
+                if (ticket == 0){
+                    break;
+                }
+                System.out.println("卖出了"+ticket+"号票");
+                ticket--;
+            } finally {
+                //记得关闭锁
+                lock.unlock();
+            }
+        }
+    }
+}
+```
+
+附加知识点：死锁：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251227184708459.png" alt="image-20251227184706346" style="zoom:50%;" />
+
+## 线程通信
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228190237885.png" alt="image-20251228190234137" style="zoom:50%;" />
+
+### 两条线程交替执行案例：
+
+```Java
+public static void main(String[] args) {
+        Print p = new Print();
+        Thread t1= new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    synchronized (Print.class) {
+                        try {
+                            p.print1();
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+                }
+            }
+        });
+        t1.start();
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    synchronized (Print.class) {
+                        try {
+                            p.print2();
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+                }
+            }
+        });
+
+        t2.start();
+    }
+}
+
+class Print{
+    private int flag = 1;
+    public void print1() throws InterruptedException {
+        if (flag != 1){
+            //wait只能通过锁对象进行调用
+            Print.class.wait();
+        }
+        System.out.print("八");
+        System.out.print("奈");
+        System.out.print("见");
+        System.out.print("杏");
+        System.out.print("菜");
+        System.out.println();
+        flag = 2;
+        //notif拥有空唤醒的权利
+        Print.class.notify();
+    }
+    public void print2() throws InterruptedException {
+        if (flag != 2){
+            Print.class.wait();
+        }
+        System.out.print("温");
+        System.out.print("水");
+        System.out.print("佳");
+        System.out.print("树");
+        System.out.println();
+        flag = 1;
+        Print.class.notify();
+
+    }
+}
+```
+
+### 注意事项：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228190306178.png" alt="image-20251228190304630" style="zoom: 67%;" />
+
+### 若想提升效率，使用ReentrantLock实现同步，获取Condition对象
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228191731287.png" alt="image-20251228191729896" style="zoom:50%;" />
+
+注意：第一次指定线程等待时，绑定了线程
+
+### 三条线程交替执行案例：
+
+```Java
+public static void main(String[] args) {
+        Printer p = new Printer();
+        Thread t1= new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                        try {
+                            p.print1();
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException(e);
+                        }
+                }
+            }
+        });
+        t1.start();
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                        try {
+                            p.print2();
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException(e);
+                        }
+                }
+            }
+        });
+        t2.start();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    try {
+                        p.print3();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }).start();
+    }
+}
+
+class Printer{
+    private int flag = 1;
+    ReentrantLock lock = new ReentrantLock();
+    //调用newCondition来获取条件对象以此来指定线程
+        Condition c1 = lock.newCondition();
+        Condition c2 = lock.newCondition();
+        Condition c3 = lock.newCondition();
+
+    public void print1() throws InterruptedException {
+        lock.lock();
+        if (flag != 1){
+            //第一次调用await方法时绑定了线程
+            c1.await();
+        }
+        System.out.print("八");
+        System.out.print("奈");
+        System.out.print("见");
+        System.out.print("杏");
+        System.out.print("菜");
+        System.out.println();
+        flag = 2;
+        c2.signal();
+        lock.unlock();
+    }
+    public void print2() throws InterruptedException {
+        lock.lock();
+        if (flag != 2){
+            c2.await();
+        }
+        System.out.print("温");
+        System.out.print("水");
+        System.out.print("佳");
+        System.out.print("树");
+        System.out.println();
+        flag = 3;
+        c3.signal();
+        lock.unlock();
+    }
+
+    public void print3() throws InterruptedException {
+        lock.lock();
+        if (flag != 3){
+            c3.await();
+        }
+        System.out.print("温");
+        System.out.print("水");
+        System.out.print("梦");
+        System.out.print("子");
+        System.out.println();
+        flag = 1;
+        c1.signal();
+        lock.unlock();
+    }
+}
+```
+
+### 生产者消费者模式：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228193331390.png" alt="image-20251228193330122" style="zoom:50%;" />
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228193430647.png" alt="image-20251228193429569" style="zoom:50%;" />
+
+### 生产者消费者案例：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228193309975.png" alt="image-20251228193308023" style="zoom:67%;" />
+
+## 线程生命周期：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228194047345.png" alt="image-20251228194046082" style="zoom:67%;" />
+
+## 线程池：
+
+重点：自定义线程池
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228200136901.png" alt="image-20251228200135970" style="zoom:50%;" />
+
+**拒绝策略**：用的最多的只有第一种AbortPolicy
+
+![image-20251228200427425](https://gitee.com/icecat2233/picture/raw/master/20251228200428737.png)
+
+**任务队列：**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228200930260.png" alt="image-20251228200929336" style="zoom: 80%;" />
+
+### 总结：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228200821304.png" alt="image-20251228200820075" style="zoom:50%;" />
+
+### 案例：
+
+```Java
+public class Demo3 {
+    public static void main(String[] args) {
+        ThreadPoolExecutor tp = new ThreadPoolExecutor(
+                3,//核心数
+                6,//最大核心数
+                10,//空闲时间
+                TimeUnit.SECONDS,//时间单位
+                new ArrayBlockingQueue<>(10),//排队人数
+                Executors.defaultThreadFactory(),//线程对象任务工厂，基本为固定
+               new ThreadPoolExecutor.AbortPolicy()//拒绝策略，基本只用这个方法
+        );
+        for (int i = 1; i <17 ; i++) {
+            tp.submit(new Runnable() {
+                @Override
+                public void run() {
+                    System.out.println(Thread.currentThread().getName() + "调用了hhh");
+                }
+            });
+        }
+        tp.shutdown();
+    }
+}
+```
+
+## 单例设计模式：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228204751280.png" alt="image-20251228204750037" style="zoom:50%;" />
+
+两种方式：
+
+**饿汉式：简单不烧脑**：
+
+直接创建出对象 而不是调用方法的时候再创建对象
+
+**懒汉式：（延迟加载模式）：**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251228204928022.png" alt="image-20251228204926855" style="zoom:50%;" />
\ No newline at end of file
diff --git a/网络编程.md b/网络编程.md
new file mode 100644
index 0000000..9410941
--- /dev/null
+++ b/网络编程.md
@@ -0,0 +1,238 @@
+# 网络编程：
+
+## 软件架构：
+
+**BS**
+
+Browser Server 浏览器 服务端
+
+**CS**
+
+Client Server 客户段 服务端
+
+## 总结：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229162054898.png" alt="image-20251229162046866" style="zoom: 50%;" />
+
+## 网络编程三要素
+
+### **IP**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229162724636.png" alt="image-20251229162723116" style="zoom:50%;" />
+
+**特殊ip地址：**
+
+![image-20251229163018519](https://gitee.com/icecat2233/picture/raw/master/20251229163019681.png)
+
+**常用命令：**
+
+ipconfig:查看本机ip地址
+
+ping:检查网络是否畅通
+
+### **端口**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229164024494.png" alt="image-20251229164022824" style="zoom:50%;" />
+
+### 协议
+
+**UDP协议：不可靠  速度快**
+
+案例：收发消息：
+
+接收端：
+
+```Java
+public class Receive {
+    public static void main(String[] args) throws Exception{
+        //创建DatagramSocket对象
+        DatagramSocket socket = new DatagramSocket(9999);
+        //创建DatagramPacket对象
+        DatagramPacket packet = new DatagramPacket(new byte[1024],1024);
+        //接受信息
+        socket.receive(packet);
+        //拆包裹
+        byte [] data =packet.getData();
+        String msg = new String(data);
+        String ip = packet.getAddress().getHostAddress();
+        System.out.println("从"+ip+"ip发过来的信息："+msg);
+        //释放资源
+        socket.close();
+    }
+}
+```
+
+发送端：
+
+```Java
+public class Send {
+    public static void main(String[] args) throws Exception{
+        //创建DatagramSocket对象
+        DatagramSocket socket = new DatagramSocket(8888);
+        //准备材料
+        String msg ="あんな别吃了";
+        byte[] bytes = msg.getBytes();
+        //打包包裹
+        DatagramPacket packet = new DatagramPacket(bytes,
+                bytes.length,
+                InetAddress.getByName("127.0.0.1"),//参数为对方的ip对方的端口
+                9999);
+        socket.send(packet);
+        socket.close();
+
+    }
+}
+```
+
+**TCP协议：可靠信息安全，速度慢**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229173459039.png" alt="image-20251229173457548" style="zoom:50%;" />
+
+**三次握手：**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229184655532.png" alt="image-20251229184654252" style="zoom: 50%;" />
+
+**四次挥手：**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251229185455707.png" alt="image-20251229185454457" style="zoom:50%;" />
+
+大型案例：重点分析：
+
+TCP上传文件：
+
+客户端
+
+```Java
+package com.ice.cat.test;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.net.Socket;
+
+public class Client {
+    public static void main(String[] args) throws Exception {
+        Socket socket = new Socket("10.104.117.228",9999);
+        //获取输入输出流
+        InputStream is = socket.getInputStream();
+        OutputStream os = socket.getOutputStream();
+        //将字节流转化为字符流，用来处理一些中文字符,再转化为字符缓冲流，可以读取一整行
+        BufferedReader br =  new BufferedReader(new InputStreamReader(is));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
+        //写出文件的名字
+        File file = new File("C:\\Users\\asus\\Pictures\\ariya.png");
+        bw.write(file.getName());//没带换行符
+        bw.newLine();
+        bw.flush();
+        //接受客户端反馈
+        String flag = br.readLine();
+        if (flag.equals("ok")){
+            //继续上传文件
+            //创建本地流，上传图片
+            FileInputStream fle = new FileInputStream(file);
+            byte [] bys = new byte[1024];
+            int lne;
+            while ((lne = fle.read(bys)) != -1){
+                os.write(bys,0,lne);
+            }
+            fle.close();
+            //重点：给服务端一个结束标记
+            socket.shutdownOutput();//通俗理解，写出了一个-1标记
+        }
+        //读取服务端的返回消息消息
+        String result = br.readLine();
+        System.out.println(result);
+        socket.close();
+    }
+}
+```
+
+服务端：
+
+```Java
+package com.ice.cat.test;
+
+import java.io.*;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.UUID;
+import java.util.concurrent.*;
+
+public class Server {
+    public static void main(String[] args) throws Exception {
+        //创建线程池
+        ThreadPoolExecutor pool = new ThreadPoolExecutor(4,
+                6,
+                60,
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(10),
+                Executors.defaultThreadFactory(),
+                new ThreadPoolExecutor.AbortPolicy());
+
+        ServerSocket server = new ServerSocket(9999);
+        System.out.println("服务端开启，等待客户端连接");
+        //响应请求
+        //多次响应上传图片，用循环包裹
+        while (true) {
+            Socket socket = server.accept();
+            pool.submit(new SubmitTask(socket));
+        }
+    }
+}
+```
+
+线程池代码：为实现多次运行，可在不同线程进行调用
+
+```Java
+package com.ice.cat.test;
+
+import java.io.*;
+import java.net.Socket;
+import java.util.UUID;
+
+public class SubmitTask implements Runnable{
+private Socket socket;
+public SubmitTask(Socket socket){
+    this.socket = socket;
+}
+    @Override
+    public void run() {
+
+        try {
+            InputStream is = socket.getInputStream();
+            OutputStream os = socket.getOutputStream();
+            //将字节流转化为字符流，用来处理一些中文字符,再转化为字符缓冲流，可以读取一整行
+            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
+            //接受文件名字
+            String resultName = br.readLine();
+            //给用户端反馈
+            bw.write("ok");
+            bw.newLine();
+            bw.flush();
+            //读取客户端上传的文件,注意写出上传的位置
+            //为避免文件名字重复使用UUID方法
+            File file = new File("C:\\Users\\asus\\Desktop\\JAVA", UUID.randomUUID().toString() + resultName);
+            //准备本地的输出流，将网络服务端数据写入到指定位置
+            FileOutputStream fos = new FileOutputStream(file);
+            //读取网络流数据，写入到本地文件
+            int lne;
+            byte[] bys = new byte[1024];
+            //is为网络输入流，没有关联文件，不可能有-1
+            while ((lne = is.read(bys)) != -1) {
+                fos.write(bys, 0, lne);
+            }
+            fos.close();
+            //回写给客户段消息
+            bw.write("上传成功");
+            bw.newLine();
+            bw.flush();
+            //关流
+            socket.close();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
+```
+
+补充点：若文件名重复则使用UUID.randomUUID().toString()来生成随机名字
\ No newline at end of file
diff --git a/集合-数据结构相关.md b/集合-数据结构相关.md
index 39b0e7f..6673751 100644
--- a/集合-数据结构相关.md
+++ b/集合-数据结构相关.md
@@ -76,9 +76,28 @@ public class Test2 {
 ## List集合的5种遍历方式
 
 1. Iterator迭代器
+
+   <img src="https://gitee.com/icecat2233/picture/raw/master/20251221153337614.png" alt="image-20251221153329358" style="zoom:50%;" />
+
 2. 增强for循环
+
+   ```Java
+   //增强for循环
+   //for(元素类型，起名 : 遍历的集合)
+   for (Student stu : c) {
+       System.out.println(stu);
+   }
+   ```
+
 3. foreach
+
+   ```Java
+   //foreach循环
+   c.forEach(stu -> System.out.println(stu));
+   ```
+
 4. 普通for循环
+
 5. ListIterator迭代器
 
 # 数据结构：栈 队列 链表 数组
@@ -102,3 +121,187 @@ public class Test2 {
 ## LinkedList特有方法
 
 removeFirst()   removeLast()
+
+# Set集合
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220175508010.png" alt="image-20251220175506487" style="zoom:67%;" />
+
+## 数据结构：树
+
+树的知识点总结：
+
+![image-20251012170947546](https://gitee.com/icecat2233/picture/raw/master/20251012171010346.png)
+
+## 三种二叉树
+
+![image-20250509183934916](https://gitee.com/icecat2233/picture/raw/master/20250509183936223.png)
+
+## 平衡二叉树
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250509183513481.png" alt="image-20250509183446340" style="zoom: 50%;" />
+
+## 红黑树(重难点)
+
+红黑树是一种特殊的平衡二叉树，但并不是完全平衡的平衡二叉树，效率最高
+
+**添加树的情况**
+
+![image-20250509201524220](https://gitee.com/icecat2233/picture/raw/master/20250509201525478.png)
+
+## TreeSet集合
+
+**排序和取出顺序示例：**
+
+![image-20251217162402752](https://gitee.com/icecat2233/picture/raw/master/20251217162411298.png)
+
+**自然排序示例：**
+
+![image-20250510170405367](https://gitee.com/icecat2233/picture/raw/master/20250510170406417.png)
+
+比较器排序示例：
+
+### **注意：**
+
+**this - 0 正序  o-this 降序**
+
+**o1 - o2 正序，o2 - o1 降序**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250510170601190.png" alt="image-20250510170600150" style="zoom: 67%;" />
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250510170515008.png" alt="image-20250510170513793" style="zoom:50%;" />
+
+两种方式比较：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20250510170101423.png" alt="image-20250510170052265" style="zoom:67%;" />
+
+# HashSet
+
+## 基本运用：
+
+特点：去重（hashCode方法和equals方法共同运用）
+
+遍历：迭代器，增强for循环，foreach方法
+
+## **HashSet组成：**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220165008373.png" alt="image-20251220165000000" style="zoom:67%;" />
+
+## **JDK8版本以后Hashset的添加过程（面试常问重点！）**
+
+### **2**步骤过程：
+
+**将数值调用hashCode方法得到原始哈希值，然后将原始哈希值向右移动16位与原始哈希值进行异或操作，得到的数值与数组长度作取模运算得到位置。**
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220165204636.png" alt="image-20251220165202216" style="zoom:67%;" />
+
+## 如何提高HashSet查询过程：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220165544826.png" alt="image-20251220165543271" style="zoom:67%;" />
+
+## LinkedHashSet集合
+
+## 特点：
+
+**有序**，不重复，无索引，保证存取顺序。
+
+
+
+# 集合总结：
+
+![image-20251220171433114](https://gitee.com/icecat2233/picture/raw/master/20251220171435072.png)
+
+# 小知识点：可变参数
+
+可变参数用在形参中可以接受多个数据。
+
+例：`int...  名称`；
+
+传输参数非常灵活，方便，可以不传参数，可以传1个或多个，也可以传数组
+
+**方法本质就是一个数组**
+
+# Collections集合工具类：
+
+![image-20251220173953237](https://gitee.com/icecat2233/picture/raw/master/20251220173954809.png)
+
+![image-20251220174214148](https://gitee.com/icecat2233/picture/raw/master/20251220174215755.png)
+
+示例：
+
+```java
+//多数据添加
+        TreeSet<Student> alist = new TreeSet<>();
+        Collections.addAll(alist,new Student("张三",14),new Student("八奈见杏菜",16),new Student("七奈见杏菜",16));
+        System.out.println(alist);
+        //二分查找
+        ArrayList<String> ts = new ArrayList<>();
+        Collections.addAll(ts,"2","3","4");
+        System.out.println(Collections.binarySearch(ts, "2"));
+        //洗牌
+        ArrayList<Student> blist = new ArrayList<>();
+        Collections.shuffle(blist);
+        System.out.println(alist);
+        //从集合中找最值
+        System.out.println(Collections.max(ts));
+        System.out.println(Collections.min(ts));
+        System.out.println(Collections.min(alist));
+        System.out.println(Collections.max(alist));
+```
+
+
+
+# MAP集合：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220201802981.png" alt="image-20251220201801335" style="zoom:67%;" />
+
+## 常用API：
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220201935518.png" alt="image-20251220201929102" style="zoom:67%;" />
+
+## MAP特点：
+
+![image-20251220202017714](https://gitee.com/icecat2233/picture/raw/master/20251220202019112.png)
+
+![image-20251220203224248](https://gitee.com/icecat2233/picture/raw/master/20251220203226325.png)
+
+## Map的三种遍历方式
+
+### 1：entrySet方法
+
+<img src="https://gitee.com/icecat2233/picture/raw/master/20251220205849706.png" alt="image-20251220205848087" style="zoom:50%;" />
+
+```java
+HashMap<String, String> m = new HashMap<>();
+        m.put("杏菜", "15岁");
+        m.put("佳树", "14岁");
+        m.put("温水", "15岁");
+        m.put("梦子", "15岁");
+        //用entrySet方法获取到所有键值对象 
+        Set<Map.Entry<String, String>> entrySet = m.entrySet();
+        //遍历set集合获取到每一个键值对儿对象
+        for (Map.Entry<String, String> stringStringEntry : entrySet) {
+            //通过键值对对象获取每一个数值
+            System.out.println(stringStringEntry.getKey() + "---" + stringStringEntry.getValue());
+        }
+
+```
+
+### 2：foreach方法：
+
+```Java
+hs.forEach(new BiConsumer<String, List<String>>() {
+    @Override
+    public void accept(String key, List<String> value) {
+        System.out.print(key+"=");
+        List list = value;
+        for (int i = 0; i < list.size()-1; i++) {
+            System.out.print(list.get(i)+",");
+        }
+        System.out.println(list.get(value.size()-1));
+    }
+});
+```
+
+### 3:调用keyset方法获取所有键值
+
+![image-20251221174612093](https://gitee.com/icecat2233/picture/raw/master/20251221174613322.png)