java流总结

Posted 2021-05-21 若曦`

• 1. java流的分类
• 2. File 类
• 3. IO流（字节流）
• • (1) InputStream
  • (2) OutputStream
• 4. 字符流
• • (1) Reader及子类FileReader
  • (2) Write及子类FileWrite
• 5. 处理流
• 6. 缓冲流
• • 缓冲流的使用

1. java流的分类

按方向分：输入流+输出流（IO流）

按单位分：字节流+字符流
（字节流是指每次处理数据以字节为单位，字符流是以字符为单位）

按功能分：节点流（字节流） + 处理流（对节点流进行处理，生成其他类型的流）

2. File 类

java.io.File，使用该类的构造函数就可以创建文件对象，将硬盘中的一个具体的文件以 Java 对象的形式来表示

方法	描述
public File(String pathname)	根据路径创建对象
public String getName()	获取文件名
public String getParent()	获取文件所在的目录
public File getParentFile()	获取文件所在目录对应的File对象
public String getPath()	获取文件路径
public boolean exists()	判断文件是否存在
public boolean isDirectory()	判断对象是否为目录
public boolean isFile()	判断对象是否为文件
public long length()	获取文件的大小
public boolean createNewFile()	根据当前对象创建新文件
public boolean delete()	删除对象
public boolean mkdir()	根据当前对象创建目录
public boolean renameTo(File file)	为已存在的对象重命名

3. IO流（字节流）

IO流有InputStream、OutputStream

InputStream和OutStream可以看作一根管道，用于将一个区域内的数据转移到java程序中或转移出去

它们俩都是以字节流的形式传输

(1) InputStream

① InputStream常用方法

1 byte = 8 位二进制数 01010101

方法	描述
int read()	以字节为单位读取数据
int read(byte b[])	将数据存入 byte 类型的数组中，返回数组中有效数据的长度
int read(byte b[],int off,int len)	将数据存入 byte 数组的指定区间内，返回数组长度
byte[] readAllBytes()	将所有数据存入 byte 数组并返回
int available()	返回当前数据流未读取的数据个数
void close()	关闭数据流

② InputStream常用读取文件的方式

方式一

public class TestStream {
    public static void main(String[] args) {
        File file = new File("text.txt");
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(file); //创建一个fileInputStream
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        long length = file.length(); // 获取文件的数据长度
        for (int i = 0; i < length; i++) {
            try {
                System.out.println(inputStream.read()); //读取一个字节
                inputStream.close();
            } catch (IOException e) {
                inputStream.close();
                e.printStackTrace();
            }
        }
    }
}

方式二

public class TestStream {
    public static void main(String[] args) {
        File file = new File("text.txt");
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(file); //创建一个fileInputStream
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            byte[] bytes = inputStream.readAllBytes();  // 用byte[]数组将文件所有数据读取保存
            System.out.println(bytes);
            inputStream.close();
        } catch (IOException e) {
            inputStream.close();
            e.printStackTrace();
     }
}

(2) OutputStream

① OutputStream的常用方法

方法	描述
void write(int b)	以字节为单位输出数据
void write(byte b[])	将byte数组中的数据输出
void write(byte b[],int off,int len)	将byte数组中指定区间的数据输出
void close()	关闭数据流
void flush()	将缓冲流中的数据同步到输出流中

② OutputStream使用示例

public class TestStream {
    public static void main(String[] args) {
        File file = new File("text.txt");

        OutputStream outputStream = null;

        try {
            outputStream = new FileOutputStream(file);//创建一个fileOutputStream
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        byte[] bytes = {96,101,108,112,116}; // 保存的时候会存储ascall码对应的字符

        try {
            outputStream.write(bytes); //写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }
        outputstream.close();
    }
}

4. 字符流

字节流是单位时间内处理一个字节的数据（输入+输出）

字符流是单位时间内处理一个字符的数据（输入+输出）

中间会有一个中介完成字节到字符的转换，也就是处理流，在后面会介绍

字符流：

输入字符流 Reader
输出字符流 Writer

(1) Reader及子类FileReader

Reader抽象类实现了Readable接口，表示可以将缓冲区数据以char类型读取


FileReader是InputStreanreader的子类，也就是Reader的孙子类

InputStreamReader是处理流，在后面会详细介绍

英文字母：1 个字符 = 1 个字节

汉字：1 个字符 = 3 个字节

FileReader的使用

read()方法会打印出字符的字节，若要原文打出可以使用char转换或者read(chars[])方法

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");

        Reader reader = new FileReader(file);

        long temp = 0;
        StringBuilder str = new StringBuilder();
        while (true){ //当读完文件后，再进行读取值会为-1
            temp = reader.read();
            if(temp==-1)
                break;
            str.append((char) temp);
        }
        System.out.println(str);
        reader.close();
    }
}

(2) Write及子类FileWrite

Writer抽象类实现了Appendable接口，表示可以将 char 类型的数据读入到数据缓冲区


FileWriter是OnputStreanreader的子类，也就是Writer的孙子类

OnputStreamWriter是处理流，在后面会详细介绍

FileWriter的使用

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");

        Writer writer = new FileWriter(file);

        writer.write("hello,world"); // 向缓冲区写数据

        writer.flush(); //将缓冲区的数据清空，刷新到文件里

        writer.close();
    }
}

5. 处理流

处理流分为InputStreamReader和OutputStreamWriter两种

InputStreamReader 的功能是将字节输入流转换为字符输入流

OutputStreamWriter 的功能是将输出字节流转成输出字符流

InputStreamReader的使用

创建好之后用法和Reader一样

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");

        InputStream inputStream = new FileInputStream(file); // 基础管道 字节流

        InputStreamReader inputStreamReader = new InputStreamReader(inputStream); // 创建处理流

        long temp = 0;  
        StringBuilder str = new StringBuilder(); 
        while (true){ //当读完文件后，再进行读取值会为-1
            temp = inputStreamReader.read(); 
            if(temp==-1)
                break;
            str.append((char) temp);
        }
        System.out.println(str);

        inputStreamReader.close();
    }
}

OutputStreamReader的使用

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");
        
        OutputStream outputStream = new FileOutputStream(file);
        
        OutputStreamWriter writer = new OutputStreamWriter(outputStream);
        
        writer.write("你好啊");

        writer.flush();
        
        writer.close();
        outputStream.close();
   }
}

6. 缓冲流

无论是字节流还是字符流，使用的时候都会频繁访问硬盘，对硬盘是一种损伤，同时效率不高，如何解决？

这时就可以使用缓冲流，缓冲流自带缓冲区，可以一次性从硬盘中读取部分数据存入缓冲区，再写入内存，这样就可以有效减少对硬盘的直接访问

java流按功能分：节点流（字节流） + 处理流

节点流有例如InputStream和OutpurStream

缓冲流属于处理流，如何区分节点流和处理流？

1、节点流使用的时候可以直接对接到文件对象File

2、处理流使用的时候不可以直接对接到文件对象 File，必须对接字节流

缓冲流的使用

缓冲流一般搭配字符流使用，因为字节流是以byte为单位，不能体现出缓冲流的优势

缓冲流提供了一个新方法，就是readLine()

字符输入缓冲流的使用

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");

        //创建字符流
        Reader reader = new FileReader(file);

        //创建字符缓冲流
        BufferedReader bufferedReader = new BufferedReader(reader);

        String str = null;
        String result = "";

        while(true){
            str = bufferedReader.readLine(); //以行读取数据
            if(str==null)
                break;
            else {
                result+=str;
            }
        }

        System.out.println(result);
    }
}

字符输出缓存流的使用

public class TestStream {
    public static void main(String[] args) throws IOException {
        File file = new File("C:/Users/yume/Desktop/TestStream.txt");
        
        Writer writer = new FileWriter(file);
        
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        
        String str="hello，打工人";
        
        bufferedWriter.write(str);
        
        bufferedWriter.flush();
        
        bufferedWriter.close();
	}
}