凯哥带你从零学大数据系列之Java篇---第二十六章 IO流详解_jdkio流

最新推荐文章于 2024-09-29 16:20:54 发布

2401_84254011

最新推荐文章于 2024-09-29 16:20:54 发布

阅读量411

点赞数 4

分类专栏：程序员文章标签：大数据 java 开发语言

本文链接：https://blog.csdn.net/2401_84254011/article/details/138387432

版权

程序员专栏收录该内容

204 篇文章 0 订阅

订阅专栏

2.8. Writer

2.8.1. Writer的简介

字符输出流。从方向上来分，是一个输出流，数据从程序中流动到文件中，实现文件的写操作。从流中流动的数据单位来分，是一个字符流，流中流动的数据是以字符为单位的。

2.8.2. 文件的写操作

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

/**
 * @Description 使用字符流写数据
 */
public class WriterTest {
    public static void main(String[] args) {
        // 1. 实例化相关的类
        try (Writer writer = new FileWriter("file\\day25\\target", true)) {
            // 2. 将数据写入到输出流中
            writer.write("hello, world");
            // 3. 冲刷缓冲区
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.9. 案例: 文件拷贝

2.9.1. 需求分析

实现，将一个文件拷贝到另外一个地方。注意，这个不是剪切，拷贝完成之后，原文件还在。

实现方式：借助两个流来完成。

使用字符输入流，循环读取原文件中的数据。
使用字符输出流，将每次读取到的数据，写入到目标文件中。

2.9.2. 示例代码

/**
  * 使用字符流实现文件的拷贝
  * @param srcPath 原文件路径
  * @param dstPath 目标文件路径
  */
private static void fileCopy2(String srcPath, String dstPath) {
    // 2. 循环读取目标文件中的数据
    try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
        // 3. 循环读取源文件中的数据
        char[] array = new char[100];
        int length = 0;
        while ((length = reader.read(array)) != -1) {
            // 4. 将读取到的数据写入到输出流
            writer.write(array, 0, length);
        }
        writer.flush();
        return true;
    }
    catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

3. 常见的其他流

3.1. 缓冲流

3.1.1. 缓冲流的简介

给普通的IO流，套上一个缓冲区。所有的使用缓冲流进行的读写操作，都是和缓冲区进行交互的，避免了频繁的IO操作。这样一来，带来的好处就是可以提高读写的效率。这个缓冲区，其实是一个数组。

常见的缓冲流:

BufferedInputStream : 缓冲字节输入流
BufferedOutputStream ：缓冲字节输出流
BufferedReader ：缓冲字符输入流
BufferedWriter ：缓冲字符输出

3.1.2. 缓冲字节流

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

/**
 * @Description BufferedInputStream使用
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) {
        // 过程和InputStream一模一样的
        // 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
        // 在这里，BufferedInputStream构造方法中的InputStream对象，只是用来做当前的对象的实例化，在使用结束的时候，理论上来讲，是需要关闭的
        // 实际在使用中，使用结束后，只需要关闭BufferedInputStream即可。
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
            // 1. 实例化一个字节数组
            byte[] array = new byte[1024];
            // 2. 声明一个整型变量，用来记录每次读取了多少个字节数据
            int length = 0;
            // 3. 循环读取
            while ((length = bufferedInputStream.read(array)) != -1) {
                // 4. 将读取到的数据转成字符串输出到控制台
                String msg = new String(array, 0, length);
                System.out.println(msg);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * @Description BufferedOutputStream
 */
public class BufferedOutputStreamTest {
    public static void main(String[] args) {
        // 1. 实例化一个缓冲字节输出流对象
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target")))  {
            // 2. 将数据写入到输出流中
            bufferedOutputStream.write("hello world".getBytes());
            bufferedOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.3. 缓冲字符流

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        // 借助一个字符流，实例化一个缓冲字符输入流
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 从流中读取数据
            char[] array = new char[100];
            int length = 0;
            while ((length = bufferedReader.read(array)) != -1) {
                System.out.print(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

/**
 * @Description
 */
public class BufferedWriterTest {
    public static void main(String[] args) {
        // 借助一个字符输出流，实例化一个缓冲字符输出流对象
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.4. 缓冲流中的特殊方法

BufferedReader 类中多了一个方法 readLine()

意义: 读取缓冲流中的一行数据，可以逐行读取。一直到读取到的数据是null，表示数据读取完了，没有下一行数据了。
注意事项: readLine() 是逐行读取，但是，只能读取到一行中的内容，并不能读取走换行符。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * @Date 2020/4/26
 * @Description
 */
public class BufferedReaderSpecial {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 1. 定义一个字符串，用来接收每一行读取到的数据
            String line = "";
            // 2. 循环读取数据
            while ((line = reader.readLine()) != null) {
                // 3. 将读取到的数据输出
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedWriter 类中多了一个方法 newLine()

意义：无参的方法，写一个换行符。

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

/**
 * @Description
 */
public class BufferedWriterSpecial {
    public static void main(String[] args) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.newLine();
            bufferedWriter.write("你好，世界");
            bufferedWriter.newLine();
            bufferedWriter.write("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲字符流进行文件的拷贝

import java.io.*;

/**
 * @Description 使用缓冲字符流实现文本文件的拷贝
 */
public class BufferedCopy {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
            String line = "";
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

3.2. Scanner类

3.2.1. 简介

这个类，并不是一个IO流。是一个扫描器，这个类最主要的作用，是从一个文件中或者从一个流中浏览数据。在这个类中封装了若干个方法，方便了数据的读取。

3.2.2. API

注意事项

这里nextLine和BufferedReader中的readLine都可以读取一行数据。但是区别在于：结束条件不同。

BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
Scanner: 如果没有下一行了，再去读取，会出现异常。所以，此时的结束条件是 hasNextLine() 为false。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * @Description Scanner类的方法
 */
public class ScannerTest {
    public static void main(String[] args) {
        // 其实，Scanner在使用结束之后，也是需要进行关闭的。 调用close方法。
        try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
            // 读取文件中的内容
            while (scanner.hasNextLine()) {
                System.out.println(scanner.hasNextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

3.3. 标准输入输出流

3.3.1. 简介

标准输入流: http://System.in : 连接了程序和控制台。读取控制台中的内容。

标准输出流: System.out ：连接了程序和控制台。将程序中的内容输出到控制台。

3.3.2. 标准输入流

import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * @Description 标准输入流
 */
public class SystemInTest {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
            byte[] array = new byte[128];
            int length = 0;
            while ((length = bis.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3.3. 标准输出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * @Description 标准输出流
 */
public class SystemOutTest {
    public static void main(String[] args) {
        PrintStream original = System.out;
        // PrintStream: 是一个打印流，可以将数据输出到指定位置。
        try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
            // ps.println("hello world！");
            // 重定向标准输出流
            System.setOut(ps);

            System.out.println("123");
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.setOut(original);
        }

        System.out.println("你好");

        // System.out;      标准输出流地址
        // System.out -> ps
    }
}

3.4. 转换流

3.4.1. 为什么要用转换流

在进行文件读取的时候，如果项目采用的字符集和文件的字符集不同，会出现乱码的情况。

3.4.2. 输入流

import java.io.*;

/**
 * @Description 转换流
 *      转换输入流：可以以指定的字符集读取某一个文件中的数据
 *      转换输出流：可以以指定的字符集把数据写入到某一个文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        read();
    }
    private static void read() {
        // 当前的项目是 utf-8, 读取的文件是 GBK
        // 如果需要以指定的字符集进行文件的读取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file\\day26\\src"), "GBK")) {
            char[] array = new char[128];
            int length = 0;
            while ((length = reader.read(array)) != -1) {
                System.out.println(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4.3. 输出流

import java.io.*;

/**
 * @Description 转换流
 *      转换输入流：可以以指定的字符集读取某一个文件中的数据
 *      转换输出流：可以以指定的字符集把数据写入到某一个文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        write();
    }

    private static void write() {
        // 以指定的字符集写数据
        try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file\\day26\\dst", true), "GBK")) {
            writer.write("hello world");
            writer.write("你好，世界");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.5. 对象流

3.5.1. 简介

ObjectInputStream、 ObjectOutputStream，主要是用来做对象的序列化和反序列化的。

序列化：将内存中的某个对象，以文件的形式保存到本地。
反序列化：将本地保存的某一个文件，信息读取出来，存到某一个对象中。

序列化、反序列化，是对象的持久化存储的一种常用手段。

3.5.2. 注意事项

所有的要序列化到本地的类的对象，类必须实现 java.io.Serilizable 接口。
如果需要序列化多个文件到本地，尽量不要序列化到一个文件中。如果需要序列化多个文件到本地，通常采用的方式，是村集合。将多个对象存入一个集合中，将这个集合序列化到本地。

3.5.3. 示例代码

import java.io.*;

/**
 * @Description
 */
public class Test {
    public static void main(String[] args) {
        load();
    }

    /**
     * 反序列化
     */
    private static void load() {
        try(ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file\\day26\\person"))) {
            // 读取文件中的数据
            Object obj = inputStream.readObject();

            if (obj instanceof Person) {
                Person xiaoming = (Person)obj;
                System.out.println(xiaoming);
            }

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化
     */
    private static void save() {
        // 实例化一个Person对象
        Person xiaoming = new Person("xiaoming", 12, 100);

        // 序列化对象
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file\\day26\\person"))) {
            // 序列化
            outputStream.writeObject(xiaoming);
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.6. Properties

3.6.1. 简介

Properties也不是一个IO流，是一个集合。是Hashtable的子类。

使用Properties主要是为了描述程序中的属性列表文件。有时候，我们会将一些比较简单的项目的配置信息，以 .properties 格式的文件进行存储。可以使用Properties对象读写 .properties 文件。

3.6.2. 示例代码

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/**


## 写在最后

**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**


需要完整版PDF学习资源私我



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**