Java-IO流（IO流原理和流的分类）

已于 2023-03-20 19:40:23 修改
阅读量517 收藏
点赞数
文章标签： java 学习 开发语言
于 2022-09-16 00:52:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ego_ekko/article/details/126873327
版权

Java IO流原理

1）I/O是input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等；

2）Java程序中，对于数据的输入和输出操作以“流（stream）”的方式进行；

3）java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据；

4）输入（input）：读取外部数据（磁盘、光盘等存储设备的数据到程序（内存）中）；

5）输出（output）：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

1）按照操作数据单位不同分为：字节流（8bit），字符流（按字符）（分别按照字符和字节进行读取，如果从操作单位方面看字符流操作效率较高，但是操作二进制文件时字节流不会出现错误，字节流操作文本文件比较好）；

2）按数据流的流向不同分为：输入流和输出流；

3）按流的角色不同分为：节点流，处理流（包装流）；

（抽象基类）字节流字符流
输入流

字节输入流的顶级父类

InputStream

字符输入流的顶级父类

Reader

输出流

字节输出流的顶级父类

OutputStream

字符输出流的顶级父类

Writer

★Java的IO流共涉及40多个类，都是从如上4个抽象基类派生的；

★由这四个基类派生出来的子类名称以其父类名作为子类名后缀；

InputStream抽象类实现了Closeable接口，Closeable接口上面还有一个AutoCloseable接口；OutputStream抽象类实现了Closeable接口和Flushable接口；Reader抽象类实现了Closeable接口和Readable接口；Writer抽象类实现了Appendable接口、Flushable接口和Closeable接口；在使用时，创建他们的实现子类。

IO流字节流InputStream
OutputStream
字符流Reader
Writer
InputStreamFileInputStream
PipedInputStream
ObjectInputStream
ByteArrayInputStream
SequenceInputStream
FilterInputStreamBufferedInputStream
DigestInputStream
DataInputStream
OutputStreamFileOutputStream
PipedOutputStream
ObjectOutputStream
ByteArrayOutputStream
FilterOutputStreamBufferedOutputStream
DigestOutputStream
DataOutputStream
PrintStream
ReaderInputStreamReaderFileReader
BufferedReader
CharArrayReader
FilterReader
PipedReader
StringReader
WriterOutputStreamWriterFileWriter
BufferedWriter
CharArrayWriter
FilterWriter
PipedWriter
PrintWriter
StringWriter

InputStream常用子类

1）FileInputStream：文件输入流；

2）BufferedInputStream：缓冲字节输入流；

3）ObjectInputStream：对象字节输入流；

package com.pero.inputStream;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class FileInputStream_ {
    public static void main(String[] args) {

    }

    @Test
    //读取文件
    public void test(){
        //定义文件路径
        String filePath = "d:\\demo\\test\\HelloWorld.txt";
        //定义文件输入流对象名称
        FileInputStream fileInputStream = null;
        //定义接收读取一字节数据
        int readData;
        try {
            //获取文件输入流对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            while ((readData = fileInputStream.read()) != -1){  //如果返回-1表示已经读取到最后一位
                System.out.print((char)readData); //读取数据为int型，需要转成字符型char
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {  //必须关闭流，释放链接文件的流,否则造成资源浪费
            try {
                fileInputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @Test
    public void test2(){
        String path = "d:\\demo\\test\\HelloWorld.txt";
        FileInputStream fileInputStream = null;
        byte[] bytes = new byte[8];
        int readLength = 0;

        try {
            fileInputStream = new FileInputStream(path);
            //如果读取正常返回读取的字节数
            while((readLength = fileInputStream.read(bytes)) != -1){
                //第一次读取时，bytes第一次接收八个字符hello,wo;
                // 此时fileInputStream.read(bytes)返回值为8，
                //while循环不退出，输出hello,wo后，再次进入循环
                // 第二次读取bytes第二次接收rld！
                // 此时fileInputStream.read(bytes)返回值为4，
                // （bytes中存储的为rld!o,wo，其中o,wo为上次读取的数据，bytes中没有将其覆盖）
                //但是new String(bytes, 0, readLength)输出bytes数组的0~3(0~readLength-1)位的字符
                //第三次读取，读取到数据的最后一位，此时fileInputStream.read(bytes)返回值为-1退出循环
                System.out.print(new String(bytes,0,readLength));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

 OutputStream常用子类

1）FileOutputStream：文件输出流。

package com.pero.outputStream_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Pero
 * @version 1.0
 */
public class FileOutputStream_ {
    public static void main(String[] args) {

    }

    @Test
    public void writeFile(){
        String path = "d:\\demo\\test\\next.txt";
        FileOutputStream fileOutputStream = null;

        try {
            //fileOutputStream = new FileOutputStream(path);以此方式创建输出流
            //输出文件内容会覆盖原来的内容
            //fileOutputStream = new FileOutputStream(path,true);以此方式创建输出流
            //输出文件内容会添加到原来的内容之后
            fileOutputStream = new FileOutputStream(path,true);
            //写入一个字节
            //fileOutputStream.write('H');

            //写入字符串
            String str = "Hello,world!";
            //使用getBytes,将字符串转成字节（byte）数组
            fileOutputStream.write(str.getBytes());

            //写入字符串部分数据Hello（0~5-1）
            fileOutputStream.write(str.getBytes(),0,5);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

文件拷贝（图像） 

package com.pero.outputStream_;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class FileCopy {
    public static void main(String[] args) {

    }

    @Test
    public void copy(){
        //大文件读取中，边读取数据边输出存放文件（流的形式）
        //将地址所在文件数据输入到程序
        //输入、输出路径
        String inputPath = "C:\\Users\\Pero\\Desktop\\4.jpeg";
        //将文件数据输出到指定地址存放
        String outputPath = "D:\\demo\\test\\4.jpeg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        byte[] bytes = new byte[1024];  //饱和读取数量
        int readLength = 0;

        try {
            fileInputStream = new FileInputStream(inputPath);
            fileOutputStream = new FileOutputStream(outputPath);

            //读取文件数据
            while ((readLength = fileInputStream.read(bytes)) != -1){
                //边读边写,一定要用write(bytes,0,readLength);
                //因为最后一次读写，不一定把bytes里的存储数据完全覆盖，
                //最后剩余的空间是倒数第二次传输的部分数据，会发生错误
                fileOutputStream.write(bytes,0,readLength);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        finally {
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 FileReader类和FileWriter类（字符流，按照字符来操作IO）

FileReader相关方法

1）构造器：new FileReader（File/String）

2）read：每次读取单个字符，则返回该字符，如果到了文件末尾则返回-1；

3）read（char[]）：批量读取多个字符到数组，返回读取到的字符数，如果到了文件末尾则返回-1；

相关API：

1）new String(char[] )：将char[]转换阿成String；

2）new String(char[] ,off ,len)：将char[]的指定部分转换成String。

package com.pero.reader_;

import org.junit.jupiter.api.Test;

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

/**
 * @author Pero
 * @version 1.0
 */
public class FileReader_ {
    public static void main(String[] args) {

    }

    @Test
    public void reader(){
        //创建路径
        String path = "d:\\demo\\test\\Story.txt";
        FileReader fileReader = null;
        int data = 0;
        //char[] chars = new char[1024];
        try {
            fileReader = new FileReader(path);
            //循环读取
            while ((data = fileReader.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                if (fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @Test
    public void reader1(){
        String path = "d:\\demo\\test\\Story.txt";
        char[] chars = new char[1024];
        int length = 0;
        FileReader fileReader = null;

        try {
            fileReader = new FileReader(path);
            while ((length = fileReader.read(chars)) != -1){
                System.out.print(new String(chars,0,length));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                if (fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

FileWriter相关方法

1）构造器：new FileWriter(File/String)：覆盖模式，相当于流的指针在首端；

2）构造器：new FileWriter(File/String,true)：追加模式，相当于流的指针在尾端；

3）write(int )：写入单个字符；

4）write(char[])：写入指定数组；

5）write(char[],off,len)：写入指定数组的指定部分；

6）write(String)：写入整个字符串；

7）write(String,off,len)：写入字符串的指定部分。

相关API：String类中toCharArray：将String转换成char[]。

★注意：FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件。

package com.pero.writer_;

import org.junit.jupiter.api.Test;

import java.io.FileWriter;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class FileWriter_ {
    public static void main(String[] args) {

    }

    @Test
    public void writer(){
        String path = "d:\\demo\\test\\note.txt";
        FileWriter fileWriter = null;
        char[] chars = {'H','e','l','l','o',',','H','o','r','l','d','!'};

        try {
            fileWriter = new FileWriter(path/*,true*/); 
            fileWriter.write('h');
            fileWriter.write(chars);
            fileWriter.write("不经历风雨，怎能见彩虹");
            fileWriter.write("锄禾日当午，汗滴禾下土",0,5);
            fileWriter.write(chars,0,5);

        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                fileWriter.close();
                //fileWriter.flush();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

Neo丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java—IO流学习笔记（IO流部分流分类及成员方法）
Hygges_9168的博客
08-01 161
一、 IO流概念 简单的说，就是将数据的传输操作（数据的输入输出），看做一种数据的流动。Java中的IO操作主要指的是java.io包下的一些常用类的使用，通过这些常用类对数据进行读取（输入Input）和写出（输出Output）。 二、 IO流的分类 按照流的方向可以分为输入流和输出流；按照流动的数据类型来分，可分为字节流和字符流。字节流分为输入流(顶级父类InputStream)和输出流（顶级父类OutStream)，字符流分为输入流（顶级父类Reader）和输出流（顶级父类Writer)。 三、字节流和
Java学习-IO流-序列化流
weixin_45876155的博客
03-03 459
Java学习-IO流-序列化流
JAVA—IO流详解
weixin_48006490的博客
09-01 7951
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
Java学习之IO流
qq_53723728的博客
06-19 1658
IO流介绍IO：输入/输出(Input/Output)流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载IO流的分类按照数据的流向输入流：读数据输出流：写数据按照数据类型来分字节流字节输入流字节输出流字符流字符输入流字符输出流IO流的使用场景如果操作的是纯文本文件，优先使用字符流如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
深入解析 Java IO 源码：InputStream
最新发布
qq_63353796的博客
06-12 754
是一个抽象类，位于java.io包中，用于表示字节输入流。它是所有字节输入流类的超类，提供了一些基本的方法来读取字节数据。以下是// 抽象方法，读取下一个字节的数据// 读取多个字节的数据// 从指定偏移量开始读取多个字节的数据return 0;return -1;int i = 1;try {for (;i < len;break;return i;// 跳过指定数量的字节int nr;return 0;break;
【java高级】java.io.InputStream
北极星的博客
05-24 1303
FileInputStream概述 我们通过查看FileInputStream的官方文档，我们主要看第三个构造函数。 主要看一下read()函数。 package com.sdnu.project1; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * @author Beyong * @Description FileInputStream
【Java 基础篇】Java IO流详解
繁依Fanyi的博客
06-26 3074
本文详细介绍了Java IO流的原理、分类、使用场景和常用类。IO流提供了一种统一的方式来处理输入和输出操作，无论是从文件、网络连接还是内存中。通过使用不同的IO流类，我们可以实现数据的读取和写入，满足不同的需求。希望本文对你理解和应用Java IO流有所帮助！
JAVA 根据文件头判断文件类型
qq_57570052的博客
07-24 1986
例如，一张jpg格式的图片直接修改后缀名为png也可以打开，但当一些方法需要调用后缀为png格式图片的时候，再使用这个文件，则会出现报错。是因为这张图片的本质没有变，他还是个png格式的文件。使用java.io包中的FileInputStream类。通过读取原始字节流，根据字节流头部获取到文件格式。从而判断一个文件是否被修改过。那么，该如何去掉文件名的伪装，拿到文件的真实格式呢？这里给出一个讲数组转换成为十六进制字符串的方法。
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
java-网络编程-io流-学习案例
02-25
通过这个案例，学习者可以深入理解Java网络编程的基本原理，掌握如何使用IO流进行数据交换，以及如何结合Swing创建功能丰富的图形界面。同时，这也是实践多线程编程的好机会，因为服务器需要同时处理多个客户端的...
JAVA的IO流使用及其原理总结
09-11
总结了java中的IO流及其包装类的详细使用方法，展示类其底层原理的代码。
Java IO流常用字节字符流原理解析
08-19
今天，我们将主要介绍Java IO流中的字节流和字符流原理解析。 一、字节流 字节流是Java IO流中最基本的流类型，所有的流都可以追溯到InputStream和OutputStream这两个抽象基类。字节流的主要特点是以byte为单位...
Java核心基础编程精讲-IO流
06-21
4. **IO流的使用**：Java IO流提供了丰富的类库，如使用FileInputStream和FileOutputStream读写文件，使用BufferedReader和BufferedWriter进行高效的文本读写，使用DataInputStream和DataOutputStream处理基本数据...
解析java中的文件字节输入流
SSS4362的博客
08-05 2532
解析java中的文件字节输入流
Java IO流分析、IO整理与IO优化
爱.NET
12-11 584
一、IO流的概念 Java中对文件的操作是以流的方式进行的。流是Java内存中的一组有序数据序列。Java将数据从源（文件、内存、键盘、网络）读入到内存中，形成了流，然后将这些流还可以写到另外的目的地（文件、内存、控制台、网络），之所以称为流，是因为这个数据序列在不同时刻所操作的是源的不同部分。 二、IO流的分类 Java中的流，可以从不同的角度进行分类。 按照数据流的方向不同...
Java——泛型和Io流
qq_55682798的博客
04-19 693
目录 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流 FileInputStream FileOutputStream BufferedRead PrintStream File 序列化版本号，transient关键字
m0_53881899的博客
08-03 461
Java IO流 FileInputStream FileOutputStream
Java IO流详解
m0_53067943的博客
02-02 1473
主要对于java io流进行了详细的总结
Java之IO流
m0_47310235的博客
03-23 780
大多数应用程序都需要实现与设备之间的数据传输，例如键盘可以输入数据，显示器可以显示程序的运行结果等。在Java中，将这种通过不同输入输出设备（键盘、内存、显示器、网络等）之间的数据传输抽象表述为“流”，程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于java.io包中，称为IO（输入输出）流。IO 流有很多种，按照操作数据的不同，可以分为字节流和字符流，按照数据传输方向的不同又可分为输入流和输出流，程序从输入流中读取数据，向输出流中写入数据。
Java IO流：标准输入/输出与分类详解
Java IO流根据不同的特征进行了分类： 1. **按数据类型分类**： - 输入流（InputStream）：处理数据的输入，如`FileInputStream`，用于从文件或其他数据源读取数据。 - 输出流（OutputStream）：处理数据的输出，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值