IO流基础知识(基本字节流，字符流和缓冲流)

无缘过去@

已于 2024-02-11 23:58:15 修改

阅读量1.7k

点赞数 48

文章标签： java 开发语言

于 2024-02-11 21:30:02 首次发布

本文链接：https://blog.csdn.net/m0_74077663/article/details/136097658

版权

一.第一个IO流程序

import java.io.FileInputStream;

public class Test1 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("src/main/java/IO流补充/a.txt");
        int s1 = fileInputStream.read();
        int s2 = fileInputStream.read();
        int s3 = fileInputStream.read();
        int s4 = fileInputStream.read();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        fileInputStream.close();
    }
}

这种格式是不规范的，在开发过程中我们一般不这么写，只适用于测试。

流对象使用完，必须关闭！不然，总占用系统资源，最终会造成系统崩溃！

1. 我们读取的文件内容是已知的，因此可以使用固定次数的“int s= fis.read();”语句读取内容，但是在实际开发中通常我们根本不知道文件的内容，因此我们在读取的时候需要配合while循环使用。

2. 为了保证出现异常后流的正常关闭，通常要将流的关闭语句要放到finally语句块中，并且要判断流是不是null。

二.使用IO流的经典读取方法

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

public class Test2 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try{
            fileInputStream = new FileInputStream("src/main/java/IO流补充/a.txt");
            int temp = 0;
            StringBuilder stringBuilder = new StringBuilder();
            while((temp = fileInputStream.read()) != -1){
                System.out.println(temp);
                stringBuilder.append((char) temp);
            }
            System.out.println(stringBuilder);
        }catch (Exception e){

        }finally {
            if (fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

三.IO流新语法经典写法

我们往往使用try-with-resource简化代码来实现IO流的读写操作，这会大大的减少代码量。

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

public class Test3 {
    public static void main(String[] args) {
        try(FileInputStream fileInputStream = new FileInputStream("src/main/java/IO流补充/a.txt")){
            StringBuilder stringBuilder = new StringBuilder();
            int temp = 0;
            //返回的是该字节的ASCLL码值
            while((temp = fileInputStream.read())!=-1){
                stringBuilder.append((char)temp);
            }
            System.out.println(stringBuilder);
        }catch (Exception e){
            e.printStackTrace();
        }

        try(FileOutputStream fileOutputStream = new FileOutputStream("src/main/java/IO流补充/a.txt",false)){
            //true(内容会追加到文件中)
            //false(默认覆盖原来内容)
            String temp = "cjy";
            fileOutputStream.write(temp.getBytes());
            //刷新数据将数据从内存中写入磁盘中
            fileOutputStream.flush();
        }catch (Exception ee){
            ee.printStackTrace();
        }


    }
}

必须是实现了java.lang.AutoCloseable接口的对象才可以关闭资源

try(创建输入流对象){

}catch(Exception e){

}finally{

}
//该格式会自动关闭资源

以上让宝贝们先了解一下关于流的知识。之后我们正式开始讲解呀！！

四.Java中流的概念细分

1.按流的方向分类：

输入流：数据流向是数据源到程序（以InputStream、Reader结尾的流）。

输出流：数据流向是程序到目的地（以OutPutStream、Writer结尾的流）。

2.按处理的数据单元分类：

字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、

FileOutputStream。

字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如

FileReader、FileWriter。

3.按处理对象不同分类：

节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、

DataInputStream等。

处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，

如BufferedInputStream、BufferedReader等。处理流也叫包装流。

节点流处于IO操作的第一线，所有操作必须通过它们进行；处理流 可以对节点流进行包装，提高性能或提高程序的灵活性。

五.Java中IO流类的体系

这里我们只列举出来常用的流。InputStream,OutputStream,Reader和Writer是我们IO流的四大抽象父类。需要我们牢牢掌握。

字节缓冲流复制文件（字节输入流和输出流的应用）

import java.io.FileInputStream;
import java.io.FileOutputStream;
//字节缓冲流
public class TestFileByteBuffer {
    public static void main(String[] args) {
        long time1 = System.currentTimeMillis();
        copyFile("src/main/java/IO流补充/a.txt","src/main/java/IO流补充/b.txt");
        long time2 = System.currentTimeMillis();
        System.out.println(time2 - time1);
    }
    /*
    src:源文件
    desc:目标文件
     */
    public static void copyFile(String src,String desc){
        try(FileInputStream fileInputStream = new FileInputStream(src);
            FileOutputStream fileOutputStream = new FileOutputStream(desc)){
            int temp = 0;
            //创建字节缓冲区，大大提高了速率----------------------------
            byte[] bytes = new byte[1024];
            while((temp = fileInputStream.read(bytes))!= -1){
                //返回的是实际读取的字节数
                System.out.println(temp);
                fileOutputStream.write(bytes,0,temp);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

缓冲字节流

Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流（节点流或其他处理流）上加缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包装流BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。

使用缓冲流实现文件的高效率复制

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//缓冲字节流
public class TestFileBufferStream {
    public static void main(String[] args) {
        copyFile("src/main/java/IO流补充/a.txt","src/main/java/IO流补充/b.txt");
    }
    public static void copyFile(String source,String destination){
        try(FileInputStream fileInputStream = new FileInputStream(source);
            FileOutputStream fileOutputStream = new FileOutputStream(destination);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream)){
            int temp = 0;
            while((temp = bufferedInputStream.read())!=-1){
                System.out.print((char)temp);
                bufferedOutputStream.write(temp);
            }
            bufferedOutputStream.flush();

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

}

文件字符输入流

前面介绍的文件字节流可以处理所有的文件，如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。

import java.io.FileReader;

public class TestFileReader {
    public static void main(String[] args) {
        try(FileReader fileReader = new FileReader("src/main/java/IO流补充/a.txt")){
            StringBuilder stringBuilder = new StringBuilder();
            int temp = 0;
            //字符流返回的也还是整数，也需要转换成字符流
            while ((temp = fileReader.read())!= -1){
                System.out.println(temp);
                stringBuilder.append((char)temp);
            }
            System.out.println(stringBuilder);

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

文件字符输出流

import java.io.FileWriter;

public class TestFileWriter {
    public static void main(String[] args) {
        try(FileWriter fileWriter = new FileWriter("src/main/java/IO流补充/a.txt",true)){
            //\r\n表示的是回车换行
            fileWriter.write("你好,");
            fileWriter.write("喜欢！\r\n");
            fileWriter.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

缓冲字符流

BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率。

readLine()方法是BufferedReader的方法，可以对文本文件进行更加方便的读取操作。

newLine()方法BufferedWriter的方法，可以使用newLine()方法换行。

复制文件中的内容到另一个文件并且添加行号

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

//为文件里面的内容添加行号
public class TestLineNumber {
    public static void main(String[] args) {
        try(BufferedReader br = new BufferedReader(new FileReader("src/main/java/IO流补充/a.txt"));
            //创建字符输出缓冲流与文件字符输出流
            BufferedWriter bw = new BufferedWriter(new FileWriter("src/main/java/IO流补充/b.txt"))) {
            String str = "";
            int i = 1;
            while ((str = br.readLine())!=null){
                bw.write(i+"."+str);
                bw.newLine();
                i++;
            }
            //刷新
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;

public class TestBufferedReader {
    public static void main(String[] args) {
        //创建字符缓冲处理流。缓冲区默认大小为8192个字符。
        try(FileReader fileReader = new FileReader("src/main/java/IO流补充/a.txt");
            BufferedReader bufferedReader = new BufferedReader(fileReader)){
            //操作流
            String str = "";
            while ((str = bufferedReader.readLine())!=null){
                System.out.println(str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;

public class TestBufferedWriter {
    public static void main(String[] args) {
        try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src/main/java/IO流补充/a.txt",true))){
            //创建字符输出缓冲流对象
            //操作字符输入缓冲流
            bufferedWriter.newLine();
            bufferedWriter.write("我喜欢");
            bufferedWriter.newLine();
            bufferedWriter.write("你知道我喜欢你吗？");
            bufferedWriter.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

六.小结

目前，我们讲解了IO流的基本概念以及字节流，字符流和缓冲流和一些代码还有一些相关的例子，希望宝贝们可以熟练掌握，在我们之后学习的网络编程中还有以后的开发中占的比例非常大。喜欢的宝子们点个赞呀！

无缘过去@

关注

48
点赞
踩
34

收藏

觉得还不错? 一键收藏
打赏
1
评论
IO流基础知识(基本字节流，字符流和缓冲流)

流的读取与写入功能，只是在别的流（节点流或其他处理流）上加缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包装流BufferedInputStream和。前面介绍的文件字节流可以处理所有的文件，如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。语句读取内容，但是在实际开发中通常我们根本不知道文件的内容，因此我们在读取的时候需要配合while。1. 我们读取的文件内容是已知的，因此可以使用固定次数的。这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。
复制链接

扫一扫