IO流基础

  • 开发
  • 10

IO流介绍

1.什么是IO流？

                流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序列或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出的，即数据像流体一样连绵不绝进行传输。

I 即Input，输入。O 即Output，输出。

IO流能干什么？

IO流可以在本地磁盘和网络上对数据进行传输，比如说，字符流可以向一个空的文本文件中写入数据，或是从一个未知文本文件中读取数据，还可以进行文件的拷贝。而字节流则常用于拷贝图片。

 IO流的分类：

IO流体系： 

不多bb，还是直接上图片！如图：

        首先是字符流：

 再来看一下字符流（文本文件）的类图，如下 : 

然后是字节流：

 再来看一下字节流（二进制文件）的类图，如下 : 

字符流读写文件：

1.普通字符流读取文件：
                前言:         
                使用普通字符流来读取文件（FileReader）时，共有两种方式，分别是①以单个字符读取，②以字符数组读取，两种方式大同小异，因此up会重点把第一种详细讲好，第二种就没那么难了。
                使用普通字符流来写入文件（FileWriter）时，一共有三种方式，分别是①以单个字符写入，②以字符数组写入，③以字符串形式写入，同样，三种方式大同小异，up还是重点讲解第一种方式。

1.以单个字符读取:       
                步骤:

                1) 创建字符输入流对象，关联数据源文件 (建议第一步就抛出父类异常IOException)

                2) 定义变量，记录读取到的内容

                3) 循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量

                4) 释放资源。（为防止遗忘，最好先释放资源。）

读取方法：

                需要调用Reader类中的read() 方法：
                int read(): 每次读取一个字符，返回该字符对应的ASCII码值(整数)， 若达到流的末尾，返回-1。

由于Reader类是抽象类，因此需要多态的方式来实例化其子类。Reader类的常用子类是FileReader类。其构造方法为:
                public FileReader(String pathName) 需要传入要读取文件的路径的字符串形式，来获取字符输入流对象。

/**
 * 字符流读数据
 *      Reader类中的方法
 *          int read():         每次读取一个字符，返回该字符对应的ASCII码值(整数)，
 *                              若达到流的末尾，返回-1
 *
*       FileReader类的构造方法
 *          public  FileReader(String pathName)
 *          ①根据传入的字符串形式的路径，获取字符输入流对象
 *          ②注意因为Reader类是抽象类，所以需要通过多态的方式来实例化它的子类。
 */

public class demo_1 {
    public static void main(String[] args) throws IOException {

  //1.创建字符输入流对象，关联数据源文件。

        Reader reader=new FileReader("C:\\Users\\22652\\Desktop\\程序\\1.txt");
        while (true){

//2.定义变量，记录读取到的内容。

            int tmp=reader.read();

            if (tmp==-1){
                break;
            }
            System.out.print((char) tmp);
        }

//4.释放资源        //为防止遗忘，最好先释放资源
        reader.close();
    }
}

上图中读取很麻烦，我推荐一种更好的写法。 

public static void main(String[] args) throws IOException {
/*使用 try-with-resources 时，无需手动关闭实现了 AutoCloseable 接口的资源。
在 try 代码块执行完毕后，系统会自动调用资源的 close() 方法来关闭资源，
无需编写繁琐的 finally 块。这样，我们不仅减少了代码量，还避免了由于忘记关闭资源而导致的潜在资源泄漏问题
*/
        try(Reader reader=new FileReader("C:\\Users\\22652\\Desktop\\程序\\1.txt")){
            while (true){
                int tmp=reader.read();
                if (tmp==-1){
                    break;
                }
                System.out.print((char) tmp);
            }
        }
    }

 try with的加入--http://t.csdnimg.cn/dDlvD，不用我们来关闭文件；

以字符数组读取： 
                以单个字符的形式读取文件要是会了，这个就是小菜一碟了。老规矩，还是先把步骤和读取方法给大家说一下:

                步骤:

                1) 创建字符输入流对象，关联数据源文件 (建议第一步就抛出父类异常IOException)

                2) 定义变量，记录读取到的内容

                3) 循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量

                4) 释放资源。（为防止遗忘，最好先释放资源。）

public class demo_2 {
    public static void main(String[] args) throws IOException {
        try(Reader reader=new FileReader("C:\\Users\\22652\\Desktop\\程序\\1.txt")){
            char[] chars=new char[1024];
            while (true){
                int tmp=reader.read(chars);
                if (tmp==-1){
                    break;
                }
                for (int i = 0; i < tmp; i++) {
                    System.out.print(chars[i]);
                }
            }
        }
    }
}

 普通字符流写入文件

步骤：

                ①创建字符输入流对象，关联目的地文件。(建议第一步就抛出父类异常IOException)

                ②将目标内容写入到目的地文件中

                ③释放资源

public static void main(String[] args)throws IOException {
        try(Writer writer= new FileWriter("C:\\Users\\22652\\Desktop\\程序\\2.txt")){
            writer.write('说');
            writer.write('话');
            writer.write('啊');
            writer.write("hello java");
        }
    }

FileReader和FileWriter这两个流都是字符流，都是以一个字符为单位进行输入和输出的。所以读取和写入占用2个字节的字符时都可以正常地显示出来，以上是以File(文件)这个类型为例对节点流进行了讲解，所谓的节点流指定就是直接把输入流或输出插入到数据源上，直接往数据源里面写入数据或读取数据。

在诸多处理流中，有一个非常重要，那就是缓冲流。

我们知道，程序与磁盘的交互相对于内存运算是很慢的，容易成为程序的性能瓶颈。减少程序与磁盘的交互，是提升程序效率一种有效手段。缓冲流，就应用这种思路：普通流每次读写一个字节，而缓冲流在内存中设置一个缓存区，缓冲区先存储足够的待操作数据后，再与内存或磁盘进行交互。这样，在总数据量不变的情况下，通过提高每次交互的数据量，减少了交互次数。

需要注意的是，缓冲流效率一定高吗？不一定，某些情形下，缓冲流效率反而更低，具体请见IO流效率对比。

字符缓冲流（高效字符流）:

  ①字符缓冲流介绍:
                字符缓冲流，又叫做高效字符流。字符缓冲流自带有缓冲区，大小为8192个字符，也就是16KB。 (即字节数：16*1024 == 8192*2) ---->（Unicode编码一个中文或英文字符都是占两个字节）。

                ②字符缓冲流的普通用法：
                使用字符缓冲流来拷贝文件时，依然遵循经典的IO流拷贝文件核心六部曲，因此为什么我强调要把IO流拷贝文件核心六部曲全文背诵？因为太经典了！几乎可以可以做到一招通吃。
                但是，与之前有差异的地方在于，在创建高效字符输入流对象时，并不是直接传入数据源文件的路径了，而是要传入一个普通的字符输入流对象，而我们知道，普通读文件对象在创建时传入的就是数据源文件的路径了，因此，可以总结为：创建高效字符输入流对象需要传入一个 ‘已经关联数据源文件的普通字符输入流对象’ 。仔细品味这句话，高效字符输出流也是同理。一下子看不懂也没有关系，毕竟都是带抽象，没上手过纯纯天书，还是直接举个栗子直观一点：

//声明：以下是仅作差异演示的代码段，并不完整，完整代码在之后的代码演示中会有
 
//1.我们先创建一个普通字符输入流对象
    Reader reader = new FileReader("Test/1.txt");
 
//2.好，有了普通字符输入流对象后，我们就可以创建高效字符输入流对象了。
    BufferedReader bufferedReader = new BufferedReader(reader);
//这样我们就得到了一个高效字符输入流对象bufferedReader。
 
//其实，实际开发中往往采用链式编程优化代码，如下：
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("Test/2.txt"));
 
//说白了就是把1. 2. 两步合起来了，看着简洁直观。

字符缓冲流的特有用法：
                BufferedReader类中的方法：
                public String readLine() : 一次读取一行数据并返回读取到的内容，读不到返回null,
                该方法可以用String类型的变量作接收。

                BufferedWriter类中的方法：
                public void newLine: 根据当前操作系统给出相应的换行符 (注释中有详解)

字节流读写文件：

InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本
可以认为不同的输入设备都可以对应一个 InputStream 类，我们现在只关心从文件中读取，所以使用 FileInputStream 

public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("hello.txt")) {
            while (true) {
                int b = is.read();
                if (b == -1) {
                    // 代表文件已经全部读完
                    break;
               }
                
                System.out.printf("%c", b);
           }
       }
   }
利用 UTF-8 读取字符 

import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
public class Main {
    public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("hello.txt")) {
            byte[] buf = new byte[1024];
            int len;
            while (true) {
                len = is.read(buf);
                if (len == -1) {
                    // 代表文件已经全部读完
                    break;
               }
                // 每次使用 3 字节进行 utf-8 解码，得到中文字符
                // 利用 String 中的构造方法完成
                // 这个方法了解下即可，不是通用的解决办法
                for (int i = 0; i < len; i += 3) {
                    String s = new String(buf, i, 3, "UTF-8");
                    System.out.printf("%s", s);
               }
           }
       }
   }
}

 这个方法了解下即可，不是通用的解决办法

利用Scanner来读取进行字符读取。

FileOutputStream: 普通字节输出流，用来写出数据的
           成员方法:
             public void write(byte[] b,int index, int len) :
                  一次写入一个指定的字节数组,需要传入数组名，起始索引，有效长度

import java.io.*;
import java.util.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
public class Main {
    public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("hello.txt")) {
           try (Scanner scanner = new Scanner(is, "UTF-8")) {
               while (scanner.hasNext()) {
                   String s = scanner.next();
                   System.out.print(s);
               }
           }
       }
   }
}

上述，我们其实已经完成输出工作，但总是有所不方便，我们接来下将 OutputStream 处理下，使用
PrintWriter 类来完成输出，因为
PrintWriter 类中提供了我们熟悉的 print/println/printf 方法 
 public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("output.txt")) {
            try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-
8")) {
                try (PrintWriter writer = new PrintWriter(osWriter)) {
                    writer.println("我是第一行");
                    writer.print("我的第二行\r\n");
                    writer.printf("%d: 我的第三行\r\n", 1 + 1);
                    writer.flush();
               }
           }
       }
   }

 拷贝

try (InputStream inputStream = new FileInputStream(srcFile);
             OutputStream outputStream = new FileOutputStream(destFile)) {
            while (true) {
                byte[] buffer = new byte[20480];
                int n = inputStream.read(buffer);
                System.out.println("n = " + n);
                if (n == -1) {
                    System.out.println("读取到 eof, 循环结束. ");
                    break;
                }
                outputStream.write(buffer, 0, n);
            }
        }

阅读全部

相关推荐

  2. IO 流

    2024-04-28 05:54:05       45 阅读

  3. IO流——其他流

    2024-04-28 05:54:05       19 阅读

  4. IO流-字符流

    2024-04-28 05:54:05       11 阅读

  5. IO流(字符流)

    2024-04-28 05:54:05       8 阅读

  6. ios 推流 拉流

    2024-04-28 05:54:05       44 阅读

  8. IO流-处理流之——缓冲流

    2024-04-28 05:54:05       33 阅读

  10. Kong基于QPS、IP限流

    2024-04-28 05:54:05       19 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-04-28 05:54:05       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-04-28 05:54:05       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-04-28 05:54:05       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-04-28 05:54:05       20 阅读

热门阅读

  1. webpack

    webpack

    2024-04-28 05:54:05      32 阅读

  2. python在Django中使用django-mptt库来实现无限级树结构非常直观和方便

    2024-04-28 05:54:05       14 阅读

  8. Golang实现一个批量自动化执行树莓派指令的软件(7)辅助模块-本地活动网络

    2024-04-28 05:54:05       9 阅读

  9. Python项目开发实战：动物分拣器的实现

    2024-04-28 05:54:05       11 阅读

  10. 揭密 scaling laws

    2024-04-28 05:54:05       14 阅读

  12. 1Panel应用推荐： frp内网穿透工具

    2024-04-28 05:54:05       43 阅读

  17. Linux系统及工具的使用

    2024-04-28 05:54:05       43 阅读

  20. Vue 3 快速上手指南（第一期）

    2024-04-28 05:54:05       12 阅读

  21. 在C语言中，有哪些常见的编码错误应该避免？

    2024-04-28 05:54:05       10 阅读

  29. 编辑器，编译器，IDE的区别

    2024-04-28 05:54:05       15 阅读