JavaSE-IO流--IO原理、流的分类、FileReader、FileWriter

已于 2022-06-27 23:09:47 修改
阅读量239 收藏
点赞数
分类专栏： JavaSE 文章标签： java IO流
于 2022-06-27 23:09:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46112274/article/details/125276654
版权

IO原理及流的分类

1、IO原理及流的分类

1.1、Java IO原理

在这里插入图片描述
在这里插入图片描述

1.2、流的分类

在这里插入图片描述

1.3、IO流体系

在这里插入图片描述

2、数据读入FileReader

2.1、FileReader读入数据的基本操作：使用read()方法

  • IDEA中main方法中文件路径是相对于当前工程
  • IDEA中单元测试中的该文件路径是相对于当前module
package com.io.test;

import org.junit.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 一、流的分类
 * 1、操作数据单位：字节流、字符流
 * 2、数据的流向：输入流、输出流
 * 3、流的角色：节点流、处理流
 * 二、流的体系结构
 * 抽象基类              节点流（文件流）           缓冲流（处理流的一种）
 * InputStream          FileInputStream         BufferedInputStream
 * OutputStream         FileOutStream           BufferedOutputStream
 * Reader               FileReader              BufferedReader
 * Writer               FileWriter              BufferedWriter
 */
public class FileReaderWriterTest {

    public static void main(String[] args) {
        File file = new File("Hello.txt");//main方法中该文件路径是相对于当前工程
        System.out.println(file.getAbsolutePath());//获取Hello.txt文件的绝对路径：E:\workspaces\IDEA\JavaSE\Hello.txt

        File file1 = new File("IO\\Hello.txt");
        System.out.println(file1.getAbsolutePath());
    }

     /**
     * 将Hello.txt文件内容读入到程序中，并输出到控制台.
     * 说明点：
     *  1、read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
     *  2、异常的处理：为了保证资源一定可以执行关闭操作。需要使用try-catch-finally处理
     *  3、读入的文件一定要存在，否则就会报FileNotFoundException
     */
    @Test
    public void test(){
        FileReader fileReader = null;
        try {
            //1、实例化File对象，指明要操作的文件
            File file = new File("Hello.txt");//单元测试中的该文件路径是相对于当前module
            //System.out.println(file.getAbsolutePath());//控制台输出为：E:\workspaces\IDEA\JavaSE\IO\Hello.txt

            //2、提供具体的流
            fileReader = new FileReader(file);

            //3、数据的读入
            //Read():返回读入的一个字符。如果达到文件末尾，返回-1
            int data = fileReader.read();
            while (data != -1){
                System.out.print((char)data);
                data = fileReader.read();
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            try {
                //4、关闭流
                if(fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

2.2、FileReader使用read(char[] cbuf)读入数据

  • read(char[] cbuf)：返回每次读入到数组中的字符个数，
public class FileTest{
//对read()操作升级：使用read的重载方法
    @Test
    public void testFileReader(){
        FileReader fr = null;
        try {
            //1、File类的实例化
            File file = new File("Hello.txt");
            //2、FileReader流的实例化
            fr = new FileReader(file);
            //3、读入的操作
            //read(char[] cbuf)：返回每次读入cbuf数组中字符的个数，如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一
                for(int i = 0; i < len; i++){
                    System.out.print(cbuf[i]);
                }
                //方式二
//                String str = new String(cbuf,0,len);
//                System.out.print(str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            //4、关闭流
            if(fr !=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 }

在这里插入图片描述

3、写出数据FileWriter

/**
 * 从内存中写出数据到硬盘的文件里。
 * 说明：
 * 1、输出操作，对应的File可以不存在的。
 * 2、File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建文件。
 *    File的硬盘中的文件如果存在：
 *          如果流使用的构造器是：FileWriter(file,false)/FileWriter(file):对原有文件覆盖
 *          如果流使用的构造器是：FileWriter(file,true):不会对原有的文件覆盖，而是在原有文件基础上增加
 */
public class FileWriter {
    @Test
    public void test() throws IOException {
        //1、提供File类的对象，指明写出到的文件
        File file = new File("writer.txt");

        //2、提供FileWriter的对象，用于数据的写出
        java.io.FileWriter fileWriter = new java.io.FileWriter(file,true);

        //3、写出的操作
        fileWriter.write("I have a dream!\n");
        fileWriter.write("You need to have a dream!\n");

        //4、流资源的关闭
        fileWriter.close();

    }
}

在这里插入图片描述

4、FileReader和FileWriter实现文本文件的复制

 //FileReader和FileWriter实现文本文件的复制
    @Test
    public void test01()  {
        FileReader fr = null;
        FileWriter fw = null;
        try{
            //1、提供File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello1.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);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4、流资源的关闭
            if(fw!=null){
                //4、流资源的关闭
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(fr!=null){
                        try {
                            fr.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

5、FileInputStream、FileOutputStream实现非文本文件的复制

  • 对于文本文件（.txt .java .c .cpp）使用字符流处理
  • 对于非文本文件（.jpg .mp3 .mp4 .avi .doc .ppt）使用字符流处理

5.1、图片的复制

public class FileInputOuputStream {
    //实现图片(非文本文件)的的复制
    @Test
    public void test01()  {
        FileInputStream fr = null;
        FileOutputStream fw = null;
        try{
            //1、提供File类的对象，指明读入和写出的文件
            File srcFile = new File("bird.png");
            File destFile = new File("bird1.png");

            //2、提供输入流和输出流的对象
            fr = new FileInputStream(srcFile);
            fw  =new FileOutputStream(destFile);

            //3、数据的读入和写出的操作
            byte[] cbuf = new byte[5];
            int len;//记录每次读入到cbuf数组中字符的个数
            while ((len = fr.read(cbuf)) != -1){
                fw.write(cbuf,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4、流资源的关闭
            if(fw!=null){
                //4、流资源的关闭
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(fr!=null){
                        try {
                            fr.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

在这里插入图片描述

5.2、视频的复制

public class FileInputOuputStream {
	public void copyFile(String srcFile,String destFile)  {
	        FileInputStream fis = null;
	        FileOutputStream fos = null;
	        try{
	            //2、提供输入流和输出流的对象
	            fis = new FileInputStream(srcFile);
	            fos  =new FileOutputStream(destFile);
	
	            //3、数据的读入和写出的操作
	            byte[] cbuf = new byte[1024];
	            int len;//记录每次读入到cbuf数组中字符的个数
	            while ((len = fis.read(cbuf)) != -1){
	                fos.write(cbuf,0,len);
	            }
	        }catch (IOException e){
	            e.printStackTrace();
	        }finally {
	            //4、流资源的关闭
	            if(fos!=null){
	                //4、流资源的关闭
	                try {
	                    fos.close();
	                } catch (IOException e) {
	                    e.printStackTrace();
	                }finally {
	                    if(fis!=null){
	                        try {
	                            fis.close();
	                        } catch (IOException e) {
	                            e.printStackTrace();
	                        }
	                    }
	                }
	            }
	        }
	    }
	
	    @Test
	    public void test(){
	        String srcFile = "C:\\Users\\Lenovo\\Desktop\\01-视频.mp3";
	        String destFile = "C:\\Users\\Lenovo\\Desktop\\02-视频.mp3";
	        long start = System.currentTimeMillis();
	        copyFile(srcFile, destFile);
	        long end = System.currentTimeMillis();
	        System.out.println("复制视频耗时：" + (end-start) );
	    }
	}

6、字节型缓冲流的使用BufferedInputStream 和BufferedOutputStream

6.1、复制文本

 public class BufferedTest {
    @Test
    public void test(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1、造文件
            File srcFile = new File("bird.png");
            File destFile = new File("bird3.png");
            //2、造流
            //2.1、造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2、造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3、复制的细节：读取，写入
            byte[] buffer = new byte[5];
            int len;
            while((len = bis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭。我们可以省略
            if(bos != null){
                //4、资源关闭
                //要求：先关闭外层的流、再关闭内层的流
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 }

6.2、复制视频

 public class BufferedTest {
  public void copyFile(String srcFile,String destFile)  {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //2、提供输入流和输出流的对象
            fis = new FileInputStream(srcFile);
            fos  =new FileOutputStream(destFile);

            //3、数据的读入和写出的操作
            byte[] cbuf = new byte[1024];
            int len;//记录每次读入到cbuf数组中字符的个数
            while ((len = fis.read(cbuf)) != -1){
                fos.write(cbuf,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4、流资源的关闭
            if(fos!=null){
                //4、流资源的关闭
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(fis!=null){
                        try {
                            fis.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

		//测试方法
    @Test
    public void test(){
        String srcFile = "C:\\Users\\Lenovo\\Desktop\\01-视频.mp3";
        String destFile = "C:\\Users\\Lenovo\\Desktop\\02-视频.mp3";
        long start = System.currentTimeMillis();
        copyFile(srcFile, destFile);
        long end = System.currentTimeMillis();
        System.out.println("复制视频耗时：" + (end-start) );
    }
 }

7、字节型缓冲流的使用BufferedReader和BufferedWriter

@Test
    public void testBufferedReaderBufferWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello.txt")));
            //读写操作
            //方式一：使用char[]数组
//            char[] cbuff = new char[5];
//            int len;
//            while((len = br.read(cbuff)) != -1){
//                bw.write(cbuff,0,len);
//            }
            //方式二：使用String[]
            String data;
            while((data=br.readLine()) !=null){
                //方法一：
                bw.write(data);//data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行操作

            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {//关闭资源
            if(bw != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
           if(br != null){
               try {
                   bw.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }

8、总结

 二、流的体系结构
 抽象基类          节点流（文件流）                                 缓冲流（处理流的一种）
 InputStream    FileInputStream (read(byte[] buffer)          BufferedInputStream (read(byte[] buffer)
 OutputStream   FileOutStream (write(byte[] buffer,0,len))    BufferedOutputStream (write(byte[] buffer,0,len))
 Reader         FileReader (read(byte[] buffer)               BufferedReader (read(byte[] buffer /readLine())
 Writer         FileWriter (write(byte[] buffer,0,len))       BufferedWriter (write(byte[] buffer,0,len))
小码哥呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java io原理FileReader_Java-IO流之BufferedReader 和BufferedWriter的使用和原理
weixin_39525097的博客
02-26 231
BufferedReader和BufferedWriter出现的目的是为了对FileReader以及FileWriter的读写操作进行增强，而怎么增强呢，原理类似于使用StringBuilder，是把数据先放入他们的一个char数组中，然后再操作char数组。使用缓冲区的字符流是使用了装饰着模式对FileReader等进行功能上的增强，装饰者模式与继承都可以实现功能上的增强，但是装饰者可以做得更加...
JAVA基础知识之FileReader流
咕噜是个胖子
07-20 3648
一、FileReader流解释     API文档说明：FileReader流是用于读取字符文件的便捷类。此类的构造函数假定默认字符编码和默认字节缓冲区大小是合适的。如果要自己指定这些值，那么需要通过FileInputStream流对象来构造InputStreamReader流对象即可     FileReader类继承InputStreamReader类 public class Fil...
IO流之FileReader和FileWriter原理研究
瘦子没有夏天
06-08 1039
FileReader和FileWriter介绍 FileReader “文件字符输入流”，一般用于读取文本形式的文件，也可以用来读取字节形式文件，但是会存在乱码问题。 FileWriter 原理分析 FileReader 构造方法 // 构造器1 // 可以看出其底层传入依然是字节流，只是依赖了InputStreamReader进行编码和解码操作 // 其余构造器...
Java文件流的原理与应用
简约不简单
03-07 576
如何判断是输入流还是输出流？ 以内存为参照物，如果数据是向内存流动是输入流，反之则是输出流 java流分为两种流 1，字节流：可以用于读写二进制文件及任何类型文件byte 2，字符流：可以用于读写文件文本 字节流：输入(InputStream) 输出(OutputStream) 字符流：输入(Reader) 输出(writer) import java.io.Fil...
BufferedReader包装FileReader按行读取文件
focus-unchanged-thing
07-18 3502
import java.io.FileReader; import java.io.IOException; import java.util.LinkedList; import java.util.ListIterator; public class UseLabel { public static void main(String[] args) throws IOException
javaSE-IO流与序列化
Antg的博客
07-03 200
文章目录一.概述1.概念2.分类3.抽象类定义二.字节流1.概述2.FileInputStream与FileOutPutStream3.BufferedInputStream与BufferedOutputStream4.字节输入流和字节缓存流的效率比较三.字符流1.概述2.FileReader和FileWriter3.BufferedReader和BufferedWriter四.转换流1.概述2.代码实现五.打印流1.概述2.代码实现六.序列化与反序列化1.概述2.代码实现七.数据流1.概述2.代码实现 一
JavaSE-IO流
apple_59745077的博客
01-22 946
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。I : Input输入 O : output输出以字节的方式进行文件中的内容的读取操作，要想读取文件需要先找到文件的位置，文件位置可以通过绝对路径或相对路径找到。绝对路径 : 绝对路径是从系统的根目录开始，一级一级指向目标文件或资源的完整路径.
Java中FileReader类的常用方法
热门推荐
scbiaosdo的博客
05-23 1万+
FileReader字符输入流构造方法public FileReader(String fileName) throws FileNotFoundException在给定从中读取数据的文件名的情况下创建一个新 FileReader。 fileName - 要从中读取数据的文件的名称 public FileReader(File file) throws FileNotFoundException在...
Java FileReader InputStreamReader类源码解析
weixin_34050005的博客
08-28 562
FileReader 前面介绍FileInputStream的时候提到过，它是从文件读取字节，如果要从文件读取字符的话可以使用FileReader。FileReader是可以便利读取字符文件的类，构造器只能使用默认的字符集编码（系统的默认字符集）、默认的bytebuffer大小8KB。如果想要自己指定这些值的话，可以直接通过FileInputStream...
枚举工具类
qq_43049583的博客
08-04 132
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 184
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 575
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 523
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 516
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
Servlet(2)
最新发布
xjdkxnhcoskxbco的博客
08-04 344
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 686
集合之Map
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 183
④创建artifact。②点击加号创建，选择。
安装ElasticSearch
diffiii
07-31 633
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值