new commit

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%;" />

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 + "}";
+    }
+}
+```

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;
+    }
+}
+```