Java IO流详解

迈不过友情╰ 2023-07-22 14:30 12阅读 0赞

参考转载地址：[https://blog.csdn.net/zhangliangzi/article/details/51226652][https_blog.csdn.net_zhangliangzi_article_details_51226652]

[http://www.cnblogs.com/ysocean/p/6870069.html][http_www.cnblogs.com_ysocean_p_6870069.html]

[https://www.cnblogs.com/jmsjh/p/7761272.html][https_www.cnblogs.com_jmsjh_p_7761272.html]

[http://blog.csdn.net/hguisu/article/details/7418161][http_blog.csdn.net_hguisu_article_details_7418161]

# 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中采用的便是块IO。

流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。

这里先讲流IO。

--------------------

# 2.流的基本概念 #

在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？

在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:

标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，**java中将输入输出抽象称为流**，就好像水管，将两个容器连接起来。将数据从外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。

**我的理解是：从eclipse输出到文本文件txt中叫输出流，而从文本文件txt输入到eclipse叫作输入流。（所有此时文本文件txt对应是外存，而eclipse对应是内存，可能不太准确但是便于我自己的理解，有问题请指点）。**

流的分类：

**一、根据流向分为输入流和输出流：**

注意输入流和输出流是相对于程序而言的。

输出：把程序(内存)中的内容输出到磁盘、光盘等存储设备中

![format_png][]

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

![format_png 1][]

综合起来：

![format_png 2][]

**二、根据传输数据单位分为字节流和字符流**

![format_png 3][]

上面的也是 Java IO流中的四大基流。这四大基流都是抽象类，其他流都是继承于这四大基流的。

1) 字节流：数据流中最小的数据单元是字节

2)  字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节（**无论中文还是英文都是两个字节**）。

**三、根据功能分为节点流和包装流**

节点流：可以从或向一个特定的地方(节点)读写数据，直接连接数据源。如最常见的是文件的FileReader，还可以是数组、管道、字符串，关键字分别为ByteArray/CharArray，Piped，String。.

处理流（包装流）：并不直接连接数据源，是对一个已存在的流的连接和封装，是一种典型的装饰器设计模式，使用处理流主要是为了更方便的执行输入输出工作，如PrintStream，输出功能很强大，又如BufferedReader提供缓存机制，推荐输出时都使用处理流包装。

一个流对象经过其他流的多次包装，称为流的链接。

注意：一个IO流可以即是输入流又是字节流又或是以其他方式分类的流类型，是不冲突的。比如FileInputStream，它既是输入流又是字节流还是文件节点流。

**四、一些特别的的流类型**

转换流：转换流只有字节流转换为字符流，因为字符流使用起来更方便，我们只会向更方便使用的方向转化。如：InputStreamReader与OutputStreamWriter。

缓冲流：有关键字Buffered，也是一种处理流，为其包装的流增加了缓存功能，提高了输入输出的效率，增加缓冲功能后需要使用flush()才能将缓冲区中内容写入到实际的物理节点。但是，在现在版本的Java中，只需记得关闭输出流（调用close()方法），就会自动执行输出流的flush()方法，可以保证将缓冲区中内容写入。

对象流：有关键字Object，主要用于将目标对象保存到磁盘中或允许在网络中直接传输对象时使用（对象序列化），具体可参看博客[Java序列化与反序列化][Java]。

操作 IO 流的模板：

①、创建源或目标对象

输入：把文件中的数据流向到程序中，此时文件是 源，程序是目标

输出：把程序中的数据流向到文件中，此时文件是目标，程序是源

②、创建 IO 流对象

输入：创建输入流对象

输出：创建输出流对象

③、具体的 IO 操作

④、关闭资源

输入：输入流的 close() 方法

输出：输出流的 close() 方法

**注意：1、程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源。如果不关闭该资源，那么磁盘的文件将一直被程序引用着，不能删除也不能更改。所以应该手动调用 close() 方法关闭流资源**

Java IO 流的整体架构图：

## ##

![format_png 4][]

--------------------

# 3. 标准I/O #

Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

### 1. 命令行参数 ###

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

public class TestArgs {  
        public static void main(String[] args) {  
            for (int i = 0; i < args.length; i++) {  
                System.out.println("args[" + i + "] is <" + args[i] + ">");  
            }  
        }  
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

运行命令：java Java C VB
    
    运行结果：
    
    args[0] is <Java>
    
    args[1] is <C>
    
    args[2] is <VB>

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

### 2. 标准输入，输出数据流 ###

java系统自带的标准数据流：java.lang.System:

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

java.lang.System   
    public final class System  extends Object{   
       static  PrintStream  err;//标准错误流（输出）  
       static  InputStream  in;//标准输入(键盘输入流)  
       static  PrintStream  out;//标准输出流(显示器输出流)  
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

注意：  
（1）System类不能创建对象，只能直接使用它的三个静态成员。  
（2）每当main方法被执行时,就自动生成上述三个对象。

1) 标准输出流 System.out

System.out向标准输出设备输出数据，其数据类型为PrintStream。方法：

Void print(参数)

Void println(参数)

2)标准输入流 System.in

System.in读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为InputStream。方法：

int read()  //返回ASCII码。若,返回值=-1，说明没有读取到任何字节读取工作结束。

int read(byte\[\] b)//读入多个字节到缓冲区b中返回值是读入的字节数

例如：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

import java.io.*;  
    public class StandardInputOutput {  
        public static void main(String args[]) {  
            int b;  
            try {  
                System.out.println("please Input:");  
                while ((b = System.in.read()) != -1) {  
                    System.out.print((char) b);  
                }  
            } catch (IOException e) {  
                System.out.println(e.toString());  
            }  
        }  
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

等待键盘输入，键盘输入什么，就打印出什么：

![1354093989\_4632.jpg][1354093989_4632.jpg]![uploading.4e448015.gif][]转存失败重新上传取消![1354093989_4632.jpg][]

3)标准错误流

System.err输出标准错误，其数据类型为PrintStream。可查阅API获得详细说明。

标准输出通过System.out调用println方法输出参数并换行，而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为boolean、char、int、long、float和double。同时，也重载实现 了输出参数类型为char\[\]、String和Object的方法。其中，print（Object）和println（Object）方法在运行时将调 用参数Object的toString方法。

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

import java.io.BufferedReader;  
    import java.io.IOException;  
    import java.io.InputStreamReader;  
      
    public class StandardInputOutput {  
        public static void main(String args[]) {  
            String s;  
            // 创建缓冲区阅读器从键盘逐行读入数据  
            InputStreamReader ir = new InputStreamReader(System.in);  
            BufferedReader in = new BufferedReader(ir);  
            System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"  
                    + "\nWindows系统: ctrl-z 退出");  
            try {  
                // 读一行数据，并标准输出至显示器  
                s = in.readLine();  
                // readLine()方法运行时若发生I/O错误，将抛出IOException异常  
                while (s != null) {  
                    System.out.println("Read: " + s);  
                    s = in.readLine();  
                }  
                // 关闭缓冲阅读器  
                in.close();  
            } catch (IOException e) { // Catch any IO exceptions.  
                e.printStackTrace();  
            }  
        }  
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

--------------------

# 4.File类 #

在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。（与之类似还有socket）

**File 类：文件和目录路径名的抽象表示。**

**注意：File 类只能操作文件的属性，文件的内容是不能操作的。**

**1、File 类的字段**

**![format_png 5][]**

我们知道，各个平台之间的路径分隔符是不一样的。

①、对于UNIX平台，绝对路径名的前缀始终为`"/"` 。 相对路径名没有前缀。 表示根目录的抽象路径名具有前缀`"/"`和空名称序列。

②、对于Microsoft Windows平台，包含驱动器说明符的路径名的前缀由后面跟着`":"`的驱动器号组成，如果路径名是绝对的，则可能后跟`"\\"` 。 UNC路径名的前缀为`"\\\\"` ; 主机名和共享名称是名称序列中的前两个名称　　　           没有有指定驱动器的相对路径名没有前缀。

那么为了屏蔽各个平台之间的分隔符差异，我们在构造 File 类的时候（如何构造，请看下面第二点），就可以使用上述 Java 为我们提供的字段。

System.out.println(File.separator);//输出 \  
    System.out.println(File.pathSeparator);//输出 ;

File.pathSeparator指的是分隔连续多个路径字符串的分隔符，例如:  
java   -cp   test.jar;abc.jar   HelloWorld  
就是指“;”

File.separator才是用来分隔同一个路径字符串中的目录的，例如：  
C:\\Program Files\\Common Files  
就是指“\\”

**2、File 类的构造方法**

![format_png 6][]

如何使用上述构造方法，请看如下例子：

**定义文件路径时，可以用“/”或者“\\\\”。**

**在创建一个文件时，如果目录下有同名文件将被覆盖。**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//不使用 Java 提供的分隔符字段，注意：这样写只能在 Windows 平台有效
            File f1 = new File("D:\\IO\\a.txt");或者是D:/IO/a.txt
            //使用 Java 提供的分隔符
            File f2 = new File("D:"+File.separator+"IO"+File.separator+"a.txt");
            System.out.println(f1);//输出 D:\IO\a.txt  
            System.out.println(f2);//输出 D:\IO\a.txt
             
            //File(File parent, String child)
            //从父抽象路径名和子路径名字符串创建新的 File实例。
            File f3 = new File("D:");
            File f4 = new File(f3,"IO");
            System.out.println(f4); //D:\IO
             
            //File(String pathname)
            //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
            File f5 = new File("D:"+File.separator+"IO"+File.separator+"a.txt");
            System.out.println(f5); //D:\IO\a.txt
             
            //File(String parent, String child)
            //从父路径名字符串和子路径名字符串创建新的 File实例。
            File f6 = new File("D:","IO\\a.txt");
            System.out.println(f6); //D:\IO\a.txt

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**3、File 类的常用方法**

①、**创建方法**

1.boolean createNewFile() 不存在返回true 存在返回false  
　　　　2.boolean mkdir() 创建目录，如果上一级目录不存在，则会创建失败  
　　　　3.boolean mkdirs() 创建多级目录，如果上一级目录不存在也会自动创建

②、**删除方法**

1.boolean delete() 删除文件或目录，如果表示目录，则目录下必须为空才能删除  
　　　　2.boolean deleteOnExit() 文件使用完成后删除

③、**判断方法**

1.boolean canExecute()判断文件是否可执行  
　　　　2.boolean canRead()判断文件是否可读  
　　　　3.boolean canWrite() 判断文件是否可写  
　　　　4.boolean exists() 判断文件或目录是否存在  
　　　　5.boolean isDirectory()  判断此路径是否为一个目录  
　　　　6.boolean isFile()　　判断是否为一个文件  
　　　　7.boolean isHidden()　　判断是否为隐藏文件  
　　　　8.boolean isAbsolute()判断是否是绝对路径 文件不存在也能判断

④、**获取方法**

1.String getName() 获取此路径表示的文件或目录名称  
　　　　2.String getPath() 将此路径名转换为路径名字符串  
　　　　3.String getAbsolutePath() 返回此抽象路径名的绝对形式  
　　　　4.String getParent()//如果没有父目录返回null  
　　　　5.long lastModified()//获取最后一次修改的时间  
　　　　6.long length() 返回由此抽象路径名表示的文件的长度。  
　　　　7.boolean renameTo(File f) 重命名由此抽象路径名表示的文件。  
　　　　8.File\[\] liseRoots()//获取机器盘符  
　　　　9.String\[\] list()  返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。  
　　　　10.String\[\] list(FilenameFilter filter) 返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录。

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//File(File parent, String child)
            //从父抽象路径名和子路径名字符串创建新的 File实例。
            File dir = new File("D:"+File.separator+"IO");
            File file = new File(dir,"a.txt");
             
            //判断dir 是否存在且表示一个目录
            if(!(dir.exists()||dir.isDirectory())){
                //如果 dir 不存在，则创建这个目录
                dir.mkdirs();
                //根据目录和文件名，创建 a.txt文件
                file.createNewFile();
     
            }
            //返回由此抽象路径名表示的文件或目录的名称。 这只是路径名称序列中的最后一个名字。 如果路径名的名称序列为空，则返回空字符串。
            System.out.println(file.getName()); //a.txt
            //返回此抽象路径名的父null的路径名字符串，如果此路径名未命名为父目录，则返回null。
            System.out.println(file.getParent());//D:\IO
            //将此抽象路径名转换为路径名字符串。 结果字符串使用default name-separator character以名称顺序分隔名称。
            System.out.println(file.getPath()); //D:\IO\a.txt

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**4、File 的一些技巧**

①、打印给定目录下的所有文件夹和文件夹里面的内容

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

public static void getFileList(File file){
            //第一级子目录
            File[] files = file.listFiles();
            for(File f:files){
                //打印目录和文件
                System.out.println(f);
                if(f.isDirectory()){
                    getFileList(f);
                }
            }
        }
    public static void main(String[] args) throws Exception {
         File f = new File("D:"+File.separator+"WebStormFile");
           getFileList(f);
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

--------------------

#  5.字节流InputStream/OutputStream #

字节输入输出流：**InputStream、OutputSteam**(下图红色长方形框内)，红色椭圆框内是其典型实现（FileInputSteam、FileOutStream）

![format_png 7][]

**1、字节输入流：InputStream**

public abstract class InputStream
    　　extends Object
    　　implements Closeable

这个抽象类是表示输入字节流的所有类的超类。

方法摘要：

**　　![format_png 8][]**

下面我们用 字节输出流 InputStream 的典型实现 FileInputStream 来介绍：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//1、创建目标对象，输入流表示那个文件的数据保存到程序中。不写盘符，默认该文件是在该项目的根目录下
                //a.txt 保存的文件内容为：AAaBCDEF
            File target = new File("io"+File.separator+"a.txt");
            //2、创建输入流对象
            InputStream in = new FileInputStream(target);
            //3、具体的 IO 操作（读取 a.txt 文件中的数据到程序中）
                /**
                 * 注意：读取文件中的数据，读到最后没有数据时，返回-1
                 *  int read():读取一个字节，返回读取的字节
                 *  int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节
                 *  int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节
                 */
            //int read():读取一个字节，返回读取的字节
            int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
            System.out.println((char)data1); //A
            //int read(byte[] b):读取多个字节保存到数组b 中
            byte[] buffer  = new byte[10];
            in.read(buffer);//获取 a.txt 文件中的前10 个字节，并存储到 buffer 数组中
            System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
            System.out.println(new String(buffer)); //AaBCDEF[][][]
             
            //int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中,从索引 off 开始到 len
            in.read(buffer, 0, 3);
            System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
            System.out.println(new String(buffer)); //AaB[][][][][][][]
            //4、关闭流资源
            in.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

** 2、字节输出流：OutputStream**

public abstract class OutputStream 
                    extends Object
    　　　　　　      implements Closeable, Flushable

这个抽象类是表示字节输出流的所有类的超类。继承自InputStream  的流都是向程序中输入数据的，且数据单位为字节（8bit）。 输出流接收输出字节并将其发送到某个接收器。

方法摘要：

![format_png 9][]

下面我们用 字节输出流 OutputStream 的典型实现 FileOutputStream 来介绍：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//1、创建目标对象，输出流表示把数据保存到哪个文件。不写盘符，默认该文件是在该项目的根目录下
            File target = new File("io"+File.separator+"a.txt");
            //2、创建文件的字节输出流对象,第二个参数是 Boolean 类型，true 表示后面写入的文件追加到数据后面，false 表示覆盖
            OutputStream out = new FileOutputStream(target,true);
            //3、具体的 IO 操作(将数据写入到文件 a.txt 中)
                /**
                 * void write(int b):把一个字节写入到文件中
                 * void write(byte[] b):把数组b 中的所有字节写入到文件中
                 * void write(byte[] b,int off,int len):把数组b 中的从 off 索引开始的 len 个字节写入到文件中
                 */
            out.write(65); //将 A 写入到文件中
            out.write("Aa".getBytes()); //将 Aa 写入到文件中
            out.write("ABCDEFG".getBytes(), 1, 5); //将 BCDEF 写入到文件中
            //经过上面的操作，a.txt 文件中数据为 AAaBCDEF
             
            //4、关闭流资源
            out.close();
            System.out.println(target.getAbsolutePath());

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

** **

**3、用字节流完成文件的复制**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

/**
             * 将 a.txt 文件 复制到 b.txt 中
             */
            //1、创建源和目标
            File srcFile = new File("io"+File.separator+"a.txt");
            File descFile = new File("io"+File.separator+"b.txt");
            //2、创建输入输出流对象
            InputStream in = new FileInputStream(srcFile);
            OutputStream out = new FileOutputStream(descFile);
            //3、读取和写入操作
            byte[] buffer = new byte[10];//创建一个容量为 10 的字节数组，存储已经读取的数据
            int len = -1;//表示已经读取了多少个字节，如果是 -1，表示已经读取到文件的末尾
            while((len=in.read(buffer))!=-1){
                //打印读取的数据
                System.out.println(new String(buffer,0,len));
                //将 buffer 数组中从 0 开始，长度为 len 的数据读取到 b.txt 文件中
                out.write(buffer, 0, len);
            }
            //4、关闭流资源
            out.close();
            in.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

--------------------

# 6.字符流Reader/Writer #

字节输入输出流：**Reader、Writer**(下图红色长方形框内)，红色椭圆框内是其典型实现（FileReader、FileWriter）

![format_png 10][]

**①、为什么要使用字符流？**

因为使用字节流操作汉字或特殊符号语言的时候容易乱码，因为汉字不止一个字节，为了解决这个问题，建议使用字符流。

**②、什么情况下使用字符流？**

一般可以用记事本打开的文件，我们可以看到内容不乱码的。就是文本文件，可以使用字符流。而操作二进制文件（比如图片、音频、视频）必须使用字节流

** 1、字符输出流：FileWriter**

public abstract class Writer
    　　extends Object
    　　implements Appendable, Closeable, Flushable

用于写入字符流的抽象类

方法摘要：

![format_png 11][]

下面我们用 字符输出流 Writer  的典型实现 FileWriter 来介绍这个类的用法：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//1、创建源
            File srcFile = new File("io"+File.separator+"a.txt");
            //2、创建字符输出流对象
            Writer out = new FileWriter(srcFile);
            //3、具体的 IO 操作
                /***
                 * void write(int c):向外写出一个字符
                 * void write(char[] buffer):向外写出多个字符 buffer
                 * void write(char[] buffer,int off,int len):把 buffer 数组中从索引 off 开始到 len个长度的数据写出去
                 * void write(String str):向外写出一个字符串
                 */
            //void write(int c):向外写出一个字符
            out.write(65);//将 A 写入 a.txt 文件中
            //void write(char[] buffer):向外写出多个字符 buffer
            out.write("Aa帅锅".toCharArray());//将 Aa帅锅 写入 a.txt 文件中
            //void write(char[] buffer,int off,int len)
            out.write("Aa帅锅".toCharArray(),0,2);//将 Aa 写入a.txt文件中
            //void write(String str):向外写出一个字符串
            out.write("Aa帅锅");//将 Aa帅锅 写入 a.txt 文件中
             
            //4、关闭流资源
            /***
             * 注意如果这里有一个 缓冲的概念，如果写入文件的数据没有达到缓冲的数组长度，那么数据是不会写入到文件中的
             * 解决办法：手动刷新缓冲区 flush()
             * 或者直接调用 close() 方法，这个方法会默认刷新缓冲区
             */
            out.flush();
            out.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

** 2、字符输入流：Reader**

public abstract class Reader
    　　extends Object
    　　implements Readable, Closeable

用于读取字符流的抽象类。

方法摘要：

![format_png 12][]

下面我们用 字符输入流 Reader  的典型实现 FileReader 来介绍这个类的用法：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//1、创建源
            File srcFile = new File("io"+File.separator+"a.txt");
            //2、创建字符输出流对象
            Reader in = new FileReader(srcFile);
            //3、具体的 IO 操作
                /***
                 * int read():每次读取一个字符，读到最后返回 -1
                 * int read(char[] buffer):将字符读进字符数组,返回结果为读取的字符数
                 * int read(char[] buffer,int off,int len):将读取的字符存储进字符数组 buffer，返回结果为读取的字符数，从索引 off 开始，长度为 len
                 *
                 */
            //int read():每次读取一个字符，读到最后返回 -1
            int len = -1;//定义当前读取字符的数量
            while((len = in.read())!=-1){
                //打印 a.txt 文件中所有内容
                System.out.print((char)len);
            }
             
            //int read(char[] buffer):将字符读进字符数组
            char[] buffer = new char[10]; //每次读取 10 个字符
            while((len=in.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
             
            //int read(char[] buffer,int off,int len)
            while((len=in.read(buffer,0,10))!=-1){
                System.out.println(new String(buffer,0,len));
            }
            //4、关闭流资源
            in.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**3、用字符流完成文件的复制**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

/**
             * 将 a.txt 文件 复制到 b.txt 中
             */
            //1、创建源和目标
            File srcFile = new File("io"+File.separator+"a.txt");
            File descFile = new File("io"+File.separator+"b.txt");
            //2、创建字符输入输出流对象
            Reader in = new FileReader(srcFile);
            Writer out = new FileWriter(descFile);
            //3、读取和写入操作
            char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据
            int len = -1;//表示已经读取了多少个字节，如果是 -1，表示已经读取到文件的末尾
            while((len=in.read(buffer))!=-1){
                out.write(buffer, 0, len);
            }
             
            //4、关闭流资源
            out.close();
            in.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

--------------------

# 7.包装流（包含缓冲流，转换流对象流等等） #

①、包装流隐藏了底层节点流的差异，并对外提供了更方便的输入\\输出功能，让我们只关心这个高级流的操作

②、使用包装流包装了节点流，程序直接操作包装流，而底层还是节点流和IO设备操作

③、**关闭包装流的时候，只需要关闭包装流即可**

**1、缓冲流**

![format_png 13][]

缓冲流：是一个包装流，目的是缓存作用，加快读取和写入数据的速度。

字节缓冲流：BufferedInputStream、BufferedOutputStream

字符缓冲流：BufferedReader、BufferedWriter

**案情回放：我们在将字符输入输出流、字节输入输出流的时候，读取操作，通常都会定义一个字节或字符数组，将读取/写入的数据先存放到这个数组里面，然后在取数组里面的数据。这比我们一个一个的读取/写入数据要快很多，而这也就是缓冲流的由来。只不过缓冲流里面定义了一个 数组用来存储我们读取/写入的数据，当内部定义的数组满了（注意：我们操作的时候外部还是会定义一个小的数组，小数组放入到内部数组中），就会进行下一步操作。　**

![format_png 14][]

下面是没有用缓冲流的操作：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//1、创建目标对象，输入流表示那个文件的数据保存到程序中。不写盘符，默认该文件是在该项目的根目录下
                //a.txt 保存的文件内容为：AAaBCDEF
            File target = new File("io"+File.separator+"a.txt");
            //2、创建输入流对象
            InputStream in = new FileInputStream(target);
            //3、具体的 IO 操作（读取 a.txt 文件中的数据到程序中）
                /**
                 * 注意：读取文件中的数据，读到最后没有数据时，返回-1
                 *  int read():读取一个字节，返回读取的字节
                 *  int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节
                 *  int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节
                 */
            //int read():读取一个字节，返回读取的字节
            int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
            System.out.println((char)data1); //A
            //int read(byte[] b):读取多个字节保存到数组b 中
            byte[] buffer  = new byte[10];//这里我们定义了一个 长度为 10 的字节数组，用来存储读取的数据
            in.read(buffer);//获取 a.txt 文件中的前10 个字节，并存储到 buffer 数组中
            System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
            System.out.println(new String(buffer)); //AaBCDEF[][][]
             
            //int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中,从索引 off 开始到 len
            in.read(buffer, 0, 3);
            System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
            System.out.println(new String(buffer)); //AaB[][][][][][][]
            //4、关闭流资源
            in.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

我们查看 缓冲流的 JDK 底层源码，可以看到，程序中定义了这样的 缓存数组,大小为 8192

**BufferedInputStream:**

![format_png 15][]

**BufferedOutputStream:**

![format_png 16][]

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//字节缓冲输入流
            BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream("io"+File.separator+"a.txt"));
            //定义一个字节数组，用来存储数据
            byte[] buffer = new byte[1024];
            int len = -1;//定义一个整数，表示读取的字节数
            while((len=bis.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
            //关闭流资源
            bis.close();<br><br>
             
            //字节缓冲输出流
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream("io"+File.separator+"a.txt"));
            bos.write("ABCD".getBytes());
            bos.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//字符缓冲输入流
            BufferedReader br = new BufferedReader(
                    new FileReader("io"+File.separator+"a.txt"));
            char[] buffer = new char[10];
            int len = -1;
            while((len=br.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
            br.close();
             
            //字符缓冲输出流
            BufferedWriter bw = new BufferedWriter(
                    new FileWriter("io"+File.separator+"a.txt"));
            bw.write("ABCD");
            bw.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**2、转换流：把字节流转换为字符流**

**　　InputStreamReader:把字节输入流转换为字符输入流**

**　　OutputStreamWriter:把字节输出流转换为字符输出流**

![format_png 17][]

用转换流进行文件的复制：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

/**
             * 将 a.txt 文件 复制到 b.txt 中
             */
            //1、创建源和目标
            File srcFile = new File("io"+File.separator+"a.txt");
            File descFile = new File("io"+File.separator+"b.txt");
            //2、创建字节输入输出流对象
            InputStream in = new FileInputStream(srcFile);
            OutputStream out = new FileOutputStream(descFile);
            //3、创建转换输入输出对象
            Reader rd = new InputStreamReader(in);
            Writer wt = new OutputStreamWriter(out);
            //3、读取和写入操作
            char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据
            int len = -1;//表示已经读取了多少个字符，如果是 -1，表示已经读取到文件的末尾
            while((len=rd.read(buffer))!=-1){
                wt.write(buffer, 0, len);
            }
            //4、关闭流资源
            rd.close();
            wt.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

### **转换流和子类区别** ###

发现有如下继承关系：

OutputStreamWriter:

|--FileWriter:

InputStreamReader:

|--FileReader;

父类和子类的功能有什么区别呢？

OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。

FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

FileReader fr = new FileReader("a.txt");

这三句代码的功能是一样的，其中第三句最为便捷。

注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。什么时候用子类呢？

条件：

1、操作的是文件。2、使用默认编码。

总结：

字节--->字符 ： 看不懂的--->看的懂的。  需要读。输入流。 InputStreamReader

字符--->字节 ： 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

**3、内存流（数组流）：**

**　　**把数据先临时存在数组中，也就是内存中。所以关闭 内存流是无效的，关闭后还是可以调用这个类的方法。底层源码的 close()是一个空方法

![format_png 18][]

①、字节内存流：ByteArrayOutputStream 、ByteArrayInputStream

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//字节数组输出流：程序---》内存
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            //将数据写入到内存中
            bos.write("ABCD".getBytes());
            //创建一个新分配的字节数组。 其大小是此输出流的当前大小，缓冲区的有效内容已被复制到其中。
            byte[] temp = bos.toByteArray();
            System.out.println(new String(temp,0,temp.length));
             
            byte[] buffer = new byte[10];
            ///字节数组输入流：内存---》程序
            ByteArrayInputStream bis = new ByteArrayInputStream(temp);
            int len = -1;
            while((len=bis.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
             
            //这里不写也没事，因为源码中的 close()是一个空的方法体
            bos.close();
            bis.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

②、字符内存流：CharArrayReader、CharArrayWriter

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//字符数组输出流
            CharArrayWriter caw = new CharArrayWriter();
            caw.write("ABCD");
            //返回内存数据的副本
            char[] temp = caw.toCharArray();
            System.out.println(new String(temp));
             
            //字符数组输入流
            CharArrayReader car = new CharArrayReader(temp);
            char[] buffer = new char[10];
            int len = -1;
            while((len=car.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

③、字符串流：StringReader,StringWriter（把数据临时存储到字符串中）

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//字符串输出流,底层采用 StringBuffer 进行拼接
            StringWriter sw = new StringWriter();
            sw.write("ABCD");
            sw.write("帅锅");
            System.out.println(sw.toString());//ABCD帅锅
     
            //字符串输入流
            StringReader sr = new StringReader(sw.toString());
            char[] buffer = new char[10];
            int len = -1;
            while((len=sr.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));//ABCD帅锅
            }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**4、合并流：把多个输入流合并为一个流，也叫顺序流，因为在读取的时候是先读第一个，读完了在读下面一个流。**

![format_png 19][]

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//定义字节输入合并流
            SequenceInputStream seinput = new SequenceInputStream(
                    new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));
            byte[] buffer = new byte[10];
            int len = -1;
            while((len=seinput.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }
             
            seinput.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

--------------------

# 8.序列化与反序列化（对象流） #

**1、什么是序列化与反序列化？**

**　　**序列化：指把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。这个过程称为序列化。通俗来说就是将数据结构或对象转换成二进制串的过程

反序列化：把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

**2、为什么要做序列化？**

①、在分布式系统中，此时需要把对象在网络上传输，就得把对象数据转换为二进制形式，需要共享的数据的 JavaBean 对象，都得做序列化。

②、服务器钝化：如果服务器发现某些对象好久没活动了，那么服务器就会把这些内存中的对象持久化在本地磁盘文件中（Java对象转换为二进制文件）；如果服务器发现某些对象需要活动时，先去内存中寻找，找不到再去磁盘文件中反序列化我们的对象数据，恢复成 Java 对象。这样能节省服务器内存。

**3、Java 怎么进行序列化？**

①、需要做序列化的对象的类，必须实现序列化接口：Java.lang.Serializable 接口（这是一个标志接口，没有任何抽象方法），Java 中大多数类都实现了该接口，比如：String，Integer

②、底层会判断，如果当前对象是 Serializable 的实例，才允许做序列化，Java对象 instanceof Serializable 来判断。

③、在 Java 中使用对象流来完成序列化和反序列化

**ObjectOutputStream**:通过 writeObject()方法做序列化操作

**ObjectInputStream**:通过 readObject() 方法做反序列化操作

**　　　　![format_png 20][]**

** 第一步：创建一个 JavaBean 对象**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

public class Person implements Serializable{
        private String name;
        private int age;
         
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**第二步：使用 ObjectOutputStream 对象实现序列化**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

//在根目录下新建一个 io 的文件夹
            OutputStream op = new FileOutputStream("io"+File.separator+"a.txt");
            ObjectOutputStream ops = new ObjectOutputStream(op);
            ops.writeObject(new Person("vae",1));
             
            ops.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

我们打开 a.txt 文件，发现里面的内容乱码，注意这不需要我们来看懂，这是二进制文件，计算机能读懂就行了。

错误一：如果新建的 Person 对象没有实现 Serializable 接口，那么上面的操作会报错：

![format_png 21][]

**第三步：使用ObjectInputStream 对象实现反序列化**

**　　反序列化的对象必须要提供该对象的字节码文件.class**

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

InputStream in = new FileInputStream("io"+File.separator+"a.txt");
            ObjectInputStream os = new ObjectInputStream(in);
            byte[] buffer = new byte[10];
            int len = -1;
            Person p = (Person) os.readObject();
            System.out.println(p);  //Person [name=vae, age=1]
            os.close();

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

问题1：如果某些数据不需要做序列化，比如密码，比如上面的年龄？

解决办法：在字段面前加上 transient

private String name;//需要序列化
        transient private int age;//不需要序列化

那么我们在反序列化的时候，打印出来的就是Person \[name=vae, age=0\]，整型数据默认值为 0

问题2：序列化版本问题，在完成序列化操作后，由于项目的升级或修改，可能我们会对序列化对象进行修改，比如增加某个字段，那么我们在进行反序列化就会报错：

![format_png 22][]

![format_png 23][]

解决办法：在 JavaBean 对象中增加一个 serialVersionUID 字段，用来固定这个版本，无论我们怎么修改，版本都是一致的，就能进行反序列化了

private static final long serialVersionUID = 8656128222714547171L;

--------------------

# 9.随机访问文件流 #

--------------------

# 字节流与字符流的区别 #

[ https://blog.csdn.net/cynhafa/article/details/6882061][https_blog.csdn.net_cynhafa_article_details_6882061]

[https_blog.csdn.net_zhangliangzi_article_details_51226652]: https://blog.csdn.net/zhangliangzi/article/details/51226652
[http_www.cnblogs.com_ysocean_p_6870069.html]: http://www.cnblogs.com/ysocean/p/6870069.html
[https_www.cnblogs.com_jmsjh_p_7761272.html]: https://www.cnblogs.com/jmsjh/p/7761272.html
[http_blog.csdn.net_hguisu_article_details_7418161]: http://blog.csdn.net/hguisu/article/details/7418161
[format_png]: /images/20230528/349f237806e04ac698ab3e582d3bcd7b.png
[format_png 1]: /images/20230528/2c9ee64d3b33486e94c1cf71f09033ca.png
[format_png 2]: /images/20230528/3b29de20d8f84122954b5a9f49fe0cd9.png
[format_png 3]: /images/20230528/a1abbf2e106c41abb70b16224a2a6ce1.png
[Java]: http://blog.csdn.net/zhangliangzi/article/details/50605640
[format_png 4]: /images/20230528/3002ac3836e840b78d733c9241804c56.png
[aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]: /images/20230528/9c2a954d6979405188880b6c30f420fa.png
[1354093989_4632.jpg]: https://img-my.csdn.net/uploads/201211/28/1354093989_4632.jpg
[uploading.4e448015.gif]: https://csdnimg.cn/release/mp/img/uploading.4e448015.gif
[format_png 5]: /images/20230528/68d2d4da473a41f1bb83b24094a94292.png
[format_png 6]: /images/20230528/64e576bceff7450aaf63c06939ac1aaa.png
[format_png 7]: /images/20230528/61e83153e2f5484f979609321c9f6511.png
[format_png 8]: /images/20230528/34b386a1797d4e239f44705386923913.png
[format_png 9]: /images/20230528/263e1bd7ef6b4e4299ceeaa6ca9202d1.png
[format_png 10]: /images/20230528/114a0be76b464564a9e34b001c893f01.png
[format_png 11]: /images/20230528/7b024cd787cd41ddb7e3532545887b87.png
[format_png 12]: /images/20230528/aaf786a0e5444ca593c1fb395da73807.png
[format_png 13]: /images/20230528/996695f528a64c39a770f6bae32352a6.png
[format_png 14]: /images/20230528/d2c21243289e4fbb918ac5ae736f2a52.png
[format_png 15]: /images/20230528/a938aa8acb1641d68f39b7e13d9210dd.png
[format_png 16]: /images/20230528/6da7d0ec7f6a4029b70e36d89e60cda9.png
[format_png 17]: /images/20230528/49ece96656b74a62a8ed5293c05d2435.png
[format_png 18]: /images/20230528/3d7d05a7c191439e8f84a1c10f63fc5f.png
[format_png 19]: /images/20230528/c067880f1e4646e8820cab25408bb985.png
[format_png 20]: /images/20230528/928ccdbccb214239a704242a8cd4811b.png
[format_png 21]: /images/20230528/400d1da14be745b3a3c894bfa179e52c.png
[format_png 22]: /images/20230528/9d8840817fce4819a04db4a73273a5c1.png
[format_png 23]: /images/20230528/c647765f99184bba86c438c9698d9ac3.png
[https_blog.csdn.net_cynhafa_article_details_6882061]: https://blog.csdn.net/cynhafa/article/details/6882061