JAVA（IO）流知识点分享

前沿：

一，什么是流对象？

二， Java中的流对象

三，流的分类

四， 字节流与字符流的区别？

五，字节流

六，字符流

七，Stream流

跟随老狗速速上车！！！

一，什么是流对象？

<font color = greenYellow>内存与存储设备之前的传输数据的通道</font>

二， Java中的流对象

JavaIO流，是一种计算机用语。主要是用于处理数据的传输。

三，流的分类

1. 按照方向

- 输入流（Input）：将存储设备中的内容读取到内存中

- 输出流(Output)：讲内存中的内容写入到存储设备中

2. 按照单位

- 字节流(Byte)：以字节为单位，可以读取所有的数据

- 字符流(Char)：以字符为单位，只能读取文本数据

字节（Byte）计量单位，表示数据量的多少，是计算机用于计量数据的一种计量单位，通常情况下一个字等8位

字符（Character）计算机中使用的字母，数字，符号等都是字符

3. 按照功能

过滤流：在节点流的基础之上进行的增强功能

节点流：具有实际传输数据的读写功能,直接跟输入输出源交互

四， 字节流与字符流的区别？

<font color = redyellow>字节流与字符流本质上的区别就是：

1.两者组成不同

- 字节流的组成：字节流是由字节组成的

- 字符流的组成：字符流是由字符组成的

2.两者处理方式不同

- 字节流的处理：主要处理二进制数据，按照字节来处理

- 字符流的处理：按照编码集，字符集来进行处理

字节流是原生的操作，字符流是经过处理后的操作。</font>

Java中的字符是由两个字节组成，1个字符=2个字节

Java字节流采用ASCll编码的

字符流采用的是UTF编码，支持中文

为什么要有字符流而不直接使用字节流？

当字节流处理多个字节表示的数据是有可能会出现乱码问题。比如汉字，因为有一位字节没有读到造成乱码，字符流完美的解决了这一问题。字节流加上编码表就相当于是字符流。编码表就是可以确定这个汉字占用了多少个字节，之后字节流就可以根据位数准确的读汉字。

五，字节流

字节流最基础的两个类<font color=red>InputStream</font>和<font color=red>OutputStream</font>，根据这两类派生出来的方法，read()和write()两个基本方法，用于读写单个字节或者是字节数组。

InputStream类是一个抽象类，是所有字节输入流的父类

OuputStream类是一个抽象类，是所有字节输出流的父类

InputStream常见的子类：

FileInputStream:从文件读取信息

ByteArrayInputStream:字节数组输入流

ObjectInputStream:对象序列化使用

FilterInputStream:过滤输入流，为基础的输入流提供一些额外的操作

FilterInputStream的子类

DataIntputStream:从流中读取基本数据类型

OutPutStream常见的子类：

FileOutputStream:文件输出流对文件进行操作

ByteArrayOutputStream:字节数组输出流

ObjectOutputStream:对象序列化使用

FilterOutputStream:过滤输出流，为基础的输出流提供一些额外的操作

FilterOutputStream子类

DataOutputStream:可以向文件中写入基本类型数据

PrintStream:用于产生格式化输出

java
package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

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

public class FileOutputStreamDemo {
    public static void main(String[] args) {
        //根据文件来创建对象
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");
            //往文件中写入数据
            fileOutputStream.write((int) 'A');
            fileOutputStream.write((int) 'N');
            fileOutputStream.write((int) 'D');
            fileOutputStream.write((int) 'Y');

            String str = "FUNG";
            fileOutputStream.write(str.getBytes());
            fileOutputStream.close();


            //根据文件来创建对象
            FileInputStream fileInputStream = new FileInputStream("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");

            int by;
            while ((by = fileInputStream.read()) != -1) {
                System.out.print((char)by);
            }
            fileInputStream.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 

从一个字符串中读取数组

```java
package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建一个字节输出流对象
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        //写入数据
        String str = "AndyFung";
        byteArrayOutputStream.write(str.getBytes());
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        //读取数据
        int i;
        while ((i = byteArrayInputStream.read()) != -1) {
            System.out.print((char)i);
        }
    }
}

JAVA 
package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

import java.io.*;

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException ,ClassNotFoundException{
        Student student = new Student("安迪");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("teacher.txt"));
        //序列化对象，把对象写入到teacher.txt中去
        objectOutputStream.writeObject("zhangsan");
        objectOutputStream.writeObject(student);
        //关流
        objectOutputStream.close();


               //teacher.txt读取数据
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"));
        //读取对象内容
        //Object o = ois.readObject();

        String str = ois.readObject().toString();
        Student stu =(Student) ois.readObject();
        System.out.println(str);
        System.out.print(stu);
    }
}


class Student implements Serializable {
    private String name;

    Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

java
package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

import java.io.*;

public class FilterStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");
        FileInputStream fileInputStream = new FileInputStream("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");

        DataOutputStream dataOutputStream = new DataOutputStream(fos);
        dataOutputStream.writeByte(12);

        dataOutputStream.writeShort(11);
        dataOutputStream.writeInt(123);
        dataOutputStream.writeLong(123);

        dataOutputStream.writeDouble(12.12);
        dataOutputStream.writeBoolean(true);

        dataOutputStream.writeChar('孬');

        dataOutputStream.writeFloat(90);

        dataOutputStream.close();

        DataInputStream dataInputStream = new DataInputStream(fileInputStream);
        System.out.println( dataInputStream.readByte());
        System.out.println( dataInputStream.readShort());
        System.out.println( dataInputStream.readInt());
        System.out.println( dataInputStream.readLong());
        System.out.println( dataInputStream.readDouble());
        System.out.println( dataInputStream.readBoolean());
        System.out.println( dataInputStream.readChar());
        System.out.println( dataInputStream.readFloat());

        dataInputStream.close();

        PrintStream printStream = new PrintStream("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");

        //写入字节数组
        printStream.write("helloWorld".getBytes());

        //写入换行
        printStream.println();

        //格式化写入数据
        printStream.format("文件名称:%s", "music.txt");

        //换行
        printStream.println();

        printStream.append("andyFung");
        printStream.close();
    }
}

六，字符流

字符流：在字节流的的基础上，加上了编码集，形成的数据流对象。

字符流含义：在操作字节流操作字符时会出现中文乱码的情况，所以由字节流引出的字符流。

1. Reader类和Weiter类

字符流最基础的两个类Reader和Writer，根据这个两个类派生出来的类都有read()和write()两个基本方法

实际应用

处理文本数据时候使用字符流多一些

其他格式文件比如图片、音频、视频等，使用字节

Reader类常见的子类

FileReader:文件的输入流

BufferedReader:带有缓冲区的字符输入流

Writer类常见的子类

FileWriter: 文件的输出流

BufferedWriter: 带缓冲区的字符输出流

java

package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileChar {

    public static void main(String[] args) throws IOException {
        //创建一个FileWriter
        FileWriter fileWriter = new FileWriter("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");
        //向文件里面写入数据信息
        fileWriter.write("天青色等烟雨，而我在等你。");
        fileWriter.append("炊烟袅袅升起，隔江千万里。");
        //把文件写入到缓冲区中,把流数据刷新到文件中，
        fileWriter.flush();
        fileWriter.append("如传世的青花瓷自顾自美丽 ，你眼带笑意。");
        //关闭流
        fileWriter.close();


        FileReader fileReader = new FileReader("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music");

        int i;
//        while ((i= fileReader.read()) != -1) {
//            System.out.print((char)i);
//        }

        //用char数组来读取数据
        char[] chars = new char[2];
        while ((i = fileReader.read(chars)) != -1) {
            System.out.print(chars);
        }
        fileReader.close();

        System.out.println();
        //使用java新特性文件流对象来读取数据
        Stream<String> lines = Files.lines(Paths.get("I:\\初始项目框架\\css-admin\\src\\main\\java\\com\\zhongzhichuang\\cssadmin\\JavaBasic\\javaIo\\music"), Charset.defaultCharset());
        lines.forEach(System.out::print);
    }
}

七，Stream流

Java8新特性，更加方便处理数据，Java把很多函数方法封装好，可以直接使用。

stream流通常结合lambda表达式一起使用。

java

package com.zhongzhichuang.cssadmin.JavaBasic.javaIo;

import com.zhongzhichuang.cssadmin.entity.Student;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        Student lb = new Student(1, "刘备", 18, "郑州市中原区", "川蜀大学");
        Student xb = new Student(4, "小白", 45, "郑州市金水区", "郑州大学");
        Student xh = new Student(3, "小红", 67, "郑州市郑东新区", "清华大学");
        Student xz = new Student(5, "小紫", 14, "郑州市管城区", "河南大学");
        Student xl = new Student(6, "小绿", 18, "郑州市二七区", "北京大学");
        Student cc = new Student(2, "曹操", 18, "郑州市高新区", "中原大学");


        List<Student> studentList = new ArrayList<>();

        studentList.add(lb);
        studentList.add(cc);
        studentList.add(xh);
        studentList.add(xb);
        studentList.add(xz);
        studentList.add(xl);
        for (Student student : studentList) {
            System.out.println(student);
        }

        //Filter
        List<Student> collect = studentList.stream().filter(student -> student.getAge() == 18).collect(Collectors.toList());
        System.out.println(collect);


        Set<Student> names = studentList.stream().filter(student -> student.getName().startsWith("小")).collect(Collectors.toSet());
        System.out.println(names);

        System.out.println("-----------------------------------");
        //在集合中取出前三位学生信息以及后两位学生信息

        studentList.stream().limit(3).forEach(System.out::println);
        studentList.stream().skip(4).forEach(System.out::println);

        System.out.println("-------------------------------");
        //对集合进行排序
        List<Student> collect1 = studentList.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
        collect1.forEach(System.out::print);
    }