IO流低级流

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量468 收藏
点赞数
分类专栏： Java核心技术 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuqu1028/article/details/126720862
版权

输入流输出流

按照流的流向来分 ， 可以分为输入流和输出流

  • 输出流 :以内存为基准把内存当中的数据写出到磁盘文件或网络介质中
  • 输入流 : 以内存为基准把磁盘文件或者网络中的数据读取到内存中去
字节输入流字节输出流字符输入流字符输出流
InputStreamOutputStreamReader（抽象类）Writer（抽象类）
FileInputStreamFileOutputStreamFileReader（实现类）FileWriter（实现类）

字节流字符流

  • 字节流和字符流的用法几乎完全一样，区别在于字节流和字符流所操作的数据单元不同字节流操作的数据单元是 8 位的字节，而字符流操作的数据单元是16位的字符。字节流主要由 InputStream 和 OutputStream作为基类 ， 而字符流则主要由 Reader 和 Writer作为基类。
  • 一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

InputStream输入流

/*构造方法*/
FileInputStream(File file) 
通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。  
FileInputStream(FileDescriptor fdObj) 
创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的现有连接到一个实际的文件。  
FileInputStream(String name) 
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。 
/*逐个字节读取*/
int read() 
从该输入流读取一个字节的数据，读取完毕没有数据时返回-1
/*读取字节数组*/
int read(byte[] b) 
从该输入流读取最多 b.length个字节的数据为字节数组。 
int read(byte[] b, int off, int len) 
从该输入流读取最多 len字节的数据为字节数组。 
/*关闭IO流资源*/
void close() 
关闭此文件输入流并释放与流相关联的任何系统资源。

读取数据–>按照字节

读取一个字节，返回值就是读到的数据值，如果读取的数据值等于-1，则读取到文件末尾

public static void main(String[] args) throws IOException {
        //创建文件
        File file = new File("E:\\杂七杂八\\TestFile.txt");
        //创建低级输入流FileInputStream();
        InputStream is = new FileInputStream(file);
        /*
        System.out.println((char) is.read());
        System.out.println((char) is.read());
        System.out.println((char) is.read());
        System.out.println(is.read());//读取完毕没有数据时返回-1
        */
        //使用循环读取
        int ch = 0;
        while((ch =  is.read()) != -1){
            System.out.print((char)ch+" ");
        }
    }
/*tips：
逐字节读取性能极差，几乎不用，了解即可
无论是单次读取还是循环读取，都是逐个字节读取
只能读取数字、字母等，不能读取中文字符
中文字符占3字节，强行读取会将其截断出现乱码

读取数据–>字节数组

  • 从字节输入流中读取字节到字节数组中去，返回读取的字节数量，没有字节可读返回-1
public static void main(String[] args) throws IOException {
        //创建字节输入流与文件接通
        FileInputStream fis = new FileInputStream("Hello.txt");
        //定义字节数组读取数据
        byte[] buffer = new byte[3];//1024--->1kb
        //将从fis通道中读取的字节装入buffer，返回读取的字节数量
    	/*读取第一组*/
        int leng = fis.read(buffer);
        System.out.println("读取的字节数："+leng);//3
        //将字节数组转化为String字符串
        String str = new String(buffer);
        System.out.println(str);//abc
        /*读取第二组*/
        int leng1 = fis.read(buffer);
        System.out.println("读取的字节数："+leng1);//1
    	
        String str1 = new String(buffer);
        System.out.println(str1);//9bc
        /* 读取的字节数：3
            abc
            读取的字节数：1
            9bc
            原因：
            buffer数组会将数组内的全部数据放入String字符串中，所以出现了该bug
            首先知道设置的buffer数组长度为3，第一次读取到“abc”三个字节，此时剩余一个字节”9“
            第二次读取，由于只剩余一个字节所以将其读出并放在buffer数组第一个位置
            剩余两个位置并未读取到新数据，所以依然存放的是第一次读取的数据
            所以：
            在讲buffer数组数据注入到字符串当中时，应该调用String的另一个构造器
            String(byte[] bytes, int offset, int length) 
		   通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。	
            如下所示：
        */
    	int leng1 = fis.read(buffer);
        System.out.println("读取的字节数："+leng1);//1
        String str1 = new String(buffer,0,leng1);
        System.out.println(str1);//9bc
    }

读取数据–>循环数组

public static void main(String[] args) throws IOException {
        //创建FileInputStream连通目标文件
        FileInputStream fileInputStream = new FileInputStream("Hello.txt");
        //创建字节数组
        byte[] buffer = new byte[3];
        //记录每次读取的字节数量--->防止最后一组读取不满
        int leng = 0;
        //循环读取完毕为止--->判断fileInputStream.read(buffer)是否返回-1
        while((leng = fileInputStream.read(buffer)) != -1){
            String str = new String(buffer,0,leng);
            System.out.print(str+" ");
        }
    }
  • 利用字节数组循环读取字节内容效率高，性能好
  • 但是以上的字节流操作均不适用读取字符即文本内容，单个字符为3个字节，读取时很难保证每次都在3的倍数读取到字符，一旦出现字符乱码，后边的所有内容也将会强行懵逼

解决字节流读取字符乱码问题

  • 直接将字节数组的长度设置为文件的长度，读取时直接一次性将其全部读出
  • 目标文件较小时可以利用此方法，但是过大的文件将会极其影响性能和效率
public static void main(String[] args) throws IOException {
        File file = new File("Hello.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        //创建字节数组--->长度与文件大小一致
        byte[] buffer = new byte[(int) file.length()];
        //获取读取的长度，并将字节读取到数组中
        int len = fileInputStream.read(buffer);
        System.out.println("读取字节数："+len);
        //数组内字节打成字符串输出
        String str = new String(buffer);
        System.out.println(str);
    }
/*JDK1.9之后提供了专门的API用来将数据一次性读出并装入字节数组*/
public static byte[] readAllBytes(Path path)

OutputStream输出流

  • 以内存为基准，将内存中的数据以字节的形式写出到磁盘文件中
  • IO流管道默认是数据覆盖管道，即每次创建管道时都会把之前的数据清空再写出
    • 但是利用append进行数据追加时就不会覆盖之前的数据
/*构造器*/
public FileOutputStream(File file):
//创建字节输出流管道通向文件对象
public FileOutputStream(String file)
//创建字节输出流管道通向文件路径（简化写法）
public FileOutpurStream(File file,boolean append)
//创建一个追加数据的字节输出流管道通向文件对象
public FileOutputStream(String file,boolean append)
//创建一个追加数据的字节输出流管道通向文件路径

/*常用API*/
//写一个字节出去
public void write(int a)
//写一个字节数组出去
public void write(byte[] buffer)
//写一个字节数组的的一部分出去
public void write(byte[] buffer,int pos,int len)
//pos起始索引位置，len写出字节数

写出数据

public static void main(String[] args) throws Exception {
        /*创建字节输出流与磁盘文件接通*/
        FileOutputStream fos = new FileOutputStream("Hello.txt");
        /*写字节数据出去到文件*/
        fos.write(97);//a
        fos.write('b');//b
        fos.write('Q');
        fos.write('Q');
        /*写字节数组出去到文件*/
        byte[] bytes = new byte[]{97,98,99,100,101,102};
        fos.write(bytes);
        /*将字符串打成字节数组并写出到文件*/
        byte[] arrs = "\nJava是世界上最美的语言".getBytes();
        //默认以当前代码编码集UTF-8编码
        //也可以利用getBytes()设置编码集
        //byte[] arrs = "\nJava是世界上最美的语言".getBytes("GBK");
        fos.write(arrs);
        /*写字节数组的一部分出去*/
        byte[] arr = "\nJava是世界上最美的语言".getBytes();
        fos.write(arr,0,8);//---->Java是
        //换行符/n的兼容性较差，可以使用\r\n作为换行符
        System.out.println("\r\n".length());
        //\r\n占据两个字节
        fos.flush();//刷新缓存，确保数据加载到文件中    刷新之后管道可以继续使用
        fos.close();//关闭IO资源
    }

append追加数据写出

public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("Hello.txt",true);
        //append:true--->第二次运行添加的数据不会覆盖第一次的数据，不会出现层叠
        byte[] bytes = "我爱Java\r\n".getBytes();
        fos.write(bytes);
        fos.flush();
        fos.close();
    }

字节流实现文件复制

  • 利用字节输入流FileInputStream将源文件与内存连通，将数据读取到内存当中。
  • 再利用FileOutputStream将内存与目标文件连通，将先前读取到内存当中的数据写出到目标文件
public static void main(String[] args){
        /*  Hello.txt----->Nice.txt  */
        //后续关闭IO流资源需要再finally中，所以需要将IO流在try-catch外部定义为空
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            /*创建字节输入流将源文件与内存接通*/
            fis = new FileInputStream("E:\\杂七杂八\\TestFile.txt");
            /*创建字节输出流将内存与目标文件接通*/
            fos = new FileOutputStream("E:\\Thinking\\Copy.txt");
            /*创建字节数组接收读取到内存的数据*/
            byte[] buffer = new byte[32];
            int len = -1;
            /*循环读取源文件数据直到读取完毕*/
            while ((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
            System.out.println("复制完成标志！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭IO资源前先进行非空校验
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

FileReader输入流

  • 以内存为基准，将源文件的字符逐个读取到内存中去
/*构造器*/
public FileReader(File file)
//创建一个字符输入流与源文件对象接通
public FileRReader(String filePath)
//创建一个字符输入流通向源文件路径
/*常用API*/
public int read()
//读取一个字符的编号返回，读取完毕返回-1
public int read(char[] buffer)
//读取一个字符数组，读取到多少个字符就返回多少个数量

FileReader读取数据

public static void main(String[] args) throws IOException {
        FileReader fr = null;
            //创建字符输入流连通内存和源文件
            fr = new FileReader("Hello.txt");
            /*逐个字符读取
            System.out.println((char) fr.read());
            */
            //字符数组读取
            char[] buffer = new char[10];
            int len;
            while((len = fr.read(buffer)) != -1){
                String str = new String(buffer,0,len);
                System.out.println(str);
            }
    }

FileWriter输出流

  • 构造器及常用API
/*构造器*/
public FileWriter(File file)
public FileWriter(String filePath)
public FileWriter(File file,boolean append)
public FileWriter(String filePath,boolean append)
/*常用API*/
public void write(int c)
public void write(String c)
public void write(char[] buffer)
public void write(String str, int off, int len)

FileWriter写出字符数据

public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("Hello.txt");
        char[] buffer = "你好，你好不好，你不好我好".toCharArray();
        fw.write(buffer);
        fw.flush();
        fw.close();
    }

字符流实现文件复制

public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("Hello.txt");
            fw = new FileWriter("Nice.txt");
            char[] buffer = new char[10];
            int len = -1;
            while((len = fr.read(buffer)) != -1){
                fw.write(buffer,0,len);
            }
            System.out.println("复制完成标志...");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fw != null) {
                try {
                    fw.flush();
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

拓展API

  • 在String类下有两个API用于操作字符串
/* 1. 通过getBytes() 将字符串打成字节数组*/
byte[] arrs = "\nJava是世界上最美的语言".getBytes();
/* 2. 通过toCharArray() 将字符串打成字符数组*/
char[] buffer = "你好，你好不好，你不好我好".toCharArray();
绿仔牛奶_
关注
专栏目录
Java 常见的 IO流
流楚丶格念的博客
11-04 1280
其中，节点流可以直接从/向一个特定的IO设备读/写数据，也称为低级流。流是Java对不同输入源输出源的抽象，代表了从起源到接收的有序数据，有了它程序就可以采用统一的方式来访问不同的输入源和输出源了。java.io.OutputStreamWriter （字符字节输出流，将字节输出流转换为字符输出流）java.io.InputStreamReader （字符字节输入流，将字节输入流转换为字符输入流）其中，字节流操作的数据单元是byte（字节），而字符流操作的数据单元是char（16位的字符）。
java中的io流开发用的多吗_JAVA基础之IO流知识总结（够详细了吗
weixin_28796657的博客
02-23 1619
欢迎关注CSDN：程序员小羊微信公众号：程序员小羊博客园：程序员小羊一、IO流体系图IO常用的几个流：【I/O流原理作用】Input/Output：输入输出机制输入机制：允许java程序获取外部设备的数据(磁盘，光盘，网络等)。输出机制：保留java程序中的数据，输出到外部设备上(磁盘，光盘等)。二、流的分类：通过不同的方法，可以对于进行分类。1. 按照功能来划分：输入流：只能从中读取数据，而不能...
Java零基础学习021-API进阶第二天
u013488276的博客
04-28 930
IO流（FileInputStream和FileOutputStream）
javaIO流总结
JamesLi6的博客
07-24 559
一、  流的分类   •   按数据流动方向   – 输入流：只能从中读取字节数据，而不能向其写出数据   – 输出流：只能向其写入字节数据，而不能从中读取数据   •   按照流所处理的数据类型   – 字节流：用于处理字节数据。   – 字符流：用于处理Unicode字符数据。   •   按照流所处理的源   – 节点流:从/向一个特定的IO设备读/写数据的流
Java I/O流详解
沐雨橙风ιε的博客
09-24 828
Java I/O流详解
IO流原理及流的分类
qq_45621766的博客
09-15 345
IO流原理 I/O 是input/output 的缩写。用于处理设备之间的数据传输。 in --> 输入，out -->输出 java 将IO 必须为“流”，即Stream .只支持单向顺序流动，这里的流动是二进制数据，我们可以理解他们是连接程序于另一端口的管道.用于获取和发送数据到另一端。 ...
Java中流-----个人总结心得
weixin_30765505的博客
07-24 115
流 字符流 字节流 缓冲区 数据流---用于传输数据。IO流---Input/Output流。数据从外部流向程序---输入流；数据从程序流向外部的时候--输出流。读取一个文件---数据从文件流向程序---输入流；向一个文件中写入数据---数据从程序流向文件---输出流 根据数据流动的方向：输入流/输出流 根据数据传输的形式：字节流/字符流 ...
IO流的低级流与高级流之分
if you want to fly,you need to walk step by step
03-01 6325
http://blog.csdn.net/panxueji/article/details/9949841 来源（来源不明-转载请标明此链接）一、IO流的三种分类方式：1.按照流向来分：输入流：只能从中读取字节数据，不能向其写出数据输出流：只能向其写入字节数据，不能从中读取数据2.按照流所处理的数据类型划分：可分为：字节流：用于处理字节数据。字符流：用于处理Unicode字符数据。3.按照格式可以...
IO流的主要流
07-12
它们是低级流，直接与文件系统交互，效率相对较低。 - **字节缓冲流**：BufferedInputStream和BufferedOutputStream属于高效流，通过内部缓冲区提高读写效率，降低了频繁磁盘操作的开销。 2. **字符流** - **字符...
java IO流详解
11-14
- **按处理效率**：分为节点流（低级流）和包装流（高级流）。 - 节点流：直接与设备交互，效率较低。 - 包装流：对节点流进行封装，提高读写效率，例如缓冲流。 #### 二、InputStream/OutputStream - **...
什么是IO流？怎样区分不同种类的IO流？
Aa112233aA1的博客
12-15 3703
I/O（Input/Output）流，即输入/输出流，是Java中实现输入/输出的基础，它可以方便地实现数据的输入/输出操作。 I/O流有很多种，按照不同的分类方式，可以分为以下三类： 1．字节流和字符流 根据流操作的数据单位的不同，可以分为字节流和字符流。字节流以字节为单位进行数据的读写，每次读写一个或多个字节数据；字符流以字符为单位进行数据的读写，每次读写一个或者多个字符数据。 2．输入流和输出流 根据流传输方向的不同，又可分为输入流和输出流。其中输入流只能从流中读取数据，而不能向其写入数据；输出流只能
Java循环写txt出现信息丢失的问题
Chance00的博客
03-05 1004
java中经常用到循环写入内容到文件的操作，但是当行数过多的时候，会出现后面的内容缺失。 解决：使用一定次数的write方法可以调用BufferedWriter.flush方法，该方法可以清除缓存，腾出空间。这样就不会出现缺失的问题了。 ...
IO操作——文件流（低级流，字节流）
linsa_pursuer的博客
09-29 557
  1.FIS——>FileInputStream 输入流——>读取数据   String str = new String(byte[] data,0,len,"utf-8");   package day04_; import java.io.FileInputStream; import java.io.IOException; /** * java.io.Fi...
Java IO流知识总结
暴风君的博客
04-02 3528
Java IO的一般使用原则： 一、按数据来源（去向）分类： 1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter 2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream 3、是Char[]: CharArrayReader, CharArrayWriter 4
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 914
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 440
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 835
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
java将word转pdf
紫月7575的博客
09-30 527
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 546
spring boot 整合 mybatis
Java IO流详解：分类与高级流应用
IO流在Java编程中扮演着核心角色，它是数据传输的基础机制，用于在程序和各种设备之间进行数据交换。Java的Input/Output（IO）流主要分为两大类：字节流和字符流。 首先，让我们从基本概念开始。Java的IO流主要集中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

绿仔牛奶_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值