day15【转换流、缓冲流、序列流、打印流】

向右看齐 2022-09-03 07:28 175阅读 0赞

# day15【转换流、缓冲流、序列流、打印流】 #

# 一、转换流 #

## 1.1 字符编码和字符集 ##

### 1.1.1 编码与解码 ###

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为**编码** 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为**解码** 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致**乱码**现象。

### 1.1.2 字符集与编码 ###

*  `字符集(charset)`：**字符集简单来说就是指字符的集合**，例如所有的英文字母是一个字符集，所有的汉字是一个字符集，当然，把全世界所有语言的符号都放在一起，也可以称为一个字符集。计算机中的字符包括文字、图形符号、数学符号等；

拿汉字中的“汉”这个字符来说，我们看到的这个“汉”其实是这个字符的一种具体表现形式，是它的图像表现形式，而且它是用中文（而非拼音）书写而成，使用宋体外观；因此同一个字符的表现形式可能有无数种，把每一种的表现形式下的同一个字符都纳入到字符集中，会使得字符集过于庞大；

**因此字符集中的字符，都是指唯一存在的抽象字符，而忽略了它的具体表现形式。在给定一个抽象字符集合中的每个字符都分配了一个整数编号之后，这个字符集就有了顺序，就成为了编码字符集。同时，这个编号，可以唯一确定到底指的是哪一个字符（哪一种具体形式）**

### 1.1.3 字符集与编码的关系（了解，科普作用） ###

字符集与编码的关系图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

在早期，字符集与编码是一对一的。有很多的字符编码方案，一个字符集只有唯一一个编码实现，两者是一一对应的。比如 GB2312，这种情况，无论你怎么去称呼它们，比如“GB2312编码”，“GB2312字符集”，说来说去其实都是一个东西，可能它本身就没有特意去做什么区分，所以无论怎么说都不会错。

到了 Unicode，变得不一样了，唯一的 Unicode 字符集对应了三种编码：UTF-8，UTF-16，UTF-32。字符集和编码等概念被彻底分离且模块化，其实是 Unicode 时代才得到广泛认同的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

从上图可以很清楚地看到，

**1、编码是依赖于字符集的，就像代码中的接口实现依赖于接口一样；**

**2、一个字符集可以有多个编码实现，就像一个接口可以有多个实现类一样。**

*  为什么 Unicode 这么特殊？

搞出新的字符集标准，无外乎是旧的字符集里的字符不够用了。Unicode 的目标是统一所有的字符集，囊括所有的字符，因此再去整什么新的字符集就没必要了。

但如果觉得它现有的编码方案不太好呢？在不能弄出新的字符集情况下，只能在编码方面做文章了，于是就有了多个实现，这样一来传统的一一对应关系就打破了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

> 从上图可以看出，由于历史方面的原因，你还会在不少地方看到把 Unicode 和 UTF-8 混在一块的情况，这种情况下的 Unicode 通常就是 UTF-16 或者是更早的 UCS-2 编码。

## 1.2 编码的问题 ##

当文本写入时的编码与读取时的编码不一致时就会出现乱码的现象；

准备两个文件，一个采用GB2312编码，一个采用UTF-8编码，使用Notepad++编辑器可编辑：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

准备Java代码分别读取两个文件：

package com.dfbz.demo01;
    
    import java.io.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws IOException { 
            FileReader fr = new FileReader("C:\\Users\\Horizon\\Desktop\\hello.txt");
            int read;
            while ((read = fr.read()) != -1) { 
                System.out.print((char)read);
            }
            fr.close();
        }
    }

发现在读取GB2312时出现中文乱码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

这是因为IDEA默认情况下都是采用UTF-8进行编码与解码，平常我们在操作时感觉不到编码的问题；而我们手动编辑了一个文本文件以GB2312的编码格式保存，此时再使用UTF-8编码进行读取就出现乱码问题；

## 1.3 转换输入流 ##

转换流`java.io.InputStreamReader`，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

### 1.3.1 构造方法 ###

*  `InputStreamReader(InputStream in)`: 创建一个使用默认字符集的字符流。
 *  `InputStreamReader(InputStream in, String charsetName)`: 创建一个指定字符集的字符流。

示例代码：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
    InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

### 1.3.2 使用转换输入流读取 ###

package com.dfbz.demo01;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 定义文件路径,文件为gbk编码
            String filename = "C:\\Users\\Horizon\\Desktop\\hello.txt";
            // 创建流对象,指定GBK编码(默认UTF-8编码)
            InputStreamReader isr = new InputStreamReader(new FileInputStream(filename), "GB2312");
    
            // 定义变量,保存字符
            int read;
    
            // 使用指定编码字符流读取,正常解析
            while ((read = isr.read()) != -1) { 
                System.out.print((char) read);// 你好
            }
            isr.close();
        }
    }

## 1.4 转换输出流 ##

转换流`java.io.OutputStreamWriter` ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

### 1.4.1 构造方法 ###

*  `OutputStreamWriter(OutputStream in)`: 创建一个使用默认字符集的字符流。
 *  `OutputStreamWriter(OutputStream in, String charsetName)`: 创建一个指定字符集的字符流。

示例代码：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
    OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

### 1.4.2 使用转换输出流写文件 ###

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws IOException { 
            // 定义文件路径
            String filename = "osw.txt";
    
            // 创建流对象,指定GBK编码
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filename), "UTF-8");
    
            // 写出数据
            osw.write("你好");    // 保存为4个字节
            osw.close();
        }
    }

> UTF-8编码表中一个中文汉字占3个字节，GBK则占2个字节；

# 二、缓冲流 #

计算机访问外部设备或文件，要比直接访问内存慢的多。如果我们每次调用read()方法或者writer()方法访问外部的设备或文件，CPU就要花上最多的时间是在等外部设备响应，而不是数据处理。为此，我们开辟一个内存缓冲区的内存区域，程序每次调用read()方法或writer()方法都是读写在这个缓冲区中。当这个缓冲区被装满后，系统才将这个缓冲区的内容一次集中写到外部设备或读取进来给CPU。使用缓冲区可以有效的提高CPU的使用率，能提高整个计算机系统的效率。

## 2.1 缓冲流的分类 ##

缓冲流是针对4个顶层父类的流的增强，分为：

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center"><strong>输入缓冲流</strong></th> 
   <th align="center">输出缓冲流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>字节缓冲流</strong></td> 
   <td align="center">BufferedInputStream</td> 
   <td align="center">BufferedOutputStream</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>字符缓冲流</strong></td> 
   <td align="center">BufferedReader</td> 
   <td align="center">BufferedWriter</td> 
  </tr> 
 </tbody> 
</table>

缓冲流在读取/写出数据时，内置有一个默认大小为8192字节/字符的缓冲区数组，当发生一次IO时读满8192个字节再进行操作，从而提高读写的效率。

## 2.2 字节缓冲流 ##

### 2.2.1 构造方法 ###

*  `public BufferedInputStream(InputStream in)` ：创建一个 新的缓冲输入流。
 *  `public BufferedOutputStream(OutputStream out)`： 创建一个新的缓冲输出流。

示例代码：

// 创建字节缓冲输入流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
    // 创建字节缓冲输出流
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

### 2.2.2 使用字节缓冲流 ###

我们分别使用普通流和缓冲流对一个大小为10.4MB的文件进行拷贝，查看两种方案所花费的时间；

*  使用普通流：

package com.dfbz.demo01;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 记录开始时间
            long start = System.currentTimeMillis();
            // 创建流对象
            try (
                    FileInputStream fis = new FileInputStream("D:\\apache-tomcat-8.0.43.zip");
                    FileOutputStream fos = new FileOutputStream("D:\\apache-tomcat-8.0.43_bak.zip")
            ) { 
                // 读写数据
                int b;
                while ((b = fis.read()) != -1) { 
                    fos.write(b);
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
            // 记录结束时间
            long end = System.currentTimeMillis();
            System.out.println("普通流复制时间:" + (end - start) + " 毫秒");
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

*  使用缓冲流拷贝：

package com.dfbz.demo01;
    
    import java.io.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 记录开始时间
            long start = System.currentTimeMillis();
            // 创建流对象
            try (
                    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\apache-tomcat-8.0.43.zip"));
                    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\apache-tomcat-8.0.43_bak.zip"));
            ){ 
                // 读写数据
                int b;
                while ((b = bis.read()) != -1) { 
                    bos.write(b);
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
            // 记录结束时间
            long end = System.currentTimeMillis();
            System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

可以看出，缓冲流拷贝文件的效率比普通流高太多太多，因此我们在做大文件拷贝时应该尽量选用缓冲流；

## 2.3 字符缓冲流 ##

在字节缓冲流中，内部维护了一个8192大小的一个字节数组，字符流则是内部维护了一个8192大小的字符数组；在一次IO时读取8192个字符，提升读取/写入性能。另外，字符缓冲流在普通流的基础上添加了一些独特的方法，让我们读取/写出字符更加方便；

### 2.3.1 构造方法 ###

*  `public BufferedReader(Reader in)` ：创建一个 新的缓冲输入流。
 *  `public BufferedWriter(Writer out)`： 创建一个新的缓冲输出流。

示例代码：

// 创建字符缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("br.txt"));
    
    // 创建字符缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

### 2.3.2 常用方法 ###

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

*  BufferedReader：`public String readLine()`: 读一行文字。
 *  BufferedWriter：`public void newLine()`: 写一行行分隔符,由系统属性定义符号。

`newLine`方法示例代码如下：

package com.dfbz.demo02;
    
    import java.io.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws IOException { 
            // 创建流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));
            // 写出数据
            bw.write("我是");
            // 写出换行
            bw.newLine();
    
            bw.write("中国");
            bw.newLine();
    
            bw.write("人");
            bw.newLine();
    
            // 释放资源
            bw.close();
        }
    }

`readLine`方法示例代码如下：

package com.dfbz.demo02;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws IOException { 
            // 创建流对象
            BufferedReader br = new BufferedReader(new FileReader("test.txt"));
            // 定义字符串,保存读取的一行文字
            String line  = null;
            // 循环读取,读取到最后返回null
            while ((line = br.readLine())!=null) { 
                System.out.println(line);
            }
            // 释放资源
            br.close();
        }
    }

# 三、序列流 #

## 3.1 序列化概述 ##

Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

## 3.2 对象输出流 ##

`java.io.ObjectOutputStream` 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

### 3.2.1 构造方法 ###

*  `public ObjectOutputStream(OutputStream out)`： 创建一个指定OutputStream的ObjectOutputStream。

示例代码：

FileOutputStream fileOut = new FileOutputStream("goods.txt");
    ObjectOutputStream out = new ObjectOutputStream(fileOut);

### 3.2.2 对象的序列化 ###

一个对象要想序列化，必须满足两个条件:

*  该类必须实现`java.io.Serializable` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。
 *  该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。

写出对象方法：

*  `public final void writeObject (Object obj)` : 将指定的对象写出。

准备一个对象：

package com.dfbz.demo01;
    
    import java.io.Serializable;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Goods implements Serializable { 
    
        // 标题
        private String title;
    
        // 价格
        private Double price;
    
        // 库存
        private transient Integer store;        // transient修饰的成员不会被序列化
    
        public Goods() { 
        }
    
        public Goods(String title, Double price, Integer store) { 
            this.title = title;
            this.price = price;
            this.store = store;
        }
    
        public String getTitle() { 
            return title;
        }
    
        public void setTitle(String title) { 
            this.title = title;
        }
    
        public Double getPrice() { 
            return price;
        }
    
        public void setPrice(Double price) { 
            this.price = price;
        }
    
        public Integer getStore() { 
            return store;
        }
    
        public void setStore(Integer store) { 
            this.store = store;
        }
    
        @Override
        public String toString() { 
            return "Goods{" +
                    "title='" + title + '\'' +
                    ", price=" + price +
                    ", store=" + store +
                    '}';
        }
    }

测试代码：

package com.dfbz.demo01;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            Goods goods = new Goods("赣南脐橙",20.0D,20000);
            try { 
                // 创建序列化流对象
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("goods.txt"));
                // 写出对象
                oos.writeObject(goods);     // title、price被序列化，store没有被序列化。
                // 释放资源
                oos.close();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

## 3.3 对象输入流 ##

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

### 3.3.1 构造方法 ###

*  `public ObjectInputStream(InputStream in)`： 创建一个指定InputStream的ObjectInputStream。

### 3.3.2 对象的反序列化 ###

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用`ObjectInputStream`读取对象的方法：

*  `public final Object readObject ()` : 读取一个对象。

package com.dfbz.demo01;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
            Goods goods = null;
            try { 
                // 创建反序列化流
                FileInputStream fis = new FileInputStream("goods.txt");
                ObjectInputStream ois = new ObjectInputStream(fis);
                // 读取一个对象
                goods = (Goods) ois.readObject();
                // 释放资源
                fis.close();
                ois.close();
            } catch (IOException | ClassNotFoundException e) { 
                // 捕获其他异常
                e.printStackTrace();
            }
            
            System.out.println(goods.toString());   // Goods{title='赣南脐橙', price=20.0, store=null}
            
        }
    }

### 3.3.3 序列化版本号 ###

**当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个`InvalidClassException`异常**。发生这个异常的原因如下：

*  1）该类的序列版本号与从流中读取的类描述符的版本号不匹配
 *  2）该类包含未知数据类型
 *  3）该类没有可访问的无参数构造方法

`Serializable` 接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID` 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

package com.dfbz.demo01;
    
    import java.io.Serializable;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Goods implements Serializable { 
    
        // 序列化版本号
        private static final long serialVersionUID = 1L;
    
        // 标题
        private String title;
    
        // 价格
        private Double price;
        
        private transient Integer store;        // transient修饰的成员不会被序列化
    }

> 对象在序列化时，如果指定了序列号，那么在反序列化时会默认读取到上次序列化时的序列化，即使类已经修改过也没有关系；

## 3.4 序列化案例 ##

1.  将存有多个自定义对象的集合序列化操作，保存到`list.txt`文件中。
2.  反序列化`list.txt` ，并遍历集合，打印对象信息。

### 3.4.1 案例分析 ###

1.  把若干学生对象 ，保存到集合中。
2.  把集合序列化。
3.  反序列化读取时，只需要读取一次，转换为集合类型。
4.  遍历集合，可以打印所有的学生信息

### 3.4.2 案例实现 ###

package com.dfbz.demo02;
    
    import com.dfbz.demo02.Book;
    
    import java.io.*;
    import java.util.ArrayList;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws Exception { 
            // 创建 学生对象
            Book book1 = new Book("《西游记》", "吴承恩");
            Book book2 = new Book("《三国演义》", "罗贯中");
            Book book3 = new Book("《水浒传》", "施耐庵");
            Book book4 = new Book("《红楼梦》", "曹雪芹");
    
            ArrayList<Book> bookList = new ArrayList<>();
            bookList.add(book1);
            bookList.add(book2);
            bookList.add(book3);
            bookList.add(book4);
    
    // serialize(bookList);
            deserialize(bookList);
        }
    
        public static void serialize(ArrayList<Book> bookList) throws IOException { 
            // 创建 序列化流
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
            // 写出对象
            oos.writeObject(bookList);
            // 释放资源
            oos.close();
        }
    
        public static void deserialize(ArrayList<Book> bookList) throws Exception { 
            // 反序列化
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
            // 读取对象,强转为ArrayList类型
            ArrayList<Book> list = (ArrayList<Book>) ois.readObject();
    
            System.out.println(list);
        }
    }

# 四、打印流 #

## 4.1 打印流概述 ##

打印流`java.io.PrintStream`类是`OutputStream`的一个子类，因此也是属于字节输出流。打印流的功能主要是将数据打印（输出）到控制台，方便我们输出的；

我们平时向控制台输出内容都是借助打印流来完成的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

## 4.2 打印流的使用 ##

### 4.2.1 构造方法 ###

*  `public PrintStream(String fileName)`： 使用指定的文件名创建一个新的打印流。

示例代码：

PrintStream ps = new PrintStream("ps.txt")；

### 4.2.2 打印流输出内容 ###

*  `public void println(String x)`：将指定的字符串输出
 *  `public void println(int x)`：将指定的整形输出

> 我们之前通过`System.out`获取到的就是一个打印流，因此打印流的方法不多赘述；

示例代码：

package com.dfbz.demo01;
    
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintStream;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws FileNotFoundException { 
            PrintStream ps = new PrintStream("ps.txt");
    
            // 打印并换行
            ps.println("我是");
            ps.println("中国");
            ps.println("人");
    
            ps.close();
        }
    }

## 4.3 标准输入输出流 ##

### 4.3.1 标准输入流 ###

标准输入流是一个缓冲字节输入流（BufferedInputStream），他默认指向的是控制台（键盘），通过`System.in`获取；

我们之前在用Scanner的时候，构造方法如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

System.in获取的就是标准输入流（指向键盘），因此Scanner总是接受我们键盘输入的数据，我们可以更改Scanner读取的流对象：

package com.dfbz.demo01;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.Scanner;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws FileNotFoundException { 
    
            Scanner sc = new Scanner(new FileInputStream("ps.txt"));
    
            String str = sc.next();
            System.out.println(str);
    
            str=sc.next();          // 此时读取的不是控制台的数据,而是ps.txt中的数据
            System.out.println(str);
    
            str=sc.next();
            System.out.println(str);
    
            str=sc.next();              // 读取到结尾 抛出java.util.NoSuchElementException
            System.out.println(str);
        }
    }

也可以更改标准输入流：

package com.dfbz.demo01;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws FileNotFoundException { 
            // 更改标准输入流 
            System.setIn(new FileInputStream("StandardInputStream.txt"));
        }
    }

### 4.3.2 标准输出流 ###

标准输出流是一个打印流（PrintStream），他默认指向的是控制台，通过`System.out`获取标准输出流，因此我们之前总是使用`System.out.println`往控制台输出内容；

我们也可以更改标准输出流，让其不在输出到控制台，而是输出到我们制定的地方：

package com.dfbz.demo01;
    
    import java.io.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) throws FileNotFoundException { 
    
            // 修改标准输出流
            System.setOut(new PrintStream("StandardOutputStream.txt"));
    
            // 此时输出到StandardOutputStream.txt文件中,而不是控制台
            System.out.println("我是中国人");
            System.out.println("犯我中华者");
            System.out.println("虽远必诛");
        }
    }

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

**上一篇**：[day14【IO概述、字符流、字节流、属性操作】][day14_IO]

**下一篇**：

**目录**：【JavaSE零基础系列教程目录】

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/353f1b6c8a284db3a9dc9eb844468790.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/d383cce4dae14e3ebf2fbf6643ee25fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/3c59cc4af32641d29a753c2a2fc38bae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/a9cfadf36f6f480ea397682c7408593d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/3bf76ac449d14847b1ca18112881f052.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/7a5f01722cba4426bd541154e95d9d3e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/695472c35b9f4529ba72e5ab3b27439d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/349be2350af54fd8bd3c45beee0c9c95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/81848f98f6a1466cbefc0385b2154ad6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/28ab4e89556943e9af1c19b40441c919.png
[day14_IO]: https://blog.csdn.net/Bb15070047748/article/details/119444714