IO流详细总结

最新推荐文章于 2023-06-19 11:22:11 发布
最新推荐文章于 2023-06-19 11:22:11 发布
阅读量142 收藏 1
点赞数
分类专栏： Java 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adsdaas/article/details/108587142
版权

目录

一、概念

1.1什么是IO流

流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出

1.2为什么要学IO流

  • 使用IO流技术读取文件的内容数据。
  • 解决设备与设备之间的数据传输问题。 内存—>硬盘 硬盘—>内存

二、流的分类

在这里插入图片描述

2.1按照数据的流向划分：

  • 输入流：以字节为单位，可以读写所有数据。
  • 输出流：一字符为单位，只能读写文本数据。

判断是输入流还是输出流：

以当前程序作为参照物，观察数据是流入还是流出，如果是流入则是输入流，如果是流出则是输出流。

在这里插入图片描述

2.2按照处理的单位划分：

  • 字节流：字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。
  • 字符流：字符流读取的数据是以字符为单位的 。 字符流也是读取文件中的二进制数据，但是会把这些二进制数据转换成我们能识别的字符。

字符流 = 字节流 + 解码

三、字节流

简介

输入字节流
    -----------| InputStream 输入字节流的基类   抽象类
    ----------------| FileInputStream 读取文件数据的输入字节流。
    ----------------| BufferedInputStream 缓冲输入字节流    缓冲输入字节流出现的目的： 为了提高读取文件数据的效率。 该类内部维护了一个8kb字节数组
 
输出字节流：
    ---------| OutputStream 输出字节流的基类。  抽象类
    --------------| FileOutStream  向文件输出数据的输出字节流。
    --------------| BufferedOutputStream 缓冲输出字节流。  该类出现的目的是为了提高写数据的效率 。 该类内部也是维护了一个8kb的数组
    当调用其write方法的时候数据默认是向它内部的数组中存储的，只有调用flush方法或者是close方法或者是8kb的字节数组存储满数据的时候才会真正的向硬盘输出。

3.1输入字节流

--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流

使用FileInputStream读取文件数据的步骤：

  • 找到目标文件
  • 建立数据的输入通道。
  • 读取文件中的数据。
  • 关闭资源.
public class Demo1 {
    
    public static void main(String[] args) throws IOException {
        readTest4();
    }
    
    //方式4：使用缓冲数组配合循环一起读取。28G
    public static void readTest4() throws IOException{
        long startTime = System.currentTimeMillis();
        //找到目标文件
        File file = new File("F:\\study\\1.jpg");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲数组配合循环读取文件的数据。
        int length = 0; //保存每次读取到的字节个数。
        byte[] buf = new byte[1024]; //存储读取到的数据    缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。  理论上缓冲数组越大，效率越高
        
        while((length = fileInputStream.read(buf))!=-1){ // read方法如果读取到了文件的末尾，那么会返回-1表示。
            System.out.print(new String(buf,0,length));
        }
        
        //关闭资源
        fileInputStream.close();
        

        long endTime = System.currentTimeMillis();
        System.out.println("读取的时间是："+ (endTime-startTime)); //446
    }
    
    
    //方式3：使用缓冲 数组 读取。 缺点： 无法读取完整一个文件的数据。 12G
    public static void readTest3() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲字节数组，读取文件的数据。
        byte[] buf = new byte[1024];  
        // 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，
        //而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
        int length = fileInputStream.read(buf); 
        System.out.println("length:"+ length);
        
        //使用字节数组构建字符串
        String content = new String(buf,0,length);
        System.out.println("内容："+ content);
        //关闭资源
        fileInputStream.close();
    }

    //方式2 ： 使用循环读取文件的数据
    public static void readTest2() throws IOException{
        long startTime = System.currentTimeMillis();
        //找到目标文件
        File file = new File("F:\\study\\1.jpg");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取文件的数据
        int content = 0; //声明该变量用于存储读取到的数据
        while((content = fileInputStream.read())!=-1){
            System.out.print((char)content);
        }
        //关闭资源
        fileInputStream.close();
        
        long endTime = System.currentTimeMillis();
        System.out.println("读取的时间是："+ (endTime-startTime)); //446
    }
    
    
    
    //读取的方式一   缺陷： 无法读取完整一个文件 的数据.
    public static void readTest1() throws IOException{
        //1. 找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道。
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取文件中的数据
        int content = fileInputStream.read(); // read() 读取一个字节的数据，把读取的数据返回。
        System.out.println("读到的内容是："+ (char)content);
        //关闭资源    实际上就是释放资源。 
         fileInputStream.close();
    }
    
    
}

3.2输出字节流

 --------| OutputStream 是所有输出字节流 的父类。  抽象类
 -----------| FileOutStream 向文件输出数据的输出字节流。

使用FileOutputStream写出文件的步骤：

  • 找到目标文件
  • 建立数据的输出通道。
  • 把数据转换成字节数组写出。
  • 关闭资源
public class Demo1 {
    
    public static void main(String[] args) throws IOException {
        writeTest3();
    }
    
    //使用字节数组把数据写出。
    public static void writeTest3() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //把数据写出。
        String data = "abc";   
        byte[] buf = data.getBytes();
        fileOutputStream.write(buf, 0, 3); // 0 从字节数组的指定索引值开始写， 3：写出两个字节。
        //关闭资源
        fileOutputStream.close();
    }

    //使用字节数组把数据写出。
    public static void writeTest2() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file,true);
        //把数据写出。
        String data = "\r\nhello world";
        fileOutputStream.write(data.getBytes());
        //关闭资源
        fileOutputStream.close();
    }
    
    
    
    //每次只能写一个字节的数据出去。
    public static void writeTest1() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //把数据写出
        fileOutputStream.write('h');
        fileOutputStream.write('e');
        fileOutputStream.write('l');
        fileOutputStream.write('l');
        fileOutputStream.write('o');
        //关闭资源
        fileOutputStream.close();
    } 
}

FileOutputStream要注意的细节：

  1. 使用FileOutputStream的时候，如果目标文件不存在，那么会自动创建目标文件对象。
  2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
  3. 使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
  4. 使用FileOutputStream的write方法写数据的时候，虽然接收的是一个 int 类型的数据，但是真正写出的只是一个字节的数据，只是把低八位的二进制数据写出，其他二十四位数据全部丢弃。

3.3输入输出完整案例

public class Demo2 {
    
    public static void main(String[] args) throws IOException {
        readTest();
    }
    
    public static void readTest() throws IOException{
        //找到目标文件
        File file = new File("F:\\hcx.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲输入读取文件数据
        byte[] buf = new byte[4];
        //读取文件数据
        int length = fileInputStream.read(buf);
        System.out.println("字节数组的内容："+ Arrays.toString(buf));
        //关闭资源
        fileInputStream.close();
        
    }

    public static void writeTest() throws FileNotFoundException, IOException {
        //找到目标文件
        File file = new File("F:\\hcx.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //把数据写出
        fileOutputStream.write(511);
        //关闭资源
        fileOutputStream.close();
    }
}

3.4拷贝一张图片

public class CopyImage {
    
    public static void main(String[] args) throws IOException {
        //找到目标文件
        File inFile = new File("F:\\1.jpg");
        File destFile = new File("E:\\1.jpg");
        //建立数据的输入输出通道
        FileInputStream fileInputStream = new  FileInputStream(inFile);
        FileOutputStream fileOutputStream = new FileOutputStream(destFile); //追加数据....
        
        //每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。 
        //每写出一次，指针都会出现相应移动。
        //建立缓冲数据，边读边写
        byte[] buf = new byte[1024]; 
        int length = 0 ; 
        while((length = fileInputStream.read(buf))!=-1){ 
            fileOutputStream.write(buf,0,length); 
        }
        //关闭资源 原则： 先开后关，后开先关。
        fileOutputStream.close();
        fileInputStream.close();
    }
}

四、IO异常的处理

在发生异常时，要阻止后面的代码执行，并且要通知调用者这里出错了：

通过在catch块中抛出运行时异常，并把异常传递过去，抛出运行时异常，方法上可以声明也可以不声明，调用者可以处理也可以不处理，把IOException传递给RuntimeException包装一层，然后再抛出，这样做的目的是为了让调用者使用变得更加灵活。

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

import javax.management.RuntimeErrorException;

/*
 IO异常 的处理
 */
public class Demo1 {

    public static void main(String[] args) {
    //  readTest();
        copyImage();
    }

    // 拷贝图片
    public static void copyImage() {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            // 找到目标文件
            File inFile = new File("F:\\1.jpg");
            File outFile = new File("E:\\1.jpg");
            // 建立输入输出通道
            fileInputStream = new FileInputStream(inFile);
            fileOutputStream = new FileOutputStream(outFile);
            // 建立缓冲数组，边读边写
            byte[] buf = new byte[1024];
            int length = 0;
            while ((length = fileInputStream.read(buf)) != -1) {
                fileOutputStream.write(buf, 0, length);
            }
        } catch (IOException e) {
            System.out.println("拷贝图片出错...");
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                    System.out.println("关闭输出流对象成功...");
                }
            } catch (IOException e) {
                System.out.println("关闭输出流资源失败...");
                throw new RuntimeException(e);
            } finally {
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                        System.out.println("关闭输入流对象成功...");
                    } catch (IOException e) {
                        System.out.println("关闭输入流对象失败...");
                        throw new RuntimeException(e);
                    }
                }

            }
        }
    }

    public static void readTest() {
        FileInputStream fileInputStream = null;
        try {
            // 找到目标文件
            File file = new File("F:\\a.txt");
            // 建立数据输入通道
            fileInputStream = new FileInputStream(file);
            // 建立缓冲数组读取数据
            byte[] buf = new byte[1024];
            int length = 0;
            while ((length = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, length));
            }
        } catch (IOException e) {
            /*
             * //处理的代码... 首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了... throw new
             * RuntimeException(e);
             * //把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
             * 为了让调用者使用变得更加灵活。
             */
            System.out.println("读取文件资源出错....");
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                    System.out.println("关闭资源成功...");
                }
            } catch (IOException e) {
                System.out.println("关闭资源失败...");
                throw new RuntimeException(e);
            }
        }
    }

}

五、缓冲字节流

缓冲输入字节流对象,可以更高效率读取文件。

5.1缓冲输入字节流

----| InputStream  输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流  缓冲输入字节流的出现主要是为了提高读取文件数据的效率。(其实该类内部只不过是维护了一个8kb的字节数组而已。)

使用BufferedInputStream的步骤:

  1. 找到目标文件
  2. 建立数据的输入通道
  3. 建立缓冲输入字节流流
  4. 关闭资源

注意： 凡是缓冲流都不具备读写文件的能力。
有缓冲流时，只需要关闭缓冲流，因为调用BufferedInputStream的close方法实际上关闭的是FileinputStream.

BufferedInputStream出现的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据，而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream效率高的原因是什么？

缓冲类内部维护了一个8kb的字节数组，而BufferedInputStream的read()方法源码如下：

public synchronized int read() throws IOException {
    if (pos >= count) {
        fill();
        if (pos >= count)
        return -1;
    }
    return getBufIfOpen()[pos++] & 0xff;
}

count： 目前缓冲数组中存储了几个字节的数据
pos： 当前已经读取到了第几个字节（指针）

第一次的时候，count为0，pos也为0，调用fill()方法，使用内部维护的缓冲数组去读取文件数据，一次最多读取8kb的字节数据到缓冲数组中。最后从字节数组中取出数据并返回。当第二次往后调用时，每次都从字节数组中取出数据并返回，直到取完之后，再次填充。而fileInputStream每次都是从硬盘中读取数据。

使用bufferedInputStream和自己创建一个8kb的字节数组，两者的效率是一样的。严格意义上说，自己创建数组效率更高一些，因为没有了判断的步骤。

public class Demo1 {
    
    public static void main(String[] args) throws IOException {
        readTest2();
    }
    
    public static void readTest2() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        
        FileInputStream fileInputStream= new FileInputStream(file);
        //创建BufferedInputStream的时候需要传入fileInputStream：BufferedInputStream本身不具备读文件的能力，
        //需要借助fileInputStream来读取文件的数据。
        BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
        bufferedInputStream.read();

        
        //读取文件数据
        int content = 0 ;
        //BufferedInputStream出现 的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据
        //而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream为什么效率更高
        while((content = fileInputStream.read())!=-1){
            System.out.print((char)content);
        }
        
        //关闭资源
        bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
    }

    //读取文件的时候都是使用缓冲数组读取。效率会更加高(推荐)
    public static void readTest() throws IOException{
        File file = new File("F:\\a.txt");
        //建立数组通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲数组读取数据
        byte[] buf = new byte[1024*8];
        int length = 0; 
        while((length = fileInputStream.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
        //关闭资源
        fileInputStream.close();
    }
    
}

5.2缓冲输出字节流

--------| OutputStream  所有输出字节流的基类  抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream  缓冲输出字节流  BufferedOutputStream出现的目的是为了提高写数据的效率。 (内部也是维护了一个8kb的字节数组)
  • 使用BufferedOutputStream写数据的时候，它的write方法是先把数据写到它内部维护的字节数组中
  • 如果需要把数据真正的写到硬盘上面，需要调用flush方法，当内部维护的字节数组已经填满数据的时候，会自动把数据刷出去。
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输出通道
        FileOutputStream  fileOutputStream = new FileOutputStream(file);
        //建立缓冲输出字节流对象
        BufferedOutputStream bufferedOutputStream  = new BufferedOutputStream(fileOutputStream);
        //把数据写出
        bufferedOutputStream.write("hello world".getBytes()); 
        //把缓冲数组中内部的数据写到硬盘上面。
        //bufferedOutputStream.flush();
        bufferedOutputStream.close();
    }
}

注意：使用read方法把内容存储到了缓冲数组中，返回值返回的是存储到缓冲数组中的字节个数。如果read方法没有传入缓冲数组，那么返回值就是读取到的内容。

5.3使用缓冲输入输出字节流拷贝图片：

public class CopyImage {
    public static void main(String[] args) throws IOException {
        //找到目标文件
        File  inFile = new File("F:\\java\\1.jpg");
        File outFile = new File("E:\\1.jpg");
        //建立数据输入输出通道
        FileInputStream fileInputStream = new FileInputStream(inFile);
        FileOutputStream fileOutputStream = new FileOutputStream(outFile);
        //建立缓冲输入输出流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        //边读边写
        int content = 0; 
        // int length = bufferedInputStream.read(buf);   如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
        while((content = bufferedInputStream.read())!=-1){ // 如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
            bufferedOutputStream.write(content);
//          bufferedOutputStream.flush();
        }
        //关闭资源
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

六、字符流

使用字节流来读写中文都是比较麻烦的：

public class Demo1 {
    
    public static void main(String[] args) throws IOException {
//      writeTest();
        readrTest();
    }
    
    //使用字节流读取中文
    public static void readrTest() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取内容
        //int content = 0;
        
        /*while((content = fileInputStream.read())!=-1){ //出现乱码的原因： 一个中文在gbk码表中默认是占两个字节，
                                                       // 目前你只读取了一个字节而已，所以不是一个完整的中文。
            System.out.print((char)content);
        }*/
        byte[] buf = new byte[2];
        for(int i = 0 ; i < 3 ; i++){
            fileInputStream.read(buf);
            System.out.print(new String(buf));
        }
        //关闭资源
        fileInputStream.close();
    }
    //使用字节流写中文。   
    //字节流之所以能够写中文是因为借助了字符串的getBytes方法对字符串进行了编码（字符---->数字）。 
    public static void writeTest() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream  = new FileOutputStream(file);
        //准备数据，把数据写出。
        String data = "大家好";
        byte[] buf = data.getBytes();   //把字符串转换成字节数组
        System.out.println("输出的内容："+ Arrays.toString(buf));//[-76,-13,-68,-46,-70,-61]
        fileOutputStream.write(buf);
        ///关闭资源
        fileOutputStream.close();
    }
}

字节流读取的是文件中的二进制数据，读到的数据并不会帮你转换成你看得懂的字符。

6.1输入字符流

  • 字符流： 字符流会把读取到的二进制的数据进行对应的编码与解码工作。
  • 字符流 = 字节流 + 编码(解码)
-------| Reader 所有输入字符流的基类。 抽象类
----------| FileReader 读取文件字符串的输入字符流。
----------| BufferedReader   缓冲输入字符流 。 缓冲输入字符流出现的目的是为了提高读取文件 的效率和拓展了FileReader的功能。(其实该类内部也是维护了一个字符数组)

案例如下：

public class Demo2 {

    public static void main(String[] args) throws IOException {
        readTest2();
        //readTest1();
    }
    
    //使用缓冲字符数组读取文件。
    public static void readTest2() throws IOException{
        //找到目标文件
        File file = new File("F:\\Demo1.java");
        // 建立数据的输入通道
        FileReader fileReader = new FileReader(file);
        //建立缓冲字符数组读取文件数据
        char[] buf = new char[1024];
        int length = 0 ; 
        while((length = fileReader.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
    }

    
    public static void readTest1() throws IOException{
        //找到目标文件
        File file = new File("F:\\Demo1.java");
        //建立数据的输入通道
        FileReader fileReader = new FileReader(file);
        int content = 0 ;
        while((content = fileReader.read())!=-1){ //每次只会读取一个字符，效率低。
            System.out.print((char)content);
        }
        //关闭资源
        fileReader.close();
    }
    
}

注意：缓冲流都不具备读写文件的能力。

5.2输出字符流

------| Writer 输出字符流的基类。抽象类
-----------| FileWriter 向文件输出数据的输出字符流

FileWriter要注意的事项：

  1. 使用FileWriter写数据的时候，FileWriter内部是维护了一个1024个字符数组的，写数据的时候会先写入到它内部维护的字符数组中，如果需要把数据真正写到硬盘上，需要调用flush方法或者是填满了内部的字符数组。
  2. 使用FileWriter的时候，如果目标文件不存在，那么会自动创建目标文件。
  3. 使用FileWriter的时候， 如果目标文件已经存在了，那么默认情况会先清空文件中的数据，然后再写入数据 ， 如果需要在原来的基础上追加数据，需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为```true``。
public class Demo1 {

    public static void main(String[] args) throws IOException {
        writeTest1();
    }
    
    public static void  writeTest1() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据输出通道
        FileWriter fileWriter = new FileWriter(file,true);
        //准备数据，把数据写出
        String data = "你好 世界";
        fileWriter.write(data);  //字符流具备解码的功能。
        //刷新字符流
//      fileWriter.flush();
        //关闭资源
        fileWriter.close();

    }
}

注意：尽量不要使用FileWrite拷贝图片，数据会丢失导致图片显示不出来。

七、缓冲字符流

7.1缓冲输入字符流

-------| Reader 所有输入字符流的基类。 抽象类
----------| FileReader 读取文件字符串的输入字符流。
----------| BufferedReader   缓冲输入字符流 。缓冲输入字符流出现的目的是为了提高读取文件的效率和拓展了FileReader的功能。(该类内部也是维护了一个字符数组)

案例如下：

public class Demo1 {

    public static void main(String[] args) throws IOException {
//       readTest1();
        File file  = new File("F:\\Demo1.java");
        //建立数据的输入通道。
        FileReader fileReader = new FileReader(file);
        String line =  null;
        
        while((line = myReadLine(fileReader))!=null){
            System.out.println(line);
        }
    }

    
    //实现readLine方法。
    public static String myReadLine(FileReader fileReader) throws IOException{
        //创建一个字符串缓冲类对象
        StringBuilder sb = new StringBuilder();  //StringBuilder主要是用于存储读取到的数据
        int content = 0 ;
        while((content = fileReader.read())!=-1){
            if(content=='\r'){
                continue;
            }else if(content=='\n'){
                break;
            }else{
                //普通字符
                sb.append((char)content);
            }
        }
        //代表已经读取完毕了。
        if(content ==-1){
            return null;
        }
        
        return sb.toString();  
    }
    
    public static void readTest1() throws IOException{
        //找到目标文件
        File file  = new File("F:\\a.txt");
        //建立数据的输入通道。
        FileReader fileReader = new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //读取数据
        /*int content = bufferedReader.read();  //读到了一个字符。 读取到的字符肯定也是从Bufferedreader内部的字符数组中获取的到。所以效率高。
        System.out.println((char)content);*/
        //使用BUfferedReader拓展的功能，readLine()  一次读取一行文本，如果读到了文件的末尾返回null表示。
        String line =  null;
        while((line = bufferedReader.readLine())!=null){ // 虽然readLine每次读取一行数据，但是返回的line是不包含\r\n的
            System.out.println(Arrays.toString("a".getBytes()));
        }
        //关闭资源
        bufferedReader.close();
        
    }
}

注意缓冲流都不具备读写的能力

7.2.缓冲输出字符流

----------| Writer  所有输出字符流的基类，  抽象类。
--------------- | FileWriter 向文件输出字符数据的输出字符流。 
----------------| BufferedWriter 缓冲输出字符流

缓冲输出字符流作用： 提高FileWriter的写数据效率与拓展FileWriter的功能。
BufferedWriter内部提供了一个8192长度的字符数组作为缓冲区，拓展了FileWriter的功能。

public class Demo2 {

    public static void main(String[] args) throws IOException {
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输出通道
        FileWriter fileWriter = new FileWriter(file,true);
        //建立缓冲输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter); 
        //写出数据
//      bufferedWriter.newLine(); //newLine() 换行。 实际上就是向文件输出\r\n.
        bufferedWriter.write("\r\n");
        bufferedWriter.write("我要学好Java");
        //关闭资源
        bufferedWriter.flush();
//      bufferedWriter.close();
        
    }
}

如果觉得这篇总结对自己有益的话，请多支持一下好吗。

咖啡味的茶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaIO流详细总结
08-17
这个也是网上牛人总结的，主要是全，每个都有例子
IO流学习总结
01-26
本文档为本人学习 java IO流期间的学习总结笔记，希望对新学习的朋友有所帮助和参考价值。本人java 开发时间不是太长，可能存在不完善或不对之处，欢迎指正！
IO流 （字节流、字符流）
qq_46030254的博客
06-08 4295
IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。如下图所示IO流在Java中有很多种，不同的流来干不同的事情。Java把各种流用不同的类来表示，这些流的继承体系如下图所示：IO流分为两大派系：1.字节流：字节流又分为字节输入流、字节输出流2.字符流：字符流由分为字符输入流、字符输出流。
常见IO流汇总——已完结
qq_42108133的博客
05-27 664
1 IO 1.1 IO的分类 根据数据流向分类 输入流：把数据从其他设备读取到内存 ​ 以InputStream,Reader结尾 输出流：把数据从内存中写出到其他设备 ​ 以OutputStream、Writer结尾 根据数据类型分类 字节流：已字节为单位，读写数据 ​ 以InputStream和OutputStream结尾 字符流：以字符为单位，读写数据 ​ 以Reader和Writer结尾 根据IO流的角色不同 节点流：可以从或向一个特定的地方（节点）读写数据 处理流：是对一个
IO 流超级详细讲解
业精于勤，荒于嬉
03-31 1208
从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。//如果返回-1 , 表示读取完= -1)}//转成 char 显示 }1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面3. 写入一个字节 fileOutputStream.write('H');4. 写入字符串 String str = "world!
IO流详解.
lwj_07的博客
04-01 5662
一、IO流概述 IO流： 什么是IO？ I：Input O：Output (断电内存数据消失) 二、IO流的分类 Io流的分类? 有多种分类方式: 一种方式是按照流的方向进行分类: 以内存作为参照物,往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write) 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte,等同于一次读...
Java学习之IO流
qq_53723728的博客
06-19 1541
IO流介绍IO：输入/输出(Input/Output)流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载IO流的分类按照数据的流向输入流：读数据输出流：写数据按照数据类型来分字节流字节输入流字节输出流字符流字符输入流字符输出流IO流的使用场景如果操作的是纯文本文件，优先使用字符流如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
Java io流总结
08-12
Java io流的总结
java-io流学习总结.doc
11-24
java-io流学习总结.doc
关于Java中的IO流总结(推荐)
08-30
下面小编就为大家带来一篇关于Java中的IO流总结(推荐)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
最全最详细的IO流教程
奔跑的熊猫
05-27 7947
最全最详细的IO流教程
关于流的概念及字节流的使用
孤云博客
05-23 2145
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)。 1.流按照方向分：输入流，输出流。流的方向以内存作为参照物。 如果从数据源中将数据读取到内存叫输入流，也叫读取流。 如果将内存中的数据写入到数据源，叫输出流，也叫写入流。 2.流按照类型分 :字节流、字符流、对象...
流介绍
m0_61547956的博客
09-25 818
1.流就是一个类的对象 2.计算机中的流其实是一种信息的转换，接受外界信息的输入叫做输入流（input），相应的从对象向外输出，叫做输出流（output），输入输出流（I/O Streams）。 3.对象间进行信息或者数据交换先将数据或者对象转换成某种的流，通过流的传输到达目的对象后再将流转换成对象数据。 4.可以把流看成数据的载体，数据交换和传输 5.流所在的命名空间System.IO（提供了很多类），主要包括文本文件的读写，图像和声音文件的读写，二进制文件读写等。 6.流是字节序列的抽象概念，写操作，数
IO流（数据流）
LizChaol的博客
10-19 1044
IO技术：把程序中的数据最终输出到持久设备上。或者从持久设备读取已经存在的数据，最后给我们读取到程序中。IO：input 输入 读操作output输出 写操作2：file类介绍需要把数据持久的保存起来，最终都要以文件的形式存储在持久设备上。如果持久设备上文件太多如何管理？就会使用文件夹来管理文件或者文件夹。在学习IO技术之前，需要了解Java是如何针对文件和文件夹这类事物做封装的。在Java中使用File 这个类来描述持久设备上的文件或者文件夹。文件：是用来保存真实的数据的。
IO流详解
Maddoxzhi的博客
10-26 1524
I/O是Input和Output的缩写，I/O技术是非常实用的技术，用于处理数据传输，如读/写文件，网络通讯等 Java程序中，对于数据的输入/输出操作以“流（Stream）”的方式进行 Java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中
IO流
CSDN_HCX的博客
02-12 209
IO流 使用IO流技术读取文件的内容数据。 IO流解决问题： 解决设备与设备之间的数据传输问题。 内存—&gt;硬盘 硬盘—&gt;内存 一、IO流分类 1.按照数据的流向划分： 输入流 输出流 判断是输入流还是输出流： 以当前程序作为参照物，观察数据是流入还是流出，如果是流入则是输入流，如果是流出则是输出流。 2.按照处理的单位划分： 字节流：字节流读取得都是文件中二进制数据，读取...
流
愿世界和平的IT劝退师
10-12 286
并发重点在于一个极短时间段内运行多个不同的任务；并行重点在于同时运行一个任务。 1.       任务并行性：是指并行执行两个或多个不同的任务，而不是在大量数据上执行同一个任务。 2.       概念：CUDA流表示一个GPU操作队列，并且该队列中的操作将以指定的顺序执行。我们可以在流中添加一些操作，如核函数启动，内存复制以及事件的启动和结束等。这些操作的添加到流的顺序也是它们的执行顺序。
史上最骚最全最详细的IO流教程
qq_16932445的博客
02-01 584
前言io流用到的地方很多，就比如上传下载，传输，设计模式等....基础打扎实了，才能玩更高端的。 在博主认为真正懂IO流的优秀程序员每次在使用IO流之前都会明确分析如下四点： （1）明确要操作的数据是数据源还是数据目的(也就是要读还是要写)（2）明确要操作的设备上的数据是字节还是文本（3）明确数据所在的具体设备（4）明确是否需要额外功能（比如是否需要转换流、高效流等） 以上四点将会在文章...
java IO流学习总结
weixin_34290096的博客
10-02 2215
java IO流学习总结 近期学习了Java的IO流，尝试着总结一下。 java.io 包下的IO流很多： 其中，以Stream结尾的为字节流，以Writer或者Reader结尾的为字符流。所有的输入流都是抽象类IuputStream（字节输入流）或者抽象类Reader（字符输入流）的子类，所有的输出流都是抽象类OutputStream(字节输出流)或者抽象类Writer(字符输出流)的...
stream流和IO流
最新发布
08-19
"stream流" 和 "IO流" 都是在Java中用于处理...总结起来，"stream流" 是指在程序和外部资源之间传输数据的抽象概念，而 "IO流" 是Java中用于处理输入和输出的类库，提供了各种类和方法用于操作流进行数据读取和写入。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值