Java IO流详解

最新推荐文章于 2025-05-18 18:22:42 发布
原创 最新推荐文章于 2025-05-18 18:22:42 发布 · 221 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

File对象可以表示存在的文件或文件夹，也可以表示不存在的。

我们想要得到文件的内容怎么办，File只是操作文件，文件的内容如何处理就需要使用io流技术了。

例如在C盘下有一个名称为a.txt的文本文件.想要通过Java程序读出来文件中的内容,需要使用IO流技术.同样想要将程序中的数据,保存到硬盘的文件中,也需要IO流技术.

读和写文件文件示例:

public class IoTest {
	public static void main(String[] args) throws FileNotFoundException,
			IOException {
		writFileTest();
 
		readFileTest();
	}
 
	private static void writFileTest() throws FileNotFoundException,
			IOException {
		// 创建文件对象
		File file = new File("c:\\a.txt");
		// 创建文件输出流
		FileOutputStream fos = new FileOutputStream(file);
		fos.write('g');
		fos.write('z');
		fos.write('i');
		fos.write('t');
		fos.write('c');
		fos.write('a');
		fos.write('s');
		fos.write('t');
		fos.close();
	}
 
	private static void readFileTest() throws FileNotFoundException,
			IOException {
		// 创建文件对象
		File file = new File("c:\\a.txt");
		// 创建文件输入流
		FileInputStream fis = new FileInputStream(file);
		// 有对多长，就读多少字节。
		for (int i = 0; i < file.length(); i++) {
			System.out.print((char) fis.read());
		}
		fis.close();
	}

当完成流的读写时,应该通过调用close方法来关闭它,这个方法会释放掉十分有限的操作系统资源.如果一个应用程序打开了过多的流而没有关闭它们,那么系统资源将被耗尽.

1.IO流简介：（Input/Output）

I/O类库中使用“流”这个抽象概念。Java对设备中数据的操作是通过流的方式。

表示任何有能力产出数据的数据源对象，或者是有能力接受数据的接收端对象。“流”屏蔽了实际的I/O设备中处理数据的细节。IO流用来处理设备之间的数据传输。设备是指硬盘、内存、键盘录入、网络等。

Java用于操作流的对象都在IO包中。IO流技术主要用来处理设备之间的数据传输。

由于Java用于操作流的对象都在IO包中。所以使用IO流需要导包如：import java.io.*;

2.IO流的分类：

流按操作数据类型的不同分为两种：字节流与字符流。

流按流向分为：输入流，输出流（以程序为参照物，输入到程序，或是从程序输出），如图：

在这里插入图片描述

3.字节流

（1）字节流基类

1）InputStream

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

常用方法：

    // 从输入流中读取数据的下一个字节
    abstract int read()
    // 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
    int read(byte[] b)
    // 将输入流中最多 len 个数据字节读入 byte 数组
    int read(byte[] b, int off, int len)
    // 跳过和丢弃此输入流中数据的 n个字节
    long skip(long n)
    // 关闭此输入流并释放与该流关联的所有系统资源
    void close()
    ```
2）OutputStream
OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。


常用方法：

// 将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输出流
abstract void write(int b)
// 关闭此输出流并释放与此流有关的所有系统资源
void close()
// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()
```

（2）字节文件操作流
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，从程序中写入到其他位置。

构造方法：

   // 创建一个向指定File对象表示的文件中写入数据的文件输出流
   FileOutputStream(File file)
   // 创建一个向指定File对象表示的文件中写入数据的文件输出流
   FileOutputStream(File file, boolean append)
   // 创建一个向具有指定名称的文件中写入数据的输出文件流
   FileOutputStream(String name)
   // 创建一个向具有指定name的文件中写入数据的输出文件流
   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,因为不同文本编辑器对换行符的识别存在差异性。

（3）字节缓冲流

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：字节缓冲输出流，提高了写出效率。

构造方法：

    // 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
    BufferedOutputStream(OutputStream out)
    // 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
    BufferedOutputStream(OutputStream out, int size)
    常用方法：
    // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
    void write(byte[] b, int off, int len)
    // 将指定的字节写入此缓冲的输出流
    void write(int b)
    // 刷新此缓冲的输出流
    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();
       ```
4.字符流
（1）字符流基类

1）Reader

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

常用方法：

// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 跳过字符
long skip(long n)
// 关闭该流并释放与之关联的所有资源
abstract void close()
```

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

常用方法：

    // 写入字符数组
     void write(char[] cbuf)
    // 写入字符数组的某一部分
    abstract void write(char[] cbuf, int off, int len)
    // 写入单个字符
    void write(int c)
    // 写入字符串
    void write(String str)
    // 写入字符串的某一部分
    void write(String str, int off, int len)
    // 将指定字符添加到此 writer
    Writer append(char c)
    // 将指定字符序列添加到此 writer
    Writer append(CharSequence csq)
    // 将指定字符序列的子序列添加到此 writer.Appendable
    Writer append(CharSequence csq, int start, int end)
    // 关闭此流，但要先刷新它
    abstract void close()
    // 刷新该流的缓冲
    abstract void flush()
    ```
（2）字符转换流
1）InputStreamReader

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

 构造方法：

// 创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
// 创建使用给定字符集的 InputStreamReader
InputStreamReader(InputStream in, Charset cs)
// 创建使用给定字符集解码器的 InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
// 创建使用指定字符集的 InputStreamReader
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：字节流转字符流。

构造方法：

   // 创建使用默认字符编码的 OutputStreamWriter
   OutputStreamWriter(OutputStream out)
   // 创建使用给定字符集的 OutputStreamWriter
   OutputStreamWriter(OutputStream out, Charset cs)
   // 创建使用给定字符集编码器的 OutputStreamWriter
   OutputStreamWriter(OutputStream out, CharsetEncoder enc)
   // 创建使用指定字符集的 OutputStreamWriter
   OutputStreamWriter(OutputStream out, String charsetName)
特有方法：
   //返回此流使用的字符编码的名称 
   String getEncoding() 
   ```
（3）字符缓冲流（高效流）
1）BufferedReader

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

构造方法：

// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
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：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

构造方法：

   // 创建一个使用默认大小输出缓冲区的缓冲字符输出流
   BufferedWriter(Writer out)
   // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
   BufferedWriter(Writer out, int sz)
特有方法：
   // 写入一个行分隔符
   void newLine() 
   ```
（4）FileReader、FileWriter
FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码
5.高效流效率比对
读取f盘下的一个视频文件到项目中：文件大小29.5 MB
读取方式一：

   FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
    FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
    int len;
    // 开始时间
    long begin = System.currentTimeMillis();
    // 一次读取一个字节
    while ((len = inputStream.read()) != -1) {
        outputStream.write(len);
    }
    // 用时毫秒
    System.out.println(System.currentTimeMillis() - begin);// 213195
    //关闭流释放资源
    inputStream.close();
    outputStream.close();
    ```

读取方式二：

       FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节数组
        while ((len = inputStream.read(bs)) != -1) {
            outputStream.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 281
        inputStream.close();
        outputStream.close();
        ```
读取方式三：

    FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
    BufferedInputStream bis = new BufferedInputStream(inputStream);
    FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
    BufferedOutputStream bos = new BufferedOutputStream(outputStream);
    int len;
    byte[] bs = new byte[1024];
    // 开始时间
    long begin = System.currentTimeMillis();
    while ((len = bis.read(bs)) != -1) {
        bos.write(bs, 0, len);
    }
    // 用时毫秒
    System.out.println(System.currentTimeMillis() - begin);// 78
    bis.close();
    bos.close();
    ```

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

作者：飘走的我
来源：优快云
原文：https://blog.youkuaiyun.com/qq_33642117/article/details/52074796

Java中的IO流
学习java的小学僧的博客
02-03 379
Java中的IO流
java中的IO流
08-16 637
Java IO
Java IO流（超详细！！！）
最新发布
m0_73494933的博客
05-18 1704
本文介绍了Java IO流的基本概念和操作，重点讲解了文件创建、目录操作以及字节流的使用。首先，通过File类可以创建文件对象，并使用createNewFile()方法创建新文件。常用的文件操作方法包括获取文件名、绝对路径、父目录等。目录操作可以通过mkdir和mkdirs创建单级或多级目录，delete用于删除文件或空目录。接着，文章详细介绍了IO流的原理，分为输入流和输出流，以及字节流和字符流。字节流的核心类是InputStream和OutputStream，分别用于读取和写入字节数据。通过示例代码展示
Java——泛型和Io流
qq_55682798的博客
04-19 860
目录 1.泛型 2.File对象 3.IO流 1泛型 1.1什么是泛型 1. 泛型就是限制我们得数据类型。 2.为什么使用泛型? 我们原来在定义集合时，是如下得定义方式： List list=new ArrayList();//该集合没有使用泛型 list.add("java01"); list.add("java02"); String str= (String) list.get(0);//获取元素 需要进行强制类型转换
java IO流详解
11-14
### Java IO流详解 #### 一、流的概述与分类 在Java中，流是一种抽象概念，用于描述数据从一个地方传输到另一个地方的过程。它主要用于处理数据输入和输出，例如从磁盘读取文件、向网络发送数据或从键盘接收用户...
JavaIO流详解归纳.pdf
10-30
JavaIO流详解归纳 Java 的核心库 java.io 提供了全面的 IO 接口，包括文件读写、标准设备输出等。Java 中 IO 是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。在项目开发中，IO 是非常...
JavaIO流详解
03-31
### Java IO流详解 #### 一、流的概念 在探讨Java IO流之前，我们需要先理解“流”的概念。流的概念最初来源于UNIX系统中的管道（pipe）机制。在UNIX环境中，管道是一种特殊的通信机制，用于连接两个进程之间的...
java之IO流中InputStream和OutputStream
qq_45577911的博客
10-28 382
IO流中的IO是Input 和 Output的简写，是用来处理设备与设备之间的数据传输的，它又分为了输入流和输出流。 （1）输入流：从外部流入数据，比如读取文件 （2）输出流：从内部流出数据，比如输出文件内容 以上的是按流向来分，另外，还可以按照操作数据来分：字节流和字符流。 字节（byte，简称B）是计算机中存储数据的单元，它是一个8位的二进制数，是一个很具体的存储空间。一般的，一个标准英文字母占一个字节的位置。1KB=1024B。 而字符流就是由字符组成的。 IO流结构图： InputStream的常
java中的io流
热门推荐
m0_66689823的博客
07-19 1万+
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
Java IO流详解：从入门到精通
"本文详细介绍了Java.IO流的概念，包括其应用、分类、常用类以及在面试中的常见问题。Java.IO流是Java核心库的重要组成部分，用于处理输入和输出操作，如文件读写和标准设备输出。Java.IO流基于流式处理，数据被串行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值