Java IO流体系及节点流的使用

过期动态

已于 2022-05-01 20:48:56 修改

阅读量463

点赞数 2

分类专栏： JavaSE笔记文章标签： java 开发语言 intellij-idea 后端

于 2022-04-23 20:09:07 首次发布

本文链接：https://blog.csdn.net/qq_46370017/article/details/124226501

版权

JavaSE笔记专栏收录该内容

43 篇文章 1 订阅

订阅专栏

IO流

1，Java IO流引入
2，IO流的分类
3，IO流中节点流的使用

1，Java IO流引入

在这里插入图片描述

2，IO流的分类

在这里插入图片描述

节点流是直接作用于文件的流，处理流是在节点流的基础上又包了一层，如下图所示：
在这里插入图片描述

在这里插入图片描述
注：蓝底背景的流为常用的流，需要掌握：

总结：
①上图中InputStream类下方同列的类均为InputStream子类，其他列同理：
② 其中FileInputStream、FileOutputStream、FileReader、FileWriter为节点流，可以直接操作file。
③ 区分上图表中流是字节流还是字符流可以通过看后缀最后一个单词，如InputStreamReader为字符流。
④ 文本文件适合使用字符流，非文本文件（图片、视频）适合使用字节流。

3，IO流中节点流的使用

FileInputStream、FileOutputStream、FileReader、FileWriter为节点流，可以直接操作file。

①当前文件目录如下图所示：（JavaSenior工程下有若干module，我们在module day09下创建一个hello.txt文件，文件内容为helloworld）

在这里插入图片描述

②首先通过以下代码说明一个有关相对路径的问题：

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
public class FileReaderWriterTest {
    public static void main(String[] args) {
        File file=new File("hello.txt"); //传入相对路径，注意main()中是相对于当前工程
        System.out.println(file.getAbsolutePath()); //E:\ideaworkspace\ideaprojects\JavaSenior\hello.txt
        //若想用module day09下的hello.txt，需要:
        File file0=new File("day09\\hello.txt"); //传入相对路径，注意main()中是相对于当前工程
        System.out.println(file0.getAbsolutePath()); //E:\ideaworkspace\ideaprojects\JavaSenior\day09\hello.txt
    }
    @Test
    public void testFileReader(){
        File file=new File("hello.txt"); //传入相对路径，注意单元测试方法中是相对于当前moudle


    }
}

3.1，FileReader读入数据操作

实现将day09下的hello.txt文件读入程序（硬盘中文件内容读入内存）中，并输出控制台：

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderWriterTest {
    @Test
    public void testFileReader(){
        FileReader fr= null;
        try {
            //1,实例化File类的对象，指明要操作的文件
            File file=new File("hello.txt");  //相较于当前module
            //2,提供具体的流（先使用字符流（文本文件），并且是输入的。因此是FileReader）
            fr = new FileReader(file);  //如果对应目录下没有hello.txt文件，此处会出现文件找不到异常
            //3,数据的读入（此处使用空参的read()方法）
            //方式一：
            //int data = fr.read();  //空参的read()：返回读入的一个字符，如果达到文件末尾，返回-1。char变量对应一个int型变量
            //while(data!=-1){
            //    System.out.print((char)data);    //helloworld
            //    data=fr.read();  //读下一个
            //}
            //方式二：（更简洁）
            int data;
            while ((data=fr.read())!=-1){
                System.out.print((char)data); //helloworld

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4,手动进行流的关闭操作（必须）
            //知识点：Java垃圾自动回收机制只回收JVM堆内存中的对象空间，对于其他物理连接如：数据库连接、输入输出流、Socket连接均无能为力
            try {
                //fr = new FileReader(file);处可能出现文件找不到异常，则这种情况下就会执行finally中代码，，而此时fr对象还没有造好，直接fr.close()则会出现空指针
                if(fr!=null){ //以防出现空指针。
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

在这里插入图片描述

代码总结:
①read()：返回读入一个字符（in型），如果达到文件末尾，返回-1.
②对于异常处理，不能使用throws抛出异常，一定要使用try-catch-finally结构把代码主体包起来，这样才会实现即使程序抛出了异常，依然会执行关闭流的操作。
③ 读入的文件一定要存在，否则会报FileNotFoundException（文件找不到）异常

关于重载的read(char[ ] cubf)方法：
就像快递小哥送快递是一批一批送，送完一波回去取下一波继续送；而若取一个送一个则很浪费时间，

同理空参read()是一个一个地读，但因为一个一个地读效率太差，如果有几十万字，就会很难受。所以引入重载的read(char[ ] cbuf)，一组一组地读取。

read(char[ ] cbuf)：返回每次读入到数组中的字符的个数，如果达到文件末尾，返回-1。

1，我们先把hello.txt文件内容修改一下，如下图
在这里插入图片描述
2，回顾知识点：String和char[ ]之间的转换。

  char[] arr=new char[]{'h','e','l','l','o'};
  String str2 = new String(arr);  //返回即为String型

3，使用read(char[ ] cbuf)方法进行测试（优化）：

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderWriterTest {
    @Test
    public void testFileReader(){
        FileReader fr= null;
        try {
            //1,实例化File类的对象
            File file=new File("hello.txt");  //相较于当前module
            //2,提供具体的流
            fr = new FileReader(file);
            //3,数据的读入
            char[] cbuf=new char[5];    //假如一组放五个
            int len; //记录每次读入到cbuf数组中的字符的个数
            while ((len=fr.read(cbuf))!=-1){
                //遍历，方式一
                //for (int i = 0; i < len; i++) {  //i<len。确保每次读入几个，我们就遍历几个
                //    System.out.print(cbuf[i]);
                //}
                //遍历，方式二
                String str=new String(cbuf,0,len); //使用String的三个参数的构造器。表示对字符串从0开始取每次取len个
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4,手动进行流的关闭操作（必须）
            //知识点：Java垃圾自动回收机制只回收JVM堆内存中的对象空间，对于其他物理连接如：数据库连接、输入输出流、Socket连接均无能为力
            try {
                if(fr!=null){ //以防出现空指针。
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

在这里插入图片描述

将以上代码修改为try-catch-finally结构。IDEA中具体操作为：选中主体代码，使用快捷键ctrl+alt+T，选择try-catch-finally，把流的关闭操作放入finally中，增加if语句避免空指针，再对fw.close()进行try-catch处理。

3.2，FileWriter写出数据操作

从内存中写出数据到硬盘文件里：

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileReaderWriterTest {
    @Test        //从内存中写出数据到硬盘文件里
    public void testFileWriter() {
        FileWriter fw= null;
        try {
            //1,提供File类的对象，指明写出到的文件
            File file=new File("hello1.txt"); //写出到文件名为hello1.txt的文件，一开始module下没有此文件。
            //2,提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file);
            //3,写出的操作
            fw.write("I have a dream!\n"); //\n表示换行
            fw.write("you need to have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4,流资源的关闭
            try {
                if (fw!=null){
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述
总结：

输出操作对应的File可以不存在，并不会报异常

①File对应的硬盘中的文件如果不存在，在输出过程中。会自动创建此文件。

②File对应的硬盘中的文件如果存在，则：

若流使用的构造器为FileWriter(file,false)、FileWrter(file)：则会对原有文件进行覆盖。
若流使用的构造器为FileWriter(file,true)：则不会对原有文件进行覆盖，而是在原有文件基础上追加内容。

因为第二个参数为append是附加的意思，设为true即在原有文件尾部追加内容。
在这里插入图片描述

3.3，使用FileReader和FileWriter实现文本文件的复制

综合以上读入和写出，我们可以实现先读入到内存来，再写出到文件中去。即相当于：

使用FileReader和FileWriter实现文本文件的复制

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileReaderWriterTest {
    @Test
    public void test(){
        FileReader fr= null;
        FileWriter fw= null;
        try {
            //1,创建File类的对象，指明读入和写出的文件
            File srcFile=new File("hello.txt");
            File destFile=new File("hello2.txt"); //输出的操作对应的文件可以不存在
            //2,创建输入流、输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);
            //3,数据的读入和写出操作
            char[] cbuf =new char[5]; //读的话一次读多个，所以先造一个数组
            int len;   //记录每次读入到cbuf数组中的字符的个数
            while ((len=fr.read(cbuf))!=-1){
                //数据写出去
                fw.write(cbuf,0,len); //每次写出len个字符
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4,关闭流资源
            if(fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这里插入图片描述

字符流处理字符，如果想处理二进制字节文件（如图片、视频），则会出错。即 文本文件（.txt、.java、.c、.cpp）使用字符流处理，而非文本文件（图片、视频、音频、.doc、.ppt）使用字节流处理。

冷知识：.doc文件需要用字节流处理(word文件里可以插图)

可以使用FileInputStream、FileOutputStream实现图片复制，读入和写出仍为read和write，char[ ]型数组要换为byte[ ]型数组。

3.4，使用FileInputStream和FileOutputStream读写非文本文件

实现对图片的复制操作

①先在当前module下放入一张图片"img.png"
在这里插入图片描述
②编写代码，进行测试

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputOutputStreamTest {
    @Test    //实现对图片的复制操作
    public void test(){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1,创建File类的对象
            File srcFile=new File("img.png");
            File destFile=new File("img1.png");    //目前img1.png不存在
            //2,创建输入流、输出流的对象
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //3,复制的过程
            byte[] buffer=new byte[5];
            int len; //记录读入数组中的字节长度
            while ((len=fis.read(buffer))!=-1) {
                fos.write(buffer,0,len);  //将buffer里的内容写出去
            }
            System.out.println("复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4,关闭流资源
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

运行后，img1.png 复制成功：
在这里插入图片描述
以上程序中有很多代码可以重用，为了增强程序的可复用性，可以改写为指定路径下非文本文件的复制的通用方法，再进行调用测试

package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputOutputStreamTest {
    //通用方法：指定路径下非文本文件的复制
    public void copyFile(String srcPath,String destPath){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1,创建File类的对象
            File srcFile=new File(srcPath);
            File destFile=new File(destPath);    //目前img1.png不存在
            //2,创建输入流、输出流的对象
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //3,复制的过程
            byte[] buffer=new byte[1024];   //设一个适当的值，如为1024
            int len; //记录读入数组中的字节长度
            while ((len=fis.read(buffer))!=-1) {
                fos.write(buffer,0,len);  //将buffer里的内容写出去
            }
            System.out.println("复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4,关闭流资源
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    public void testCopyFile(){
        long start = System.currentTimeMillis();
        String srcPath="F:\\programming\\1-视频.avi";
        String descPath="F:\\programming\\1-视频-副本.avi";
        copyFile(srcPath,descPath);
        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));
    }
}

在这里插入图片描述

有一个细节问题：

实际上面的通用方法中传入文本文件也可以复制成功。
因为字节流相当于只是充当了一个搬运工，但如果在内存层面看“搬运”的内容，内容可能会出现乱码，而如果原封不动的搬过去，不会报错。
（而非文本文件使用字符流复制行不通）

过期动态

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java IO流体系及节点流的使用

IO流1，Java IO流引入2，IO流的分类3，IO流中节点流的使用3.1，FileReader读入数据操作3.2，FileWriter写出数据操作3.3，使用FileReader和FileWriter实现文本文件的复制3.4，使用FileInputStream和FileOutputStream读写非文本文件1，Java IO流引入2，IO流的分类节点流是直接作用于文件的流，处理流是在节点流的基础上又包了一层，如下图所示：注：蓝底背景的流为常用的流，需要掌握：总结：①上图中Input
复制链接

扫一扫