编程技术是改变世界的力量。
本站
当前位置:网站首页 > 后端语言 > 正文

Java IO详解那点事 java io使用

gowuye 2024-04-04 11:53 10 浏览 0 评论

0x01:字节流


字节流基类

1. InputStream

InputStream:字节输入流基类,抽象类是表示字节输入流的所有类的超类。

 常用方法:
  1. // 从输入流中读取数据的下一个字节
  2. abstract int read()
  3. // 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b中
  4. int read(byte[] b)
  5. // 将输入流中最多 len 个数据字节读入 byte 数组
  6. int read(byte[] b, int off, int len)


  7. // 跳过和丢弃此输入流中数据的 n个字节
  8. long skip(long n)

  9. // 关闭此输入流并释放与该流关联的所有系统资源
  10. void close()
    

2. OutputStream

OutputStream:字节输出流基类,抽象类是表示输出字节流的所有类的超类。

 常用方法:
    
  1. // 将 b.length 个字节从指定的 byte 数组写入此输出流
  2. void write(byte[] b)
  3. // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
  4. void write(byte[] b, int off, int len)
  5. // 将指定的字节写入此输出流
  6. abstract void write(int b)

  7. // 关闭此输出流并释放与此流有关的所有系统资源
  8. void close()

  9. // 刷新此输出流并强制写出所有缓冲的输出字节
  10. void flush()

字节文件操作流

1. FileInputStream

FileInputStream:字节文件输入流,从文件系统中的某个文件中获得输入字节,用于读取诸如图像数据之类的原始字节流。

 构造方法:
    // 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的File对象file指定
    FileInputStream(File file)
    // 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的路径name指定
    FileInputStream(String name)
 常用方法:覆盖和重写了父类的的常用方法。        // 读取f盘下该文件f://hell/test.txt        //构造方法1        InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));        int i = 0;        //一次读取一个字节        while ((i = inputStream.read()) != -1) {            // System.out.print(i + " ");// 65 66 67 68            //为什么会输出65 66 67 68?因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。            System.out.print((char) i + " ");// A B C D        }        //关闭IO流        inputStream.close();         // 读取f盘下该文件f://hell/test.txt        //构造方法2        InputStream inputStream2 = new FileInputStream("f://hello/test.txt");        // 字节数组        byte[] b = new byte[2];        int i2 = 0;        //  一次读取一个字节数组        while ((i2 = inputStream2.read(b)) != -1) {            System.out.print(new String(b, 0, i2) + " ");// AB CD        }        //关闭IO流        inputStream2.close();

注: 一次读取一个字节数组,提高了操作效率,IO流使用完毕一定要关闭。

2. FileOutputStream

FileOutputStream:字节文件输出流是用于将数据写入到File,从程序中写入到其他位置。

 构造方法:
    
  1. // 创建一个向指定File对象表示的文件中写入数据的文件输出流
  2. FileOutputStream(File file)
  3. // 创建一个向指定File对象表示的文件中写入数据的文件输出流
  4. FileOutputStream(File file, boolean append)
  5. // 创建一个向具有指定名称的文件中写入数据的输出文件流
  6. FileOutputStream(String name)
  7. // 创建一个向具有指定name的文件中写入数据的输出文件流
  8. FileOutputStream(String name, boolean append)
 常用方法:覆盖和重写了父类的的常用方法。        OutputStream outputStream = new FileOutputStream(new File("test.txt"));        // 写出数据        outputStream.write("ABCD".getBytes());        // 关闭IO流        outputStream.close();        // 内容追加写入        OutputStream outputStream2 = new FileOutputStream("test.txt", true);        // 输出换行符        outputStream2.write("\r\n".getBytes());        // 输出追加内容        outputStream2.write("hello".getBytes());        // 关闭IO流        outputStream2.close();

注;输出的目的地文件不存在,则会自动创建,不指定盘符的话,默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。


字节缓冲流(高效流)

1. BufferedInputStream

BufferedInputStream:字节缓冲输入流,提高了读取效率。

     构造方法:
     // 创建一个 BufferedInputStream并保存其参数,即输入流in,以便将来使用。
     BufferedInputStream(InputStream in)
     // 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数,即输入流in以便将来使用     BufferedInputStream(InputStream in, int size)        InputStream in = new FileInputStream("test.txt");        // 字节缓存流        BufferedInputStream bis = new BufferedInputStream(in);        byte[] bs = new byte[20];        int len = 0;        while ((len = bis.read(bs)) != -1) {            System.out.print(new String(bs, 0, len));            // ABCD            // hello        }        // 关闭流        bis.close();

2. BufferedOutputStream

BufferedOutputStream:字节缓冲输出流,提高了写出效率。

     构造方法:
     
  1. // 创建一个新的缓冲输出流,以将数据写入指定的底层输出流
  2. BufferedOutputStream(OutputStream out)
  3. // 创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流
  4. BufferedOutputStream(OutputStream out, int size)

  5. 常用方法:
  6. // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
  7. void write(byte[] b, int off, int len)
  8. // 将指定的字节写入此缓冲的输出流
  9. void write(int b)
  10. // 刷新此缓冲的输出流
  11. void flush()
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));        // 输出换行符        bos.write("\r\n".getBytes());        // 输出内容        bos.write("Hello Android".getBytes());        // 刷新此缓冲的输出流        bos.flush();        // 关闭流        bos.close();

0x02:字符流


字符流基类

1. Reader

Reader:读取字符流的抽象类.

  常用方法:
    
  1. // 读取单个字符
  2. int read()
  3. // 将字符读入数组
  4. int read(char[] cbuf)
  5. // 将字符读入数组的某一部分
  6. abstract int read(char[] cbuf, int off, int len)
  7. // 跳过字符
  8. long skip(long n)

  9. // 关闭该流并释放与之关联的所有资源
  10. abstract void close()

2. Writer

Writer:写入字符流的抽象类.

 常用方法:
  1. // 写入字符数组
  2. void write(char[] cbuf)
  3. // 写入字符数组的某一部分
  4. abstract void write(char[] cbuf, int off, int len)
  5. // 写入单个字符
  6. void write(int c)
  7. // 写入字符串
  8. void write(String str)
  9. // 写入字符串的某一部分
  10. void write(String str, int off, int len)

  11. // 将指定字符添加到此 writer
  12. Writer append(char c)
  13. // 将指定字符序列添加到此 writer
  14. Writer append(CharSequence csq)
  15. // 将指定字符序列的子序列添加到此 writer.Appendable
  16. Writer append(CharSequence csq, int start, int end)

  17. // 关闭此流,但要先刷新它
  18. abstract void close()
  19. // 刷新该流的缓冲
  20. abstract void flush()

字符转换流

1. InputStreamReader

InputStreamReader:字节流转字符流,它使用的字符集可以由名称指定或显式给定,否则将接受平台默认的字符集。

 构造方法:
  1. // 创建一个使用默认字符集的 InputStreamReader
  2. InputStreamReader(InputStream in)
  3. // 创建使用给定字符集的 InputStreamReader
  4. InputStreamReader(InputStream in, Charset cs)
  5. // 创建使用给定字符集解码器的 InputStreamReader
  6. InputStreamReader(InputStream in, CharsetDecoder dec)
  7. // 创建使用指定字符集的 InputStreamReader
  8. InputStreamReader(InputStream in, String charsetName)
 特有方法:
       //返回此流使用的字符编码的名称    String getEncoding()        //使用默认编码        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));        int len;        while ((len = reader.read()) != -1) {            System.out.print((char) len);//爱生活,爱Android        }        reader.close();         //指定编码        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");        int len;        while ((len = reader.read()) != -1) {            System.out.print((char) len);//????????Android        }        reader.close();注:Eclipse默认使用GBK编码,test.txt文件所以是GBK编码,当指定utf-8编码时所以会乱码。


2. OutputStreamWriter

OutputStreamWriter:字节流转字符流。

 构造方法:
    
  1. // 创建使用默认字符编码的 OutputStreamWriter
  2. OutputStreamWriter(OutputStream out)
  3. // 创建使用给定字符集的 OutputStreamWriter
  4. OutputStreamWriter(OutputStream out, Charset cs)
  5. // 创建使用给定字符集编码器的 OutputStreamWriter
  6. OutputStreamWriter(OutputStream out, CharsetEncoder enc)
  7. // 创建使用指定字符集的 OutputStreamWriter
  8. OutputStreamWriter(OutputStream out, String charsetName)
  9. 特有方法:
  10. //返回此流使用的字符编码的名称
  11. String getEncoding()

字符缓冲流(高效流)

1. BufferedReader

BufferedReader:字符缓冲流,从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

 构造方法:
  1. // 创建一个使用默认大小输入缓冲区的缓冲字符输入流
  2. BufferedReader(Reader in)
  3. // 创建一个使用指定大小输入缓冲区的缓冲字符输入流
  4. BufferedReader(Reader in, int sz)
 特有方法:
    // 读取一个文本行    String readLine()    //生成字符缓冲流对象        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));        String str;        //一次性读取一行        while ((str = reader.readLine()) != null) {            System.out.println(str);// 爱生活,爱Android        }        //关闭流        reader.close();
2. BufferedWriter

BufferedWriter:字符缓冲流,将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

 构造方法:
  1. // 创建一个使用默认大小输出缓冲区的缓冲字符输出流
  2. BufferedWriter(Writer out)
  3. // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
  4. BufferedWriter(Writer out, int sz)
  5. 特有方法:
  6. // 写入一个行分隔符
  7. void newLine()

FileReader、FileWriter

 FileReader:InputStreamReader类的直接子类,用来读取字符文件的便捷类,使用默认字符编码。
 FileWriter:OutputStreamWriter类的直接子类,用来写入字符文件的便捷类,使用默认字符编码。

0x03: 高效流效率比对

读取f盘下的一个视频文件到项目中:文件大小29.5 MB

读取方式一:

  1. FileInputStream inputStream = new FileInputStream("d://苍井空那点事.mp4");
  2. FileOutputStream outputStream = new FileOutputStream("苍井空那点事.mp4");
  3. int len;
  4. // 开始时间
  5. long begin = System.currentTimeMillis();
  6. // 一次读取一个字节
  7. while ((len = inputStream.read()) != -1) {
  8. outputStream.write(len);
  9. }
  10. // 用时毫秒
  11. System.out.println(System.currentTimeMillis() - begin);// 213195
  12. //关闭流释放资源
  13. inputStream.close();
  14. outputStream.close();

读取方式二:

  1. FileInputStream inputStream = new FileInputStream("d://苍井空那点事.mp4");
  2. FileOutputStream outputStream = new FileOutputStream("苍井空那点事.mp4");
  3. int len;
  4. byte[] bs = new byte[1024];
  5. // 开始时间
  6. long begin = System.currentTimeMillis();
  7. // 一次读取一个字节数组
  8. while ((len = inputStream.read(bs)) != -1) {
  9. outputStream.write(bs, 0, len);
  10. }
  11. // 用时毫秒
  12. System.out.println(System.currentTimeMillis() - begin);// 281

  13. inputStream.close();
  14. outputStream.close();

读取方式三:

  1. FileInputStream inputStream = new FileInputStream("d://苍井空那点事.mp4");
  2. BufferedInputStream bis = new BufferedInputStream(inputStream);
  3. FileOutputStream outputStream = new FileOutputStream("苍井空那点.mp4");
  4. BufferedOutputStream bos = new BufferedOutputStream(outputStream);
  5. int len;
  6. byte[] bs = new byte[1024];
  7. // 开始时间
  8. long begin = System.currentTimeMillis();
  9. while ((len = bis.read(bs)) != -1) {
  10. bos.write(bs, 0, len);
  11. }
  12. // 用时毫秒
  13. System.out.println(System.currentTimeMillis() - begin);// 78

  14. bis.close();
  15. bos.close();


注:由此可以看出高效缓冲流读写速度是非常快的,建议使用。

来源:https://www.cnblogs.com/shuaiguoguo/p/8883862.html

相关推荐

爱上开源之golang入门至实战第四章-切片(Slice)

前言Go数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的,可以追加元素,在追加时可...

Go语言入门必知教程-切片

切片是一种灵活的和可扩展的数据结构,用于实现和管理数据集。切片由多个元素组成,所有元素都是相同类型的。切片是动态数组的一部分,可以根据需要进行增长和收缩。与数组一样,切片也可以索引。切片具有容量和长度...

Go语言基础-切片

切片是什么?切片是Go语言的一种数据结构。和数组相似,不过切片可以在它的结尾增加更多的元素。这样可变长度在实际编程中更为有用。声明切片切片的声明和数组也很相似,只是声明切片时不需要指定大小。例:va...

5分钟掌握GO中切片的基本使用方法

最近Golang越来越火,不少小伙伴都纷纷开始学习Golang,但对于原先为C++或者JAVA的同学,用习惯了数据、list、vector等,会对Go的切片slice不习惯,下面整理出go中slice...

揭秘 Go 切片(Slice)的秘密

当向切片添加新参数时,底层数组会发生什么变化?它会扩展以容纳更多元素吗?在这篇文章中,我们将深入探讨切片的内部工作原理,以及如何利用这些知识来进行更好的内存管理和性能优化。具体而言,我们将探索Go...

【Go语言slice详解】深入掌握Go语言中的slice类型及常用操作!

Go语言中的slice(切片)是一种非常方便的数据结构,可以动态地增加或减少其元素数量,且可以访问底层数组的任意一个子序列。本文将对Go语言中的slice进行详细的讲解。Slice的定义在Go语言中,...

掌握GO中的Slice,这就够了

最近Golang越来越火,不少小伙伴都纷纷开始学习Golang,但对于原先为C++或者JAVA的同学,用习惯了数据、list、vector等,会对Go的切片slice不习惯,下面整理出go中slice...

golang2021面向对象(26)Go语言类型内嵌和结构体内嵌

结构体可以包含一个或多个匿名(或内嵌)字段,即这些字段没有显式的名字,只有字段的类型是必须的,此时类型也就是字段的名字。匿名字段本身可以是一个结构体类型,即结构体可以包含内嵌结构体。?可以粗略地将这个...

2022-11-13:以下go语言代码中,如何获取结构体列表以及结构体内

2022-11-13:以下go语言代码中,如何获取结构体列表以及结构体内的指针方法列表?以下代码应该返回{"S1":["M1","M2"],"S...

Go语言文件和目录操作

文件和目录操作概述一、文件和目录操作概述在计算机中,文件和目录是存储数据的重要方式。在Go语言中,我们可以使用os和io/ioutil包提供的函数和结构体来进行文件和目录操作。本文将详细介绍Go语言中...

跟我一起学习go语言(五)golang中结构体的初始化方法

1、自定义一个结构体typeVertexstruct{X,Yfloat64}2、初始化方法-指针:rect1:=new(Vertex)rect2:=&Vertex...

Go复合数据类型:结构体

一种通用的、对实体对象进行聚合抽象的能力,在Go中,提供这种聚合抽象能力的类型是结构体类型,也就是struct。自定义一个新类型在Go中,我们自定义一个新类型一般有两种方法。第一种是类型定义...

Go语言基础:方法

导读在阅读本文章前,假定你具备如下能力:?已掌握结构体1.方法1.1方法的概念在理解程序中方法的概念时,我们先看看现实中的一些情况,这样相对比较好理解一些。在农村的朋友可能会知道,在医疗落后的情况...

为什么 Go 语言 struct 要使用 tags

在Go语言中,struct是一种常见的数据类型,它可以用来表示复杂的数据结构。在struct中,我们可以定义多个字段,每个字段可以有不同的类型和名称。除了这些基本信息之外,Go还提供了s...

一文带你掌握掌握 Golang结构体与方法

1.Golang结构体的概念及定义结构体是Golang中一种复合类型,它是由一组具有相同或不同类型的数据字段组成的数据结构。结构体是一种用户自定义类型,它可以被用来封装多个字段,从而实现数据的...

取消回复欢迎 发表评论: