• I O 流

    Stream流的三类方法

    • 获取Stream流
      创建一条流水线，并把数据放到流水线上准备进行操作
    • 中间方法
      流水线上的操作
      一次操作完毕之后，还可以继续进行其他操作。
    • 终结方法
      一个Stream流只能有一个终结方法
      是流水线上的最后一个操作

    Stream流的获取方法

    • 单列集合
      可以使用Collection接口中的默认方法stream()生成流
      default() Stream stream()
    • 双列集合
      间接的生成流
      可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
    • 数组
      Arrays中的静态方法steam生成流
    • 同种数据类型的多个数据
      Stream.of(数据1，数据2，。。。。)
    package com.stream.demo;

import java.util.stream.Stream;

public class MyStream5 {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8).forEach(s-> System.out.println(s));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    单列集合

    package com.stream.demo;

import java.util.ArrayList;
import java.util.stream.Stream;

public class MyStream2 {
    public static void main(String[] args) {
        //单列集合
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

//        Stream stream = list.stream();
//        stream.forEach(s-> System.out.println(s));
        list.stream().forEach(s-> System.out.println(s));

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    双列集合

    package com.stream.demo;

import java.util.HashMap;

public class MyStream3 {
    public static void main(String[] args) {
        //双列集合
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);
        //双列集合不能直接获取Stream流
        //KeySet  //先获取所有的键
        //再把这个Set集合中所有的键放到Stream流中
       // hm.keySet().stream().forEach(s-> System.out.println(s));

        //entrySet
        // 先获取到所有键值对对象
        //再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));


    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    数组

    package com.stream.demo;

import java.util.Arrays;

public class MyStream4 {
    public static void main(String[] args) {
        //数组
        int[] arr = {1, 2, 3, 4, 5};
        Arrays.stream(arr).forEach(s -> System.out.println(s));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    常用中间方法

    package com.stream.demo;

import java.util.ArrayList;
import java.util.stream.Stream;

public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无极");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //Stream limit (long maxSize) 截取指定参数个数的数据
        list.stream().limit(2).forEach(s -> System.out.println(s));

        //Stream skip(long n ) 跳过指定参数个数的数据
        list.stream().skip(2).forEach(s -> System.out.println(s));
        //static  Stream concat (Stream a,Stream b) 合并a和b两个流为一个流

        System.out.println("---------------------");
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无极");
        list2.add("张翠山");
        list2.add("王二麻子");
        list2.add("张良");
        list2.add("谢广坤");
        list2.add("谢广坤");
        list2.add("谢广坤");
        list2.add("谢广坤");
        list2.add("谢广坤");
        list2.add("谢广坤");
        list2.add("谢广坤");

//        Stream stream1 = list.stream();
//        Stream stream2 = list2.stream();
//
//        Stream stream3 = Stream.concat(stream1, stream2);
//        stream3.forEach(s-> System.out.println(s));

        Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));

        System.out.println("------------------==================");
        //Stream  distinct() : 去除流中重复的元素。 依赖（hashcode和equals方法）

        list2.stream().distinct().forEach(s -> System.out.println(s));

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    常见终结方法

    import java.util.ArrayList;
import java.util.function.Consumer;
public class MyStream8 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无极");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //void foreach(Consumer action) 对此流的每个元素执行操作
//        Consumer接口中的方法 void accpect(T t) 对给定的参数执行操作

        //在forEach方法中的底层，会循环获取到流中的每一个数据
        //并循环调用acceot方法，并把每一个数据传递给accpect方法
        //s就依次表示流中的每一个数据
        //所以，只要在accep方法中，写上处理的业务逻辑就可以
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        System.out.println("6666666666666666666666666666666");
        list.stream().forEach(
                (String s) -> {
                    System.out.println(s);
                }
        );
        System.out.println("6666666666666666666666666666666");
        list.stream().forEach(s -> System.out.println(s));


        //long count() 返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }

}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    在Stream流中无法直接修改集合，数组等数据源中的数据

    package com.stream.demo;


import java.util.ArrayList;

public class MyStream9 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
//        list.stream().filter(
//                (Integer i) -> {
//                    return i % 2 == 0;
//                }
//        );
        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
        System.out.println("========================");
        System.out.println(list);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    收集方法

    package com.stream.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class MyStream0 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }

        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        //filter负责过滤数据的
        //collect负责收集数据
        //获取流中剩余数据，但是他不负责创建容器，也不负责把数据添加到容器
        //Collectors.toList() 底层会创建一个List集合，并把所有的数据添加到List集合中
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(list);


        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    收集方法

    package com.stream.demo;

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

public class MyStream10 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");

        Map<String, Integer> map = list.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }
                /**
                 * collect方法只能获取到流中剩余的每一个数据
                 * 在底层不能创建容器，也不能把数据添加到容器当中
                 * collectors,toMap创建一个map集合并将数据添加到集合
                 * s一次表示流中的每一个数据
                 * 第一个lambda表达式如何获取map中键
                 * 第2个lambda表达式如何获取map中值
                 */
        ).collect(Collectors.toMap(
                (String s) -> {
                    return s.split(",")[0];
                },
                (String s) -> {
                    return Integer.parseInt(s.split(",")[1]);
                }
        ));
        System.out.println(map);

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    IO流是什么

    1、可以将数据从本地文件读取出来
    2、可以将数据从内存保存到本地文件

    File类是什么

    1、在读写数据时告诉虚拟机要操作的（文件/文件夹）在哪
    2、对（文件/文件夹）本身进行操作，包括创建、删除等

    File类概述和构造方法

    File:它是文件和目录路径名的抽象表示

    • 文件和目录可以通过File封装成对象
    • File封装的对象仅仅是一个路径名。它可以是存在的，也可以是不存在的。

    file类的构造

    package com.stream.fiedemo;

import java.io.File;

public class FileDemo1 {
    public static void main(String[] args) {
        // method1();
        //method2();
        //method3();


    }

    private static void method3() {
        //File(File parent,String child)
        //从父抽象路径名和子路径名字符串创建新的File实例
        File file1 = new File("D:\\itheima");
        String path = "a.txt";
        File file = new File(file1, path);
        System.out.println(file);
    }

    private static void method2() {
        //File(String parent,String child)
        //从父路径名字符串和子路名字符串创建新的File实例
        String path1 = "D:\\itheima";
        String path2 = "a.txt";
        File file = new File(path1, path2);//将两个路径拼接
        System.out.println(file);
    }

    private static void method1() {
        //file（String pathname）通过将给定的路径名字符串转换为抽象路径来创建新的File
        String path = "D:\\itheima\\a.txt";
        File file = new File(path);
        //为什么要把字符串表示形式的路径变成File对象
        //就是为了使用File里面的方法
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    创建文件夹

    package com.stream.fiedemo;

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

public class FileDemo2 {
    public static void main(String[] args) throws IOException {
        //public boolean createNewFile() 创建一个新的空的文件
        /**
         * 如果文件存在，创建失败，返回false
         * 如果文件不存在，创建成功，返回true
         * createNewFile方法不管调用者有没有后缀名，只能创建文件
         */
        //public boolean mkdir() 创建一个单级文件夹
        /**
         * 只能创建单级文件夹，不能创建多级文件夹
         * 无论调用者有没有后缀名，只能创建单机文件夹
         */
        //public boolean mkdirs() 创建一个多级文件夹
        /**
         * 可以创建单级文件夹
         * 也可以创建多级文件夹
         * 只能创建文件夹
         */
        //method1();
        //method2();

        File file = new File("D:\\itheima\\aaa\\bb\\cc\\ddd");
        boolean result = file.mkdirs();
        System.out.println(result);


    }

    private static void method2() {
        File file = new File("D:\\itheima\\aaa");
        boolean result = file.mkdir();
        System.out.println(result);
    }

    private static void method1() throws IOException {
        File file1 = new File("D:\\itheima\\a.txt");
        boolean result1 = file1.createNewFile();
        System.out.println(result1);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    删除文件

    package com.stream.fiedemo;

import java.io.File;

public class FileDemo3 {
    public static void main(String[] args) {
        /**
         * 不走回收站的
         * 删除的是文件，直接删除，如果删除的是文件夹，只能删除空间文件夹
         * 只能删除文件和空文件夹
         *
         */
        //method1();
        File file = new File("D:\\itheima");
        boolean result = file.delete();
        System.out.println(result);
        
    }
    private static void method1() {
        File file = new File("D:\\itheima\\a.txt");
        boolean result = file.delete();
        System.out.println(result);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    File类高级获取功能

    package com.stream.fiedemo;

import java.io.File;

public class FileDemo5 {
    public static void main(String[] args) {
        File file = new File("D:\\");
        File[] files = file.listFiles();
        for (File path : files) {
            System.out.println(path);

        }
        /**
         * 进入文件夹，获取这个文件夹里面所有的文件和文件夹File对象，并把这些File对象都放在一个数组中返回
         * 包括隐藏文件和隐藏文件夹都可以获取
         */
        
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 当调用者不存在时，返回null
    • 当调用者是一个文件时，返回null
    • 当调用者是一个空文件夹时，返回一个长度为0的数组
    • 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
    • 当调用者是一个有隐藏文件的文件夹时，将里面所有的文件夹的路径放在File数组中返回，包含隐藏内容
    • 当调用者是一个需要权限才能进入的文件夹时，返回null

    IO流

    目的

    • 将数据写到文件中，实现数据永久化存储
    • 读取文件中已存在的数据
      IO的数据传输，可以看做一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作。
      简单来说：内存在读，内存在写。
      在这里插入图片描述
      一般来说，IO流的分类是按照数据类型来分的
    package com.output;

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

public class OutputDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        /**
         * 如果文件不存在，会帮我们自动创建文件
         * 如果文件存在，会把文件清空
         */
        FileOutputStream fos = new FileOutputStream("D:\\Javase\\a.txt");
        //写数据
        fos.write(97);
        //释放资源
        fos.close();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    字节流写数据
    步骤：
    1、 创建字节输出流对象
    注意事项：

    • 如果文件不存在，就创建
    • 如果文件存在就清除
      2、写数据
      注意事项：
    • 写出的整数，实际是ASCII码表对应的字母
      3、释放自由
      每次使用完流必须释放资源
      字节流写数据如何实现追加
    • 创建文件输出流以指定的名称写入文件。如果第二个参数true，不会清空文件里面的内容
    package com.output;

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

public class OutputDemo3 {
    public static void main(String[] args) throws IOException {
        /**
         * 第二个参数就是续写开关，没有传递，默认是false
         * 表示不打开续写功能，那么创建对象的这行代码会清空文件
         * 如果第二个参数true，表示打开续写功能
         * 那么创建对象的这行代码不会清空文件
         */
        FileOutputStream fos = new FileOutputStream("io\\a.txt",true);
       fos.write(97);
       fos.write("\r\n".getBytes());
       fos.write(98);
        fos.write("\r\n".getBytes());
       fos.write(99);
        fos.write("\r\n".getBytes());
       fos.write(100);
        fos.write("\r\n".getBytes());
       fos.write(101);
        fos.write("\r\n".getBytes());
        fos.write(102);
        fos.close();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    提高拷贝速度

    解决速度问题，字节流通过创建字节数组，可以一次读多个数据
    一次读一个字节数组的方法：

    • public int read(byte[] b): 从输入流读取最多b.length个字节数据
    • 返回的是读入缓冲区的总字节数，也就是实际的读取字节个数

    在这里插入图片描述

    字节流：

    可以操作（拷贝）所有类型文件

    字节缓冲流：

    可以提高效率
    不能直接操作文件，需要传递字节流

    拷贝文件的四种方式

    • 字节流一次读写一个字节
    
import java.io.FileInputStream;
import java.io.IOException;

public class OutputDemo4 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("io\\a.txt");
        int red =fis.read();
        /**
         * 一次读取一个字节，返回值就是本次读到的那个字节数据
         * 也就是字符在码表中对应的那个数字
         * 如果我们想要看到的字符数据，要转成强转char
         */
        System.out.println((char)red);
        fis.close();

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    
import java.io.FileInputStream;
import java.io.IOException;

public class OutputDemo5 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("io\\a.txt");
        int b  ;
        while ((b =fis.read())!=-1){
            System.out.println((char)b);
        }
        fis.close();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 字节流一次读写一个字节数组
    import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutputDemo7 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\itheima\\a.jpg");
        FileInputStream fis = new FileInputStream("io\\a.jpg");

        byte[] bytes = new byte[1024];
        int len; //本次读取到的有效字节个数    -- 这次读了几个字节
        while ((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 字节缓冲流一次操作一个字节
    public class OutputDemo8 {
    public static void main(String[] args) throws IOException {
        //缓冲流拷贝文件

        //创建一个字节缓冲输入流
        //在底层创建了一个默认长度8192的字节数组
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("io\\a.jpg"));
        //字节缓冲输出流
        //在底层创建了一个默认长度8192的字节数组
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io\\copoy.jpg"));
        int b;
        while ((b = bis.read())!=-1){
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 字节缓冲流一次操作一个字节数组
    
import java.io.*;

public class OutputDemo9 {
    //缓冲流结合数组，进行文件拷贝
    public static void main(String[] args) throws IOException {
        //创建一个字节缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\itheima\\a.jpg"));
        //创建一个字节缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io\\aop.jpg"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bis.close();
        bos.close();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    乱码
    因为字节流读中文，每次只能读一部分所以出现乱码
    不管在那张表中，中文的第一个字节一定是负数
    字符流 = 字节流 + 编码表
    GBK码表一个中文两个字节
    UTF-8编码格式一个中文3个字节
    把文件中数据读到内存中，使用字符输入流
    把内存中的数据写到文件中，使用字符输出流
    进行拷贝，一律用字节流或者字节缓冲流
    在这里插入图片描述

    字符缓冲流

    BufferedWriter: 可以将数据高效的写出
    BufferedReader: 可以将数据高效的读取到内存。
    在这里插入图片描述

    转换流

    对象操作流特点
    可以把对象以字节的形式写到本地文件，直接打开文件，是读不懂的，需要再次用对象操作流读到内存中。
    对象操作流分两类，对象操作输入流和对象操作输出流
    对象操作输出流（对象序列化流）：就是将对象写到本地文件中，或者在网络中传输对象
    对象操作输入流（对象反序列化流）：把写到本地文件中的对象读到内存中，或者接收网络中传输的对象

    • 给成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

    Properties

    • 是一个Map体系集合类
    • Properties中有跟IO相关的方法
    • 只存字符串
    package com.propertiesio;

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class PropertiesDemo1 {
    public static void main(String[] args) {
        Properties prop = new Properties();
        //  增
        prop.put("郭达", "杰森斯坦森");
        prop.put("曹操", "曹植");
        prop.put("刘秀", "刘邦");
        prop.put("嬴政", "秦王");
        System.out.println(prop);

        //删除

        prop.remove("曹操");
        System.out.println(prop);
        //改
        prop.put("郭达", "画虎");
        System.out.println(prop);
        //查
        Object v = prop.get("嬴政");
        System.out.println(v);

        //遍历
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            Object value = prop.get(key);
            System.out.println(key + "=" + value);

        }
        System.out.println("--------------------");
        //装的是所有的键值对
        Set<Map.Entry<Object, Object>> entries = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
  • 相关阅读:
    web：[极客大挑战 2019]LoveSQL
    1684、统计一致字符串的数目（暴力+哈希）
    CSP-J 2019 入门级 第一轮 第17题
    职称评审的业绩要求，余老师为人才讲讲都需要符合什么条件的业绩
    Python 实例教学一
    【深度学习】（四）目标检测——上篇
    【Git】使用git上传项目到github
    模板-进阶（没有什么内容，只是一个知识点）
    Python 获取谷歌切片数据，在cesium上加载
    k8s集群授权prometheus（集群外部署）
  • 原文地址：https://blog.csdn.net/pilipala_biu/article/details/126277555