第三次预习

最新推荐文章于 2025-05-06 17:40:03 发布

a_666789

最新推荐文章于 2025-05-06 17:40:03 发布

阅读量1k

点赞数 13

文章标签： windows

本文链接：https://blog.csdn.net/a_666789/article/details/146979022

版权

Stream流

作用：配合Lambda表达式，简化集合和数组操作

Stream流思想

将数据到流中（获取流对象）

将数据放在流水线的传送带上

集合获取：Stream流对象（使用Collection接口中的默认方法）

名称	说明
default Stream<E> stream()	获取当前集合对象的Stream流

//示例
public static void main(String[] args){
    List<String> list = new ArrayList<~>();
    list.add("张三丰");
    list.add("张无忌");
    list.add("张翠山");
    list.add("王二麻子");
    list.add("张良");
    list.add("谢广坤");
    
    list.stream().forEach(s -> System.out.printlin(s));

    Set<String> set = new HashSet<~>();
    set.add("张三丰");
    set.add("张无忌");
    set.add("张翠山");
    set.add("王二麻子");
    set.add("张良");
    set.add("谢广坤");
    
    set.stream().forEach(s -> System.out.printlin(s));

    Map<String, Integer> map = new HashMap<~>();
    map.add("张三丰",100);
    map.add("张无忌",35);
    map.add("张翠山",55);
    map.add("王二麻子",22);
    map.add("张良",30);
    map.add("谢广坤",55);
    
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
    entrySet.stream().forEach(s -> System.out.printlin(s));

}

数组获取：Stream流对象（使用Arrays数组工具类中的静态方法）

名称	说明
static <T> Stream<T> stream(T[] array)	将传入的数组封装到Stream流对象中

//示例
public static void main(String[] args){

    int[] arr1 = {11, 22, 33};
    double[] arr2 = {11.1, 22.2, 33.3};

    Arrays.stream(arr1).forEach(s -> System.out.printlin(s));
    Arrays.stream(arr2).forEach(s -> System.out.printlin(s));

}

零散的数据获取Stream流对象（使用Stream类中的静态方法）

名称	说明
static <T> Stream<T> of(T... values)	把一对零散的数据封装到Stream流对象中

//示例
public static void main(String[] args){

    Stream.of(1, 2, 3, 4, 5, 6).forEach(s -> System.out.printlin(s));
    Stream.of("张三","李四","王五","赵六").forEach(s -> System.out.printlin(s));

}

中间方法

注意：

中间方法调用完成后返回新的Stream流，可以继续操作，支持链式编程
如果流对象已经被消费过，就不允许在此使用了

名称	说明
Stream<T> filter(Predicate<? super T> predicate	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
Stream<T> distinct()	去掉流中重复的元素依赖（hashCode和equals方法）
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流

public static void main(String[] args){
    //需求：将集合中以“张”开头的数据，过滤出来打印在控制台
    ArrayList<String> list = new ArrayList<~>();
    list.add("林青霞");
    list.add("张曼玉");
    list.add("王祖贤");
    list.add("柳岩");
    list.add("张敏");
    list.add("张无忌");

    list.stream().filter(new Predicate<String>(){
        @Override
        public boolean test(String s){
            return s.startsWith("张");
        }
    ).forEach(s -> System.ou.printlin(s));
//等效于
    list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.printlin(s));

    //需求1：取:前3个数据在控制台输出
    list.stream().limit(3).forEach(s -> System.out.printlin(s));

    //需求2：跳过前3个元素，把剩下的元素在控制台输出
    list.stream().skip(3).forEach(s -> System.out.printlin(s));

    //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
    list.stream().skip(2).limit(2).forEach(s -> System.out.printlin(s));

    //需求4：取前4个数据组成一个流
    Stream<String> s1 = list.stream().limit(4);

    //需求5：
    Stream<String> s2 = list.stream().skip(2);

    //需求6：合并需求4和需求5得到的流，并把结果在控制台输出
    Stream<String> s3 = Stream.concat(s1, s2);
    //s3.forEach(s -> System.out.printlin(s));    由于对象只能消费一次，所以在实现需求7之前，不能消费s3

    //需求7：合并需求4和需求5得到的流，并把结果在控制台输出，要求字符串元素不能重复
    s3.distinct().forEach(s -> System.out.printlin(s));
}

终结方法

流水线中的最后一道工序

名称	说明
void forEach(Consumer action)	对此流中的每个元素执行遍历操作
Long count()	返回此流中的元素数

public static void main(String[] args){
    long count = Stream.of(1, 2, 3, 4, 5, 6).filter(s -> s % 2 == 0).count();
    System.out.printlin(count);
}

Stream收集操作

把Stream流操作后的结果数据转回到集合
名称说明
R collect(Collector collector) 开始手机Stream流，指定收集器

名称	说明
R collect(Collector collector)	开始手机Stream流，指定收集器

Stream流操作，不会修改数据源

名称	说明
public static <T> Collector toList()	把元素收集到List集合中
public static <T> Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper ,Function valueMapper)	把元素收集到Map集合中

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

list.stream().filter(s -> s % 2 == 0).forEach(s -> System.out.printlin(s));

System.out.printlin(list);

public static void main(String[] args){

    List<Integer> list1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(s -> s % 2 == 0).collect(Collections.toList());
    System.out.printlin(list1);

    Set<Integer> list2 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(s -> s % 2 == 0).collect(Collections.toSet());
    System.out.printlin(list2);

}

/*
    创建一个ArrayList集合，并添加以下字符串
    “张三，23”
    “李四，24”
    “王五，25”
    保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
public static void main(String[] args){
    ArrayList<String> list = new ArrayList<>();
    list.add("张三, 23");
    list.add("李四, 24");
    list.add("王五, 25");

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

    System.out.printlin(map);
}
}

File类

File类代表操作系统的文件对象（文件、文件夹）

File类创建对象

File对象可以定位文件和文件夹
File封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的

方法名称	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	根据父路径名字符串和子路径名字符串创建文件对象
public File(File parent, String child)	根据父路径名对应文件对象和子路径名字符串创建文件对象

public static void main(String[] args) throws IDException{
    File f1 = new File("D:\\A.txt");
    f1.createNewFile();

    File f2 = new File("D:\\test");
    System.out.printlin(f2.exists());

    File f3 = new File("D:\\", "test");
    System.out.printlin(f3.exists());

    File f4 = new File(new File("D:\\"), "test");
    System.out.printlin(f4.exists());
}

路径的写法

绝对路径：从盘符根目录开始，一直到某个具体的文件或文件夹
```
public static void main(String[] args){
    File f = new File("D:\\A.txt");
}
```
相对路径：相对于当前项目

public static void main(String[] args) throws IDException{
    File f = new File("src/com/itheima/A.txt");
    f.createNewFile();
}

File类的常用方法

方法名称	说明
public boolean isDirectory()	判断此路径名表示的File是否为文件夹
public boolean isFile()	判断此路径名表示的File是否为文件
public boolean exists()	判断此路径名表示的FIle是否存在
public long length()	返回文件的大小（字节数量）文件对象操作时，返回正确的字节个数文件夹对象操作时，返回错误的字节个数
public String getAbsolutePath(0	返回文件的绝对路径
public String getPath()	返回定义文件或文件夹时使用的路径
public String getName()	返回文件的名称，带后缀
public long last Modified()	返回文件的最后修改时间（时间毫秒值）

File f1 = new File("D:\\A.txt");
long time = f1.lastModified();
System.out.printlin(new Date(time));    //Mon Aug 28 16:10:59 CST 2023

File类的创建和删除方法

方法名称	说明
public boolean vreateNewFile()	创建一个新的空的文件
public boolean mkdir()	只能创建一级文件夹
public boolean mkdirs()	可以创建多级文件夹

方法名称	说明
public boolean delete()	删除由此抽象路径名表示的文件或空文件夹，只能删除空的文件夹，且不走回收站

方法名称

说明

public boolean delete()

删除由此抽象路径名表示的文件或空文件夹，

只能删除空的文件夹，且不走回收站

public static void main(String[] args){
    File f1 = new File("src\\com\\itheima\\B.txt");
    System.out.printlin(f1.createNewFile());

    File f2 = new File("src\\com\\itheima\\aaa\\bbb\\ccc");
    System.out.printlin(f2.mkdirs());

    //创建的是名为C.txt的文件夹
    File f3 = new File("src\\com\\itheima\\C.txt")
    System.out.printlin(f3.mkdirs());
}

File类的遍历方法

方法名称	说明
public File[] listFiles()	获取当前目录下所以得“一级文件对象” 返回File数组

方法名称

说明

public File[] listFiles()

获取当前目录下所以得“一级文件对象”

返回File数组

当调用者File表示的路径不存在时，返回null
当调用者File表示的路径是文件时，返回null
当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
当调用者File表示的路径是需要权限才能访问的文件夹时，返回null（比如C盘、D盘）

public static void main(String[] args){
    File f = new File("D:\\test");

    File[] files = f.listFiles();

    for(File file : files){
        System.out.printlin(file);
    }
}

//对接受到的文件夹路径进行遍历，找出所有的.java文件
public static void main(String[] args){
    File dir = FileTest1.getDir();
    printJavaFile(dir);
}

public static void printJavaFile(File dir){
    //1.获取当前路径下所有的文件和文件夹对象
    File[] files = dir.listFiles();

    //2.对数组遍历，获取每一个文件或文件夹对象
    for(File file : files){
        //3.判断是否是.java文件
        if(file.isFile()){
            if(file.getName().endsWith(".java")){
                System.out.printlin(file);
            }
        }else{
            //4.代码执行到这里，说明是文件夹
            //思路：调用方法，进入这个文件夹继续找.java文件
            if(file.listFiles() != null){
                printJavaFile(file);
            }
        }
    }
}

//需求：键盘录入一个文件夹路径，统计文件夹的大小
public static void main(String[] args){
    File dir = FileTest1.getDir();
    System.out.printlin(getLength());
}

public static long getLength(File dir){
    long sum = 0;
    File[] files = dir.listFiles();
    for(File file : files){
        if(file.ifFile()){
            sum += file.length();
        }else{
            if(file.listFiles() != null){
                sum += getLength(file);
            }
        }
    }
    return sum;
}

//需求：键盘录入一个文件夹路径，统计文件夹中每种文件的个数并打印（考虑子文件夹）
    //打印格式如下：
        //txt:3个
        //doc:4个
        //jpg:6个
static HashMap<String, Integer> hm = new HashMap<>();
static int count = 0;    //统计没有后缀名的文件

public static void main(String[] args){
    File dir = FileTest1.getDir();
    getCount(dir);
    hm.forEach(new BiConsumer<String, Integer>(){
        @Override
        public void accept(String key, Integer value){
            System.out.printlin(key + ":" + value + "个");
        }
    });
    System.out.printlin("没有后缀名文件的个数为:" + count);
}

public static void getCount(File dir){
    File[] files = dir.listFiles();
    for(File file : files){

        if(file.isFile()){
            //是文件，统计个数
            //1.获取文件名
            String[] sArr = fileName.split("\\.");
            String[] type = sArr[sArr.length - 1];

            if(fileName.contains(".")){
                //2.获取后缀名
                if(!hm.containsKey(type)){
                    hm.put(type, 1);
                }else{
                    hm.put(type, hm.get(type) + 1);
                }
            }else{
                //没有后缀名，单独统计
                count++;
            }
        }else{
            //是文件夹，递归调用
            if(file.listFiles() != null){
                getCount(file);
            }
        }
    }
}

IO流-字节流

介绍

I：input 输入（读取）
O：output 输出（写出）
数据传输场景
1.读写配置文件、日志文件
2.客户端与服务端的通讯
3.文件上传下载
……

IO流体系结构

数据传输场景
1.读写配置文件、日志文件
2.客户端与服务端的通讯
3.文件上传下载
……

FileOutputStream字节输出流

构造方法	说明
FileOutputStream(String name)	输出流关联文件，文件路径以字符串形式给出
FileOutputStream(String name, boolean append)	第二个参数是追加写入的开关
FileOutputStream(File file）	输出流关联文件，文件路径以File对象形式给出
FileOutputStream(File file, boolean append)	第二个参数是追加写入的开关

成员方法	说明
void write(int i)	写出一个字节
void write(byte[] bys)	写出一个字节数组
void write(byte[] b, int off, int len)	写出字节数组的一部分

细节：输出流关联文件

文件如果不存在：会自动创建出来
文件如果存在：会清空现有的内容，然后再进行写入操作

public static void main(String[] args) throws IOException{
    //创建字节输出流对象，关联文件
    FileOutputStream fos = new FileOutputStream("D:\\A.tet");

    byte[] bys = {97, 98, 99};

    //写出数据
    fos.write(97);
    fos.write(98);
    fos.write(99);
    fos.write(bys);
    fos.write("你好你好".getBytes())；
}

关流

流对象使用完毕后，记得调用close方法关闭，不然会占用资源

IO流的异常处理方式

//JDK7版本之前
public static void main(String[] args){
    FileOutputStream fos = null;

    try{
        fos = new FileOutputStream("D:\\B.txt");
        fos.write("abc".getBytes());
    }catch(IOException e){
        e.printStackTrace();
    }finally{
        if(fos != null){
            fos.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

//JDK7版本开始
public static void main(String[] args){
    try(FileOutputStream fos = new FileOutputStream("D:\\B.txt");
        fos.write("abc".getBytes());
    }catch(IOException e){
        e.printStackTrace();
    }
}

标准的关流代码

JDK7版本之后

格式：

try(需要调用clos方法的对象){
    逻辑代码...
}catch(异常类名 对象名){
    异常的处理方式
}

注意事项：
try()中的对象，需要实现过AutoCloseable接口

FileInputStream字节输入流

构造方法	说明
FileInputStream(String name)	输入流关联文件，文件路径以字符串形式给出
FileInputStream(File file)	输入流关联文件，文件路径以File对象形式给出

成员方法	说明
int read()	读取一个字节并返回，如果到达文件结尾则返回
int read(byet[] b)	将读取到字节，放到传入的数组，返回读取到的有效字节个数如果到达文件结尾则返回-1

成员方法

说明

int read()

读取一个字节并返回，如果到达文件结尾则返回

int read(byet[] b)

将读取到字节，放到传入的数组，返回读取到的有效字节个数

如果到达文件结尾则返回-1

注意：关联的文件不存在会输出FileNoFoundException异常，文件夹的话会拒绝访问

//字节流读取数据
//public int read()：读取单个字节
public static void main(String[] args) throws IOException{

    FileInputStream fis = new FileInputStream("D:\\A.txt");

    int i;
    while(i = fis.read() != -1){
        System.out.printlin((char)i);
    }

    fis.close();

}

//字节流读取数据
//public int read(byte[] bys)：读取一个字节数组
//将读取到的字节，存入数组，返回读取到的有效字节个数
public static void main(String[] args){

    //准备菜篮子，用于装（字节）
    byte[] bys = new byte[2];

    int len
    while((len = fis.read(bys)) != -1){
        String s = new String(bys, 0, len);
        System.out.printlin(s);
    }

    fis.close();

}

构造方法	说明
public String(byet[] bytes, int offset, int length)	将字节数组转换为字符串参数1：字节数组参数2：起始索引参数3：转换的个数

构造方法

说明

public String(byet[] bytes, int offset, int length)

将字节数组转换为字符串

参数1：字节数组

参数2：起始索引

参数3：转换的个数

字节缓冲流

介绍字节缓冲流在源代码中内置了字节数组，可以提高读写效率

构造方法	说明
BufferedInputStream(InputStream in) --用new FileInputStream(文件路径);实现	对传入的字节输入流进行包装
BufferedOutputStream(OutputStream out) --用new OutputStream(文件路径);实现	对传入的字节输出流进行包装

构造方法

说明

BufferedInputStream(InputStream in)

--用new FileInputStream(文件路径);实现

对传入的字节输入流进行包装

BufferedOutputStream(OutputStream out)

--用new OutputStream(文件路径);实现

对传入的字节输出流进行包装

注意：

InputStream和OutputStream是抽象类，需要用new FileInputStream（文件路径）；和new FileOutputStream（文件路径）；来实现
缓冲流不具备读写功能，它们只是对普通的流对象进行包装，真正和文件建立关联的，还是普通的流对象

public static void main(String[] args) throws IOException{
    //1.创建字节缓冲输入流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\A.txt"));
    //2.创建字节缓冲输出流
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\A.txt"));

    //3.读写操作
    int i;
    while((i = bis.read()) != -1){
        bos.write(i);
    }

    //4.关流
    bis.close();
    bos.close();

}

图片*11

字节流四种方式总结

FileReader字符输入流

作用：用于读取纯文本我呢就，解决中文乱码问题

构造方法	说明
FileReader(String fileName)	字符输入流关联我呢就，路径以字符串形式给出
FileReader(File file)	字符输入流关联文件，路径以File对象形式给出

成员方法	说明
public int read()	读取单个字符
public int read(char[] cbuf)	读取一个字符数组，返回读取到的有效字符个数

//读取单个字符
public static void main(String[] args) throws IOException{
    FileReader fr = new FileReader("D:\\A.txt");

    int i;
    while(i = fr.read() != -1){
        System.out.printlin((char)i);
    }

    fr.close();
}

//读取字符数组
public static void main(String[] args) throws IOException{
    FileReader fr = new FileReader("D:\\A.txt");

    char[] chs = new char[1024];

    int len;
    while((len = fr.read(chs)) != -1){
        String s = new String(chs, 0, len);
        System.out.printlin(s);
    }

        fr.close();
}

字符集

字符集：是指多个字符的集合

GBK字符集：我国，windows默认使用GBK
Unicode字符集：国际标准字符集

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

GBK：英文字符占用1个字节，中文字符占用2个字节
Unicode：UTF-8：中文字符占3个字节，ASCII占1个字节，平台默认字符编码

编码和解码

编码：字符转字节

成员方法	说明
public byte[] getBytes()	使用平台默认字符编码方式，对字符串编码
public byte[] getBytes(String charsetName)	使用使用字符编码方式（不区分大小写），对字符串编码

解码：字节转字符

构造方法	说明
public String(byte[] bytes)	使用平台默认字符编码方式，对字符串解码
public String(byte[] bytes, String charseName)	使用使用字符编码方式（不区分大小写），对字符串解码

public static void main(String[] args) throws IOException{
    String s = "你好你好";
    byte[] bytes = s.getBytes();
    System.out.printlin(Arrays.toString(bytes));

    byte[] gbks = s.getBytes("gbk");
    System.out.printlin(Arrays.toString(gbks));

    byts[] utf8Bytes = {-12, -67, -97, -27, -91, -67, 44, -28, -67, -96, -27, -91, -67};
    byte[] gbkBytes = {-60, -29, -70, -61, 44, -60, -29, -70, -61};

    String s1 = new String(gbkBytes,"GBK");
    System.out.printlin(s1);
}

重点记忆：中文字符以负数开头

FileWriter字符输出流

构造方法	说明
FileWriter(String fileName)	字符输出流关联文件，路径以字符串形式给出
FileWriter(String file Name, boolean append)	参数2：追加写入的开关
FileWriter(File file)	字符输出流关联我呢就，路径以File对象形式给出
FileWriter(File file, boolean append)	参数2：追加写入的开关

成员方法	说明
public void write(int c)	写出单个字符
public void write(char[] cbuf)	写出一个字符数组
public write(char[] cbud, int off, int len)	写出字符数组的一部分
public void write(String str)	写出字符串
public void write(String str, int off, int len)	写出字符串的一部分

public static void main(String[] args) throws IOException{

    FileWriter fw = new FileWriter("D:\\C.txt");

    char[] chs = {'a', 'b', 'c'};

    fw.write('a');
    fw.write(chs);
    fw.write(chs, 0, 2);
    fw.write("你好你好~");
    fw.write("哈哈哈哈哈", 0, 2);
    //aabcab你好你好~哈哈

    fw.close();
}

注意事项

字符输出流写出数据，需要调用flus或close方法，数据才会写出
flush()：刷出数据，刷出后可以继续写出

close()：关闭流释放资源，顺便刷出数据，关闭后不可以继续写出

public static void main(String[] args) throws IOException{
    FileWriter fw = new FileWriter("D:\\D.txt");
    fw.write("人活一世，草木一秋");
    fw.write("\r\n");
    fw.write("哈哈哈哈哈");
    fw.flush();
    fw.write("\r\n");
    fw.write("嘻嘻嘻");
    fw.close();
}

字节流和字符流总结

字符流使用场景：读写纯文本文件
字节流使用场景：不是纯文本文件都用字节流

图片*6

IO流-功能流

字符缓冲流

字节缓冲流在源代码中内置了字符数组，可以提高读写效率
BufferedReader
BufferedWriter

注意：缓冲流并不具备读写功能，只是对普通流对象进行包装，真正和文件建立关联的，还是普通流对象

构造方法	说明
BufferedReader(Reader reader) --用new FileReader(文件路径);	对传入的字符输入流进行包装
BufferedWriter(Writer writer) --用new FileWriter(文件路径);	对传入的字符输出流进行包装

构造方法

说明

BufferedReader(Reader reader)

--用new FileReader(文件路径);

对传入的字符输入流进行包装

BufferedWriter(Writer writer)

--用new FileWriter(文件路径);

对传入的字符输出流进行包装

字符缓冲流中特有方法

BufferedReader

成员方法	说明
public String readLine()	读取一行字符串，读取到末尾返回null

BufferedWriter

成员方法	说明
public void newLine()	写出换行符（具有跨平台性）

public static void main(String[] args) throws IOExceptiom{
    BufferedReader br = new BufferedReader(new FileReader("day\\A.txt");
    BufferedWriter bw = new BufferedWriter(new FileWriter("day\\C.txt");

    String line;
    while((line = br.readLine()) != null){
        bw.write(line);
        bw.newLine();
    }

    br.close();
    bw.close();
}

转换流

按照指定的字符编码读写操作

FileReader按照UTF-8格式读取
FileWriter按照UTF-8格式写出

构造方法	说明
InputStreamReader(InputStream in, String charsetName)	按照指定的字符编码读取
OutputStreamWriter(OutputStream out, String charsetName)	按照指定的字符编码写出

public static void main(String[] args) throws IOException{
    InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\Test.txt");

    int i;
    while(i = isr.read() != -1){
        System.out.printlin((char)i);
    }

    isr.close();
}

public static void main(String[] args) throws IOException{
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\Test.txt");

    osw.write("哈哈");

    osw.close();
}

将字节流转换为字符流进行操作

序列化流

可以在流中，以字节的形式直接读写对象
被transient修饰的变量不会序列化
ObjectInputStream
构造方法说明
public ObjectInputStream(InputStream in) 对象输入流关联文件，关联方式使用字节输入流

成员方法说明
Object readObject() 流中读取对象（反序列化）（从文件中将对象读取到程序）
ObjectOutputStream

构造方法	说明
public ObjectInputStream(InputStream in)	对象输入流关联文件，关联方式使用字节输入流

成员方法	说明
Object readObject()	流中读取对象（反序列化）（从文件中将对象读取到程序）

构造方法	说明
public ObjectOutputStream(OutputStream out)	对象输出流关联文件，关联方式使用字节输出流

成员方法	说明
void writeObject(Object obj)	在流中将对象写出到文件（序列化）

打印流

优势：使用方便
可以实现方便、高效的打印数据到文件中，并且可以指定字符编码
可以实现打印什么数据就是什么数据，如打印整数97写出去就是97，write(97) -> a，printlin(97) -> 97

public static void main(String[] args){
    PrintStream ps = System.out;
    ps.printlin("你好");
//等价于：System.out.printlin("你好");
}

PrintStream

创建对象关联文件

构造器	说明
public PrintStream(OutputStream os)	打印流直接通向字节输出流管道
public PrintStream(File f)	打印流直接通向文件对象
public PrintStream(File f, String csn)	打印流直接通向文件对象，指定字符编码
public PrintStream(String filepath)	打印流直接通向文件路径
public PrintStream(String filepath, String csn)	打印流直接通向文件路径，指定字符编码

方法	说明
public void print\println(Xxx, xx)	打印任意类型的数据出去

public static void main(String[] args) throws Exception{
    PrintStream ps = new PrintStream("D:\\Test.txt","gbk");
    ps.printlin("大家好");
    ps.close();
}

public static void main(String[] args) throws Exception{
    //追加
    PrintStream ps = new PrintStream(new FileOutputStream("D:\\Test.txt",true));
    ps.printlin("你好");
    ps.close();
}

写出方法

写出方法	说明
write()	写出一个字节，不建议使用，无法原样写入
print()	原样写入数据，无换行
printlin()	原样写入数据，带有换行

PrintWriter字符打印流

要用autoflush才能输出

构造器	说明
public PrintWriter(OutputStream os)	打印流直接通向字节输出流管道
public PrintWriter(Writer w)	打印流直接通向字符输出流管道
public PrintWriter(File f)	打印流直接通向文件对象
public PrintWriter(File f， String csn)	打印流直接通向文件对象，指定字符编码
public PrintWriter(String filepath)	打印流直接通向文件路径
public PrintWriter(String filepath, String csn)	打印流直接通向文件路径，指定字符编码

方法	说明
public void print\println(Xxx, xx)	打印任意类型的数据出去

public static void main(String[] args) throws IOException{
    //true 表 autoflush的值
    PrintWriter pw = new PrintWriter(new FileWriter("day\\F.txt"), true);
    pw.printlin("你好");
}

Properties集合

其实就是一个Map集合
内部存在两个方法，可以很方便的将集合中的键值对写入文件，也可以方便的从文件中读取，常用于加载配置文件
Properties作为集合的使用

Properties中和流有关的方法

构造器	描述
Properties()	创建一个没有默认值的空属性列表

方法	说明
Object setProperty(String key, String value)	添加（修改）一个键值对，类似Map集合的put方法
String getProperty(String key)	根据键获取值，类似Map集合的get方法
Set<String> stringPropertyNames()	获取集合中所有的键，类似Map集合的keySet方法

Properties和IO有关的方法

方法	说明
void load(InputStream inStream)	从流中加载数据到集合（字节流）
void load(Reader reader）	从流中加载数据到集合（字符流）
void store(OutputStrem out, String comments)	将集合的键值对写出到文件（字节流）
void store(Writer writer, String comments)	将集合的键值对写出到文件（字符流）

//Properties和IO有关的方法
//void load(InputStream inStream)：从输入字节流读取属性列表（键和元素对）
//void load(Reader reader)：从输入字符流读取属性列表（键和元素对）
//void store(OutputStream out, String comments)：将集合的键值对写出到文件（字节流）
//void store(Writer writer, String comments)：将集合的键值对写出到文件（字符流）
public static void main(String[] args) throws IOException{
    Properties prop = new Properties();
    prop.setProperty("张三","北京");

    FileOutputStream fos = new FileOutputStream("day\\config.properties");//.properties后缀一定要写

    prop.store(fos, "hys");//"hys"为注释信息

    fos.close();
}

public static void main(String[] args) throws IOException{
    Properties prop = new Properties();
    prop.setProperty("张三","北京");

    FileWriter fos = new FileWriter("day\\config.properties");//.properties后缀一定要写

    prop.store(fos, "hys");//"hys"为注释信息

    fos.close();
}

public static void main(String[] args) throws IOException{
    Properties prop = new Properties();
    prop.setProperty("Username","admin");
    prop.setProperty("password","1234");

    FileWriter fos = new FileWriter("day\\config.properties");

    prop.store(fos, null);    //null表没有注释信息

    fos.close();
}

public static void mian(String[] args) throws IOException{

    Properties prop = new Properties();

    FileInputStream fis = new FileInputStream("day\\config.properties");

    prop.load(fis);

    fis.close();

    System.out.println(prop);

}

注明：本文中截图均来自bilibili中黑马程序员up主