Java笔记 - 黑马程序员_06(Stream，字节流，字符流，对象流（序列化流），属性集(Properties)）

谦逊蓄意，只为飞的更高

已于 2022-07-14 20:52:55 修改

阅读量1.5k

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2022-05-08 22:09:13 首次发布

本文链接：https://blog.csdn.net/weixin_56327704/article/details/124640221

版权

本文详细介绍了Java中的IO流，包括Stream的基本概念、字节流（字节输入流和输出流）的使用，以及字符流（字符输入流和输出流）的操作。内容涵盖字节流的读写数据、缓冲流的使用，字符流的编码解码问题，以及对象流（序列化流）和属性集(Properties)的应用。通过实例展示了如何使用各种流进行文件复制和数据处理。

摘要由CSDN通过智能技术生成

Stream

Stream流的三类方法：

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

创建Stream流的方式：

方式1：根据集合获取流
- Collection根接口中提供了stream()方法可以获取流。
- 单列集合：直接调用stream0方法即可
- 双列集合：先获取键和值的单列集合，再通过集合获取键和值各自的Stream流
方式2：根据of方法获取流
- Stream类提供了静态的of()方法，可以创建一个流对象
- Stream.of(T …values)

Stream流的常用方法:

成员方法	方法作用	返回值类型	方法种类
filter	过滤	Stream	中间方法
limit	取用前几个	Stream	中间方法
skip	跳过前几个	Stream	中间方法
map	映射	Stream	中间方法
count	统计个数	long	终结方法
forEach	逐一处理	void	终结方法
静态方法	方法作用	返回值类型	方法种类
static concat(流1，流2)	组合两个流	Stream	静态方法

Stream流的使用注意：

一个Stream流对象只能操作一次
调用中间方法会返回新流，以便下次操作使用
终结方法如果没调用，中间方法也不会执行

案例：

已知两个集合数据：

第一个集合队伍数据：令狐冲，风清扬，任我行，东方不败，岳不群
第二个集合队伍数据：马云，李彦宏，刘强东，马化腾，马保国

要求：

第一个队伍只要名字为3个字的姓名
第一个队伍筛选之后只要前3人
第二个队伍只要姓马的姓名
第二个队伍不要前2人
.将两个队伍合并到一个队伍
根据姓名创建Person对象，存储到一个新集合

package com.demo_4Stream流;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo_07_案例 {
   
    public static void main(String[] args) {
   
        Stream<String> s1 = Stream.of("令狐冲", "风清扬", "任我行", "东方不败", "岳不群");
        Stream<String> s2 = Stream.of("马云", "李彦宏", "刘强东", "马化腾", "马保国" );

        //第一个队伍只要名字为3个字的姓名。 filter()
        Stream<String> s3 = s1.filter(a -> a.length() == 3);
        //第一个队伍筛选之后只要前3人。limit(3)
        Stream<String> s8 = s3.limit(3);

        //第二个队伍只要姓马的姓名
        Stream<String> s4 = s2.filter(s -> s.startsWith("马"));
        //第二个队伍不要前2人
        Stream<String> s7 = s4.skip(2);

        //将两个队伍合并到一个队伍  concat(流1, 流2)
        Stream<String> result = Stream.concat(s7, s8);

        //根据姓名创建Person对象  把String类型转为Person   map()
        Stream<Person> s5 = result.map(new Function<String, Person>() {
   
            @Override
            public Person apply(String s) {
   
                return new Person(s);
            }
        });
        //存储到新集合
        List<Person> personList = s5.collect(Collectors.toList());

        //遍历集合
        personList.forEach(new Consumer<Person>() {
   
            @Override
            public void accept(Person person) {
   
                System.out.println(person);
            }
        });
    }
}

//创建person类，生成构造器，get，set，toString方法

1.字节流

1.1 IO流概述和分类

IO流概述：

IO:输入/输出(Input/Output)
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
IO流就是用来处理设备间数据传输问题的
常见的应用：文件复制；文件上传；文件下载

IO流分类：

按照数据的流向
输入流：读数据
输出流：写数据
按照数据类型来分

字节流
字节输入流；字节输出流
字符流
字符输入流；字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的

那么这两种流都在什么情况下使用呢？

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，
否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

1.2 字节流写数据

字节流抽象基类：

InputStream:这个抽像类是表示字节输入流的所有类的超类
OutputStream:这个抽象类是表示字节输出流的所有类的超类
子类名特点：子类名称都是以其父类名作为子类名的后缀

FileOutputStream:：文件输出流用于将数据写入File

FileOutputStream(String name):创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
调用字节输出流对象的写数据方法
释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

package demo_01;

/*
FileOutputStream:：文件输出流用于将数据写入File
        FileOutputStream(String name):创建文件输出流以指定的名称写入文件
*/

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

public class FileOutputStreamDemo {
   
    public static void main(String[] args) throws IOException {
   
        //创建字节输出流对象
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\java.txt");

        //write(int b)将指定的字节写入此输出流。。
        fos.write(97);

        //释放资源
        //close()关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

1.3 字节流写数据的3种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)	将b.length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b, int off, int len)	将Ien字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

package demo_01;
/*
FileOutputStream构造方法：
    FileOutputStream(String name):创建文件输出流以指定的名称写入文件
    FileOutputStream(File file)创建文件输出流以写入由指定的 File对象表示的文件
    FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。
*/
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
   
    public static void main(String[] args) throws IOException {
   
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\java.txt",true);
        //new File(name) 底层代码
//        FileOutputStream fos = new FileOutputStream(new File("myByteStream\\java.txt"));

    //FileOutputStream(File file)创建文件输出流以写入由指定的 File对象表示的文件
/*        File file = new File("myByteStream\\java.txt");
        FileOutputStream fos2 = new FileOutputStream(file);
        */
//        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\\\java.txt"));

        //write(int b)将指定的字节写入此输出流
        fos.write(97);
        fos.write(98);

        //write(byte[] b)将 b.length字节从指定的字节数组写入此输出流。
        byte[] bys = {
   97,98,99};
        //byte[] getBytes():返回字符串对应的字节数组
        fos.write(bys);

        //write(byte[] b, int off, int len)从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流
        byte[] bys1 = {
   97,98,99};
        int len = bys1.length;
        fos.write(bys1,0,len);
        
         //释放资源
        fos.close();
    }
}

byte[]  getBytes():使用平台的默认字符集将此String编码为字节序列（返回字符串对应的字节数组）		//String中的方法

1.4 字节流写数据的两个小问题

字节流写数据如何实现换行呢？

写完数据后，加换行符

windows: \r\n
linux: \n
mac: \r

字节流写数据如何实现追加写入呢？

public FileOutputStream(String name, boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的未尾而不是开头

package demo_01;

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

public class FileOutputStreamDemo03 {
   
    public static void main(String[] args) throws IOException {
   
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\\java.txt");
        //创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的未尾而不是开头
        FileOutputStream fos = new FileOutputStream("myByteStream\\java.txt", true);

        //写入数据
        for (int i = 0; i < 10; i++) {
   
            //byte[]  getBytes():使用平台的默认字符集将此String编码为字节序列（返回字符串对应的字节数组）
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();
    }
}

1.5 字节流写数据加异常处理

finally:在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出

//格式
try{
   
    //可能出现的异常代码
}catch (异常类名 变量名){
   
    //异常处理代码
}finally {
   
    //执行所有清楚操作
}

package demo_01;

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

public class FileOutputStreamDemo04 {
   
    public static void main(String[] args) {
   
        //加入finally来实现资源释放
        FileOutputStream fos = null;
        try {
   
            fos = new FileOutputStream("myByteStream\\java.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
   
            e.printStackTrace();
        }finally {
   
            if (fos != null){
   
                try {
   
                    fos.close();
                } catch (IOException e) {
   
                    e.printStackTrace();
                }
            }
        }
    }
}

1.6 字节流读数据（一次读一个字节数据）

需求：把文件java.txt中的内容读取出来在控制台输出

FilelnputStream:从文件系统中的文件获取输入字节

FilelnputStream(String name):通过打开与实际文件的连接来创建一个FilelnputStream,该文件由文件系统中的路径名name命名

使用字节输入流读数据的步骤：
①创建字节输入流对象
②调用字节输入流对象的读数据方法
③释放资源

package demo_02;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo01 {
   
    public static void main(String[] args) throws IOException {
   
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\java.txt");

        //int read():从该输入流读取一个字节数据
        //读取数据
        /*int read = fis.read();
        System.out.println(read);
        System.out.println((char)read);*/

        //优化
        int by;
        while ((by = fis.read()) != -1) {
   
            System.out.print((char) by);
        }

        //释放资源
        fis.close();
    }
}

案例：复制文本文件

需求：把“D:\\.File\\java.txt”复制到模块目录下的“java.txt”

分析：

①复制文本文件，其实就把文本文件的内容从一个文件中读取出来（数据源），然后写入到另一个文件中（目的地）

②数据源：
D:\\.File\\java.txt—读数据—InputStream—FilelnputStream

③目的地：
myByteStream\\java.txt—写数据—OutputStream–FileOutputStream

思路：

①根据数据源创建字节输入流对象
②根据目的地创建字节输出流对象
③读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
④释放资源

package demo_02;

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

/*
        根据数据源创建字节输入流对象
        根据目的地创建字节输出流对象
        读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        释放资源
*/
public class CopyTxtDemo {
   
    public static void main(String[] args) throws IOException {
   
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\File\\java.txt");

        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\\java.txt");

        //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while ((by=fis.read())!=-1){
   
            fos.write(by);
        }

        //释放资源
        fis.close();
        fos.close();
    }
}