Java基础入门之——IO流

最新推荐文章于 2024-04-26 16:26:34 发布
最新推荐文章于 2024-04-26 16:26:34 发布
阅读量118 收藏
点赞数 1
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53308984/article/details/131894373
版权

文章目录


请添加图片描述
输入流：磁盘等数据给内存。
输出流：内存里的数据存入磁盘。
字节流：内存和磁盘之间的管道是一个一个字节相互来去
字符流：内存和磁盘之间的管道是一个一个字符相互来去

字节流

文件字节输入流

每次读取1个字节

在这里插入图片描述

public class Main {
    public static void main(String[] args) throws Exception {
        //创建文件字节输入流管道，与源文件接通
        //FileInputStream inputStream = new FileInputStream(new File("src/test.txt"));
        FileInputStream inputStream = new FileInputStream("src/test.txt");

        //读取1个字符，返回int，没有字符返回-1
        int b = inputStream.read();
        System.out.println((char) b);

        //循环读取文件地所有字符，多次访问硬盘性功能很差且遇到汉字会有乱码
        //运行时注释上面读取一个字符的代码，否则从第二个字符开始读取
        int x;
        while ((x = inputStream.read()) != -1) {
            System.out.print((char) x);
        }

        //流使用完毕后必须关闭，释放系统资源
        inputStream.close();
    }
}

中文字符乱码原因：美国最早推出ASC码（之后的编码方式基本上都在此基础上），包含数字、字母能字符，每个字符1个字节；中国推出的GBK国标码每个汉字2个字节；国际组织推出UTF-8编码汉字占3个字节。每次只读取一个字节，所以汉字会出现乱码。

每次读取多个字节

public class Main {
    public static void main(String[] args) throws Exception {
        FileInputStream inputStream = new FileInputStream("src/test.txt");

        //test.txt的内容是abcde
        int numOfWater = 3;
        byte[] buffer = new byte[numOfWater];//就像是一个水桶
        int lenOfRead = inputStream.read(buffer);
        String s = new String(buffer);
        System.out.println(s);
        System.out.println("读取字符个数：" + lenOfRead);

        //再运行一次
        int lenOfRead2 = inputStream.read(buffer);
        String s2 = new String(buffer);
        System.out.println(s2);
        System.out.println("读取字符个数：" + lenOfRead2);

        inputStream.close();
    }
}

在这里插入图片描述
第二次读取的输出有误，对后续的编程可能会有影响，String类重载了方法修改入下。

String s = new String(buffer, 0, lenOfRead);//读多少，倒多少

while循环改造，还是会有汉字乱码的问题，截断汉字的字节。

        byte[] buffer = new byte[3];
        int lenOfRead;
        while ((lenOfRead = inputStream.read(buffer)) != -1) {
            String s = new String(buffer, 0, lenOfRead);
            System.out.print(s);
        }

一次性读取全部字节

  • 方法1：定义一个和文件字节数大小一样的数组，重复以上操作
  • 方法2：调用public byte[] readAllBytes()
        byte[] bytes = inputStream.readAllBytes();
        System.out.println(new String(bytes));

两个方法本质上是一样的，JDK中封装好了方法而已。同时如果文件特别大，readAllBytes()方法会抛出内存溢出异常OutOfMemoryError

文件字节输出流

在这里插入图片描述

public class Main {
    public static void main(String[] args) throws Exception {
        //创建文件字节输入流管道，与源文件接通
        //覆盖数据管道
        FileOutputStream outputStream = new FileOutputStream("src/test.txt");

        //写一个字节
        outputStream.write(97);//a
        outputStream.write('b');//b
        outputStream.write('国');//默认写进去第一个字节，所以写进去乱码

        //写多个字节
        byte[] bytes = "我爱你中国".getBytes();
        outputStream.write(bytes);
        //使用 UTF-8 编码，每个汉字三个字节，只想输入”我爱你“要输入9个字节
        outputStream.write(bytes, 0, 9);
        
        //换行，\n支持windows操作系统，\r\n支持更过平台
        outputStream.write("\r\n".getBytes());
        
        outputStream.close();
    }
}

上面的方法每次运行会先将文件里的数据删干净，再写入。如果想追加数据，看下面。

//追加数据管道
FileOutputStream outputStream = new FileOutputStream("src/test.txt", true);

专业释放资源方式

以上我们讲到，使用完io流后要及时关闭流以达到释放资源的目的，但是在复杂的情形中，关闭流之前出现异常，那么流就一直没有被关闭，一直占用着资源，这一点不好。主要以下两种方式解决。

  • try-catch-finally
    finally代码区的特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。
    作用：一般用于在程序执行完成后进行资源的释放操作(专业级做法)。
public class Main {
    public static void main(String[] args) {
        FileOutputStream outputStream = null;
        try {
            //创建文件字节输入流管道，与源文件接通
            outputStream = new FileOutputStream("src/test.txt", true);

            //写多个字节
            byte[] bytes = "我爱你中国".getBytes();
            outputStream.write(bytes);
            //使用 UTF-8 编码，每个汉字三个字节，只想输入”我爱你“要输入9个字节
            outputStream.write(bytes, 0, 9);

            //换行，\n支持windows操作系统，\r\n支持更过平台
            outputStream.write("\r\n".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 防止创建流对象之前有异常，或者流在try中已经关闭
            try {
                if (outputStream != null) outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
  • try-with-resource
    在这里插入图片描述
    以上关闭资源方式的finally中的代码略显臃肿，JDK7之后提供了更简便的释放资源方式。
    注意：try之后的括号里只能放资源对象，像定义一个整形变量是不可以的。
    资源：实现了AutoCloseable接口，每个资源实现了close()方法，资源对象被使用完成后会自动去调用它的close()方法实现资源释放。
public class Main {
    public static void main(String[] args) {
        try (//创建文件字节输入流管道，与源文件接通
             FileOutputStream outputStream = new FileOutputStream("src/test.txt", true)) {
            //写多个字节
            byte[] bytes = "我爱你中国".getBytes();
            outputStream.write(bytes);
            //使用 UTF-8 编码，每个汉字三个字节，只想输入”我爱你“要输入9个字节
            outputStream.write(bytes, 0, 9);

            //换行，\n支持windows操作系统，\r\n支持更过平台
            outputStream.write("\r\n".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

在这里插入图片描述

public class Main {
    public static void main(String[] args) {
        try(
                Reader reader = new FileReader("src/test.txt");
            ) {
            char[] buffer = new char[3];
            int len;
            while ((len = reader.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
跟字节流差不多，不做演示了。
注意：字符流写出数据后，必须刷新流（.flush()）或者关闭流，不然没写。因为字符流先把数据写到了缓冲区，刷新和关闭操作通知缓冲区写道文件里。

缓冲流

对原始流经行包装，提升原始流的性能。
在这里插入图片描述
先来讲讲缓冲流是如何提高原始流的读取性能的，缓冲流的原理。
举一个例子从D盘复制文件到C盘，用字节输入输出流实现逻辑如下。在内存里创建一个1KB的数组，16次从D盘输入，16次向C盘输出，一共32次访问磁盘。
在这里插入图片描述
字节缓冲输入输出流先是包装了字节输入输出流，它就会在内存中开辟一个8KB的缓冲池。D盘数据到输入缓冲池只需要2次，也就是2次输入；同理，2次输出。也就是4次访问磁盘。
输入缓冲池的数据通过数组放到输出缓冲池中，这一操作在内存中实现，是相当快的。
在这里插入图片描述

字节缓冲流

在这里插入图片描述
方法也就是功能和字节流一样，只是性能上得到了提升。

public class Main {
    public static void main(String[] args) {
        try(
                InputStream inputStream = new FileInputStream("src/test.txt");
                //创建字节输入缓冲流，可传入int类型作为第二参数定义缓冲池大小
                InputStream bis = new BufferedInputStream(inputStream);
                OutputStream outputStream = new FileOutputStream("src/test_copy.txt");
                //创建字节输出缓冲流，可传入int类型作为第二参数定义缓冲池大小
                OutputStream bos = new BufferedOutputStream(outputStream);
            ) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符缓冲流

在这里插入图片描述
字符缓冲输入流还新增了一个功能
在这里插入图片描述
在这里插入图片描述
字符缓冲输出流新增功能
在这里插入图片描述

转换流

解决代码编码和文本文件编码不一致的情况，避免乱码。
在这里插入图片描述

  • 字符输入转换流
    在这里插入图片描述
public class Main {
    public static void main(String[] args) {
        try(
                //创建原始字节流（GBK编码）
                InputStream inputStream = new FileInputStream("src/test.txt");
                //把原始字节流变成字符转换流
                Reader reader = new InputStreamReader(inputStream, "GBK");
                //字符转换流包装成字符缓冲流
                BufferedReader br = new BufferedReader(reader);
            ) {
            char[] buffer = new char[20];
            int len = br.read(buffer);
            System.out.println(new String(buffer,0,len));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 字符输出转换流
    在这里插入图片描述
public class Main {
    public static void main(String[] args) {
        try(
                //创建原始字节流（GBK编码）
                OutputStream outputStream = new FileOutputStream("src/test.txt");
                //把原始字节流变成字符转换流
                Writer writer = new OutputStreamWriter(outputStream, "GBK");
                //字符转换流包装成字符缓冲流
                BufferedWriter bw = new BufferedWriter(writer);
            ) {
            bw.write("我爱中国");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印流

PrintStream/PrintWriter (打印流)
作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。
在这里插入图片描述

  • PrintStream
    在这里插入图片描述
public class Main {
    public static void main(String[] args) {
        try(
                PrintStream ps = new PrintStream("src/test.txt")
            ) {
            ps.println("你好");
            ps.println(true);
            ps.println(123);
            ps.println(3.14);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • PrintWriter
    在这里插入图片描述
        try(
                PrintWriter pw = new PrintWriter("src/test.txt")
            ) {
            pw.println("你好");
            pw.println(true);
            pw.println(123);
            pw.println(3.14);
        } catch (Exception e) {
            e.printStackTrace();
        }

以上两个流属于高级流，创建时在后面加true不能实现追加字符。那如果要实现追加流，需要包装一个实现追加流的低级流。

PrintWriter pw = new PrintWriter(new FileWriter("src/test.txt", true))
  • 打印流的应用：输出重定向

平时开发中，我们通常把数据输出到控制台，而程序在运行的时候通常用户是在文件里看数据或者异常。

public class Main {
    public static void main(String[] args) {
        try(
                PrintStream ps = new PrintStream(new FileOutputStream("src/test.txt", true))
            ) {

            //改变系统默认的打印对象
            System.setOut(ps);

            System.out.println(123);
            System.out.println("你好");
            System.out.println(1132.543);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数据流

应用场景，输出数据的同时，把数据的类型也输出记录下来。
在这里插入图片描述
数据输出流
在这里插入图片描述
数据输入流
在这里插入图片描述
可以看出来数据输入流和数据输出流的方法是相互对应的，使用时也应该相互对应使用。

public class Main {
    public static void main(String[] args) {
        try(
                DataOutputStream dos = new DataOutputStream(new FileOutputStream("src/test.txt"));
            ) {
            dos.writeInt(123);
            dos.writeDouble(12.3);
            dos.writeUTF("我爱中国");
        } catch (Exception e) {
            e.printStackTrace();
        }

        try(
                DataInputStream dis = new DataInputStream(new FileInputStream("src/test.txt"));
        ) {
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

而text中的数据
在这里插入图片描述

序列化流

序列化：把Java对象写道文件中去
反序列化：把文件里的Java对象读出来
序列化流就是解决把把Java对象写道文件中去的。
在这里插入图片描述
对象字节输出流
在这里插入图片描述
对象字节输入流
在这里插入图片描述

public class Main {
    public static void main(String[] args) {
        try(
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/test.txt"));
            ) {
            //需要序列化的对象，必须实现可序列化接口Serializable
            oos.writeObject(new Student("张三", 20));
        } catch (Exception e) {
            e.printStackTrace();
        }

        try(
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/test.txt"));
        ) {
            Student student = (Student) ois.readObject();
            System.out.println(student);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
注意：需要序列化的对象，必须实现可序列化接口Serializable

如果想要对象的某个成员变量（一般密码不参与）不参与序列化，在变量前加transient修饰符即可。

private transient String password;

总结

读取文本更适合使用字符流，而字节流跟适用于数据转移，如文件的复制。
使用缓冲流可以提高性能。
转换流解决编码问题。
使用资源后要及时关闭资源，用try-with-resource更方便。

啊铮
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础---IO流
我是太阳
01-30 2万+
1、File类的使用 常用构造器 路径分隔符 常用方法 2、IO流原理及流的分类 3、节点流(或文件流) 4、缓冲流 5、转换流 6、标准输入、输出流 7、 打印流 8、数据流 9、对象流 10、随机存取文件流 11、Path、Paths、Files类的使用 ...
Java基础——IO流
qq_48060243的博客
02-05 340
IO流的分类 根据处理数据类型的不同分为：字节流和字符流 根据数据流向不同分为：输入流和输出流 1.字节输入流InputStream 直接的子类FileInputStream FileInputStream不具备缓冲的效果，象要具备缓冲效果咋办借助于一个叫BufferedInputStream 字节缓冲输入流 示例:读取磁盘上的文件 public class Test { public static void main(String[] args) throws IOException .
Java中的IO流（最详细解说）
spade_Kwo的博客
08-06 8201
IO流一、File类的使用1.常用构造器2.路径分隔符3.常用方法二、IO流原理及流的分类1.Java IO原理三、流的分类1.输入流(1)InputStream & Reader(2)InputStream(3)Reader2.输出流(1)OutputStream & Writer(2)OutputStream(3)Writer3.节点流(1)读取文件1.字符读取FileReader (read(char[] cbuf))2.字节读取FileInputStream (read(byte
Java io流 详解
m0_68987535的博客
06-11 4550
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java学习——IO流
最新发布
m0_73245690的博客
04-26 924
FileInputStream:文件输入流BufferedInputStream:缓冲字节输入流ObjectInputStream:对象字节输入流（类的继承关系）通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定通过使用文件描述符fdObj创建一个FileInputStream，该文件描述符表示到文件系统中的某个实际文件的现有连接。
JAVA—IO流详解
weixin_48006490的博客
09-01 7925
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
【Java 基础篇】Java IO流详解
繁依Fanyi的博客
06-26 3013
本文详细介绍了Java IO流的原理、分类、使用场景和常用类。IO流提供了一种统一的方式来处理输入和输出操作，无论是从文件、网络连接还是内存中。通过使用不同的IO流类，我们可以实现数据的读取和写入，满足不同的需求。希望本文对你理解和应用Java IO流有所帮助！
Java学习之IO流
qq_53723728的博客
06-19 1648
IO流介绍IO：输入/输出(Input/Output)流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载IO流的分类按照数据的流向输入流：读数据输出流：写数据按照数据类型来分字节流字节输入流字节输出流字符流字符输入流字符输出流IO流的使用场景如果操作的是纯文本文件，优先使用字符流如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
JAVA-SE入门学习——第九讲IO流
06-08
JAVA-SE入门学习——第九讲IO流 在 Java 中，IO 流（Input/Output Stream）是一种基本的输入/输出机制，它允许程序读取和写入各种类型的数据。IO 流是 Java 编程语言的核心组件之一，它提供了一种通用的方式来处理...
Java基础入门教程
06-11
Java基础入门教程是一份非常适合初学者的教育资源，它引导学习者逐步掌握Java编程语言的核心概念。这份教程可能包含了以下几个关键的知识点： 1. **认识Java**：这部分通常会介绍Java的历史，由Sun Microsystems...
Java语言入门知识——为初学者提供入门基础
11-27
Java的IO流处理能力强，可以读写文件、网络通信等。分为字节流和字符流，以及输入流和输出流。 十一、多线程 Java内置对多线程的支持，通过实现Runnable接口或继承Thread类创建线程。 十二、网络编程 Java提供了...
Java基础知识——Java入门与加深
08-31
最后，Java的IO流和NIO（非阻塞I/O）库允许程序读写文件和网络数据。线程和并发处理使得Java可以高效地执行多任务。 总结，Java的基础知识涵盖了从基本语法到面向对象编程，再到高级特性和框架。理解并熟练运用这些...
Java基础入门及提高.pdf
09-17
《Java基础入门及提高》，整理：yyc、spirit。PDF 格式，大小 4.8 MB，非影印版。 前言： 同人类任何语言一样，Java 为我们提供了一种表达思想的方式。如操作得当，同其他方式相比，随着问题变得愈大和愈复杂，这种...
Java之IO流
m0_47310235的博客
03-23 771
大多数应用程序都需要实现与设备之间的数据传输，例如键盘可以输入数据，显示器可以显示程序的运行结果等。在Java中，将这种通过不同输入输出设备（键盘、内存、显示器、网络等）之间的数据传输抽象表述为“流”，程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于java.io包中，称为IO（输入输出）流。IO 流有很多种，按照操作数据的不同，可以分为字节流和字符流，按照数据传输方向的不同又可分为输入流和输出流，程序从输入流中读取数据，向输出流中写入数据。
java中的io流
m0_66689823的博客
07-19 9841
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
JAVA IO流
weixin_61611746的博客
06-24 538
IO，即in和out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。关于流的特性有下面几点：1.先进先出：最先写入输出流的数据最先被输入流读取到。2.顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）
Java I/O流详解
qq_28791753的博客
03-21 1976
JAVA I/O流详解，字节流，字符流
java文件操作-IO流
qq_53464269的博客
03-03 2311
文件操作
Java IO流详解
热门推荐
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值