4.1标准输入输出流

System类中有两个静态的成员变量：

public static final InputStream in:标准输入流，通常该流对应键盘输入或由主机环境或用户指定的另一个输入源
public static final PrintStream out:标准输出流，通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

标准输入流

自己实现键盘录入数据：

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

写起来太麻烦，Java就提供了一个类实现键盘录入

Scanner scanner = new Scanner(System.in);

package com.demo.system;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
 * @author jingLv
 * @date 2020/12/21
 */
public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        // public static final InputStream in:标准输入流，通常该流对应键盘输入或由主机环境或用户指定的另一个输入源
        // 通常该流对应键盘输入
//        InputStream inputStream = System.in;
        // 字节流读数据
//        int by;
//        while ((by = inputStream.read()) != -1) {
//            System.out.println((char) by);
//        }

        // 字符流读数据
        // 如何把字节流转换为字符流？使用转换流
//        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        // 使用字符流能不能够实现一次读取一行数据呢？可以
        // 但是，一次读取一行数据方式是字符缓冲输入流的特有方法
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        String readLine = bufferedReader.readLine();
        System.out.println("输入的字符串是：" + readLine);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(bufferedReader.readLine());
        System.out.println("输入的整数是：" + i);

        // 自己实现键盘录入太麻烦，所以Java提供了一个类实现键盘输入Scanner
        Scanner scanner = new Scanner(System.in);
    }
}

标准输出流

输出语句的本质：是一个标准输出流

PrintStream ps = System.out;
PrintStream类有的方法，System.out都可以使用

package com.demo.system;

import java.io.PrintStream;

/**
 * @author jingLv
 * @date 2020/12/21
 */
public class SystemOutDemo {
    public static void main(String[] args) {
        // public static final PrintStream out:标准输出流，通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
        PrintStream printStream = System.out;

        // 能够方便地打印各种数据值
        // 同行
        printStream.print("hello");
        printStream.print(200);
        // 换行
        printStream.println("hello");
        printStream.println(100);

        // System.out的本质是一个字节输出流
        // 同行
        System.out.print("hello");
        System.out.print(200);
        // 换行
        System.out.println("hello");
        System.out.println(100);
    }
}

4.2打印流

打印流分类：

字节打印流：PrintStream
字符打印流：PrinteWriter

字节打印流–PrintStream

打印流的特点：

只负责输出数据，不负责读取数据
有自己的特有方法

字节打印流：

PrintStream(String fileName):使用指定的文件名创建新的打印流
使用集成父类的方法写数据，查看的时候会转码；使用自己特有方法写数据，查看数据原样输出

package com.demo.system;

import java.io.FileNotFoundException;
import java.io.PrintStream;

/**
 * @author jingLv
 * @date 2020/12/22
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // PrintStream(String fileName):使用指定的文件名创建新的打印流
        PrintStream printStream = new PrintStream("java-file-class/ps.txt");
        // 写数据
        // 字节输出流有的方法
        // 字节转码，97转为a
        printStream.write(97);
        // 使用特有方法写数据
        // 97就是97，不会做转码操作
        printStream.print(97);
        printStream.println(98);
        // 释放资源
        printStream.close();
    }
}

字符打印流–PrinteWriter

字符打印流PrintWriter的构造方法：

方法名	说明
PrintWriter(String fileName)	使用指定的文件名创建一个新的PrintWriter，而不需要自定执行刷新
PrintWriter(Writer out, boolean autoFlush)	创建一个新的PrintWriter - out：字符输出流 - autoFlush：一个布尔值，如果为true，则println，printf，或format方法将刷新输出缓冲区

package com.demo.system;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @author jingLv
 * @date 2020/12/22
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // PrintWriter(String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自定执行刷新
        PrintWriter printWriter = new PrintWriter("java-file-class/pw.txt");
        printWriter.write("hello");
        // 换行
        printWriter.write("/r");
        printWriter.flush();
        printWriter.write("world");
        printWriter.flush();

        // println相当于write数据及换行
        printWriter.println("hello");
        printWriter.flush();

        // PrintWriter(Writer out, boolean autoFlush): 创建一个新的PrintWriter
        // 第二个参数为true--实现自动刷新
        PrintWriter pw = new PrintWriter(new FileWriter("java-file-class/pw.txt"), true);
        pw.println("hello");
        // 释放资源
        printWriter.close();
        pw.close();
    }
}

复制Java文件（打印流改进版）

思路：

根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
释放资源

package com.demo.system;

import java.io.*;

/**
 * @author jingLv
 * @date 2020/12/22
 */
public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
//        // 1. 根据数据源创建字符输入流对象
//        BufferedReader br = new BufferedReader(new FileReader(""));
//        // 2. 根据目的地创建自如输出流对象
//        BufferedWriter bw = new BufferedWriter(new FileWriter(""));
//        // 3. 读写数据，复制文件
//        String line;
//        while ((line = br.readLine()) != null) {
//            bw.write(line);
//            bw.newLine();
//            bw.flush();
//        }
//        // 4. 释放资源
//        br.close();
//        bw.close();

        System.out.println("------------字符打印流改进-------------");
        // 1. 根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader(""));
        // 2. 根据目的地创建自如输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter(""));
        String line;
        while ((line = br.readLine()) != null) {
            pw.println(line);
        }
        // 4. 释放资源
        br.close();
        pw.close();
    }
}

4.3对象序列化流

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象

这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息

字节序列写到文件之后，相当于文件中持久保存一个对象的信息

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

要实现序列化和反序列化就要使用对象序列化流和对象反序列化流：

对象序列化流：ObjectOutputStream
对象反序列化流：ObjectInputStream

对象序列化流–ObjectOutputStream

将Java对象的原始数据类型和图形写入OutputStream，可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

构造方法：

ObjectOutputStream(OutputStream out):创建一个写入执行的OutputStream的ObjectOutputStream

序列化对象的方法：

void writeObject(Object obj):将指定的对象写入ObjectOutpuStream

注意：

一个对象要想被序列化，该对象所属的类必须实现Serializable接口
Serializable是一个标记接口，实现该接口，不需要重写任何方法

对象实现Serializable的标记接口

package com.demo.model;

import java.io.Serializable;

/**
 * @author jingLv
 * @date 2020/12/15
 */
public class Student implements Serializable {

    private static final long serialVersionUID = -3657072962604195830L;

    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

   ....
}

package com.demo.system;

import com.demo.model.Student;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * 抛出异常：Exception in thread "main" java.io.NotSerializableException: com.demo.model.Student
 * NotSerializableException： 抛出一个实例需要一个Serializable接口，序列化运行时或实例的类可能会抛出此异常
 * 类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化
 * 因此，需要的对象实现Serializable接口，即Student对象实现Serializable接口
 *
 * @author jingLv
 * @date 2020/12/22
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // ObjectOutputStream(OutputStream out):创建一个写入执行的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("java-file-class/oos.txt"));
        // 创建对象
        Student student = new Student("001", "张三", 25, "北京");
        // void writeObject(Object obj):将指定的对象写入ObjectOutpuStream
        oos.writeObject(student);
        // 释放资源
        oos.close();
    }
}

对象反序列化流–ObjectInputStream

ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

构造方法：

ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法：

Object.readObject():从ObjectInputStream读取一个对象

package com.demo.system;

import com.demo.model.Student;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * @author jingLv
 * @date 2020/12/22
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java-file-class/oos.txt"));
        // Object.readObject():从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student student = (Student) obj;
        System.out.println(student.getSid() + "," + student.getName() + "," + student.getAge() + "," + student.getAddress());

        // 释放资源
        ois.close();
    }
}

对象序列化流的问题

用对象序列化流序列化一个对象后，假如我们修改了对象所有的类文件，读取数据会不会出问题呢？如果出问题如何解决呢？

会出问题，抛异常InvalidClassException

Exception in thread "main" java.io.InvalidClassException: com.demo.model.Person; 
local class incompatible: stream classdesc serialVersionUID = -8627218638897120134, 
local class serialVersionUID = 3625556106735835881

查询此异常可知：当序列化运行时检测到类中的以下问题之一时抛出。
- 类的串行版本与从流中读取的类描述符的类型不匹配
- 该类包含未知的数据类型
- 该类没有可访问的无参数构造函数
进而分析出问题出现在第一条，那么版本不一致说明的具体是什么，通过查看Serializable接口来分析：
- 序列化运行时将每个可序列化的类与称为serialVersionUID的版本号相关联，该序列号在反序列化期间用于验证序列化对象的发送者和接收者是否已加载与该序列化兼容的对象的类。如果接收方加载了一个具有不同于相应发件人类的serialVersionUID的对象的类，则反序列化将导致InvalidClassException 。一个可序列化的类可以通过声明一个名为”serialVersionUID”的字段来显式地声明它自己的serialVersionUID，该字段必须是static，final，类型是long
- 如果可序列化类没有显式声明serialVersionUID，则序列化运行时将根据Java（TM）对象序列化规范中所述的类的各个方面计算该类的默认serialVersionUID值。
- 直白的理解就是，当你修改了对象所属类的属性时，会发生版本不一致的冲突，此冲突会导致InvalidClassException异常
问题的原因已经找到，那么如何解决？：所有可序列化的类都明确声明serialVersionUID值

如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？

使用transient关键字修饰，该关键字标记的成员变量不参与序列化过程

public class Person implements Serializable {

    private static final long serialVersionUID = -8627218638897120134L;

    private String name;
    private transient Integer age;
		
  	...
}

4.4 Properties

Propertios概述：

是一个Map体系的集合类
Properties可以保存到流中或从流中加载

练习：Properties作为Map集合的使用

package com.demo.system;

import java.util.Properties;
import java.util.Set;

/**
 * @author jingLv
 * @date 2020/12/23
 */
public class PropertiesDemo01 {
    public static void main(String[] args) {
        // 创建集合对象
        Properties properties = new Properties();
        // 存储元素
        properties.put("name", "xiaohong");
        properties.put("age", "25");
        properties.put("address", "Beijing");
        // 遍历集合
        Set<Object> keySet = properties.keySet();
        for (Object key : keySet) {
            Object value = properties.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties作为集合的特有方法

方法名	说明
Object setProperties(String key, String value)	设置集合的键和值，都是String类型，底层调用Hashtable方法put
String getProperty(String key)	使用此属性列表中指定的键搜索属性
Set stringPropertyName()	从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

package com.demo.system;

import java.util.Properties;
import java.util.Set;

/**
 * @author jingLv
 * @date 2020/12/23
 */
public class PropertiesDemo02 {
    public static void main(String[] args) {
        // 创建集合对象
        Properties properties = new Properties();
        // Object setProperties(String key, String value): 设置集合的键和值，都是String类型，底层调用Hashtable方法put
        properties.setProperty("num001", "zhangsan");
        /**
         * Object setProperty(String key, String value) {
         *         return put(key, value);
         *     }
         *
         * Object put(Object key, Object value) {
         *         return map.put(key, value);
         *     }
         */
        properties.setProperty("num002", "lisi");
        properties.setProperty("num003", "wangwu");
        System.out.println(properties);
        // String getProperty(String key):使用此属性列表中指定的键搜索属性
        System.out.println(properties.getProperty("num002"));
        // Set<String> stringPropertyName():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = properties.stringPropertyNames();
        for (String name : names) {
            // System.out.println(name);
            String value = properties.getProperty(name);
            System.out.println(name + "," + value);
        }
    }
}

Properties和IO流结合的方法

方法名	说明
void load(InputStream inStream)	从输入字节流读取属性列表（键和元素对）
void load(Reader reader)	从输入字符流读取属性列表（键和元素对）
void store(OutputStream out, String comments)	将此属性列表（键和元素对）写入此Properties表中，以适合于使用load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments)	将此属性列表（键和元素对）写入此Properties表中，以适合使用load(Reader)方法的格式写入输出字符流

package com.demo.system;

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

/**
 * @author jingLv
 * @date 2020/12/23
 */
public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        // 把集合中的数据保存到文件
        // myStore();
        // 把文件中的数据加载到集合
        myLoad();
    }

    private static void myStore() throws IOException {
        Properties properties = new Properties();
        properties.setProperty("number_001", "张三");
        properties.setProperty("number_002", "李四");
        properties.setProperty("number_003", "王五");
        // void store(Writer writer, String comments):将此属性列表（键和元素对）写入此Properties表中，以适合使用load(Reader)方法的格式写入输出字符流
        FileWriter fileWriter = new FileWriter("java-file-class/fw.txt");
        properties.store(fileWriter, null);
        // 释放资源
        fileWriter.close();
    }

    private static void myLoad() throws IOException {
        Properties properties = new Properties();
        // void load(Reader reader):从输入字符流读取属性列表（键和元素对）
        FileReader fileReader = new FileReader("java-file-class/fw.txt");
        properties.load(fileReader);
        fileReader.close();
        System.out.println(properties);
    }
}

案例：游戏次数

程序实现猜数字小游戏只能试玩3次，如果还想玩，提示：游戏试玩已结束，想玩请充值

思路：

写一个游戏类，里面有一个猜数字的小游戏
写一个测试类，测试类中main()方法，main()方法中按照下面步骤完成：
1. 从文件中获取数据到Properties集合，用load()方法
  1. 文件已经存在：game.txt
  2. 里面有一个数据值：count=0
2. 通过Properties集合获取到玩游戏的次数
3. 判断次数是否到3次了
  1. 如果到了，给出提示：游戏试玩已结束，想玩请充值
  2. 如果不到三次：
    - 玩游戏，次数+1，重新写回文件，用Properties的store()方法实现

游戏类

package com.demo.system;

import java.util.Random;
import java.util.Scanner;

/**
 * @author jingLv
 * @date 2020/12/23
 */
public class GuessNumber {
    /**
     * 私有构造方法，不允许外部实例化
     */
    private GuessNumber() {
    }

    public static void start() {
        // 猜数字游戏，使用随机生成数字，范围1~100
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while (true) {
            // 实现键盘录入，输入猜测色数字值
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入您要猜数字的值：");
            int guessNumber = scanner.nextInt();
            // 比较输入的数字和随机生成的数字，根据不同的情况进行结果显示
            if (guessNumber > number) {
                System.out.println("您猜的数字：" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("您猜的数字：" + guessNumber + "小了");
            } else {
                System.out.println("恭喜您猜中了！");
                break;
            }
        }
    }
}

测试类

package com.demo.system;

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

/**
 * @author jingLv
 * @date 2020/12/23
 */
public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        //  从文件中获取数据到Properties集合，用load()方法
        Properties properties = new Properties();
        FileReader fileReader = new FileReader("java-file-class/game.txt");
        properties.load(fileReader);
        fileReader.close();
        // 通过Properties集合获取到玩游戏的次数
        String count = properties.getProperty("count");
        int number = Integer.parseInt(count);
        // 判断次数是否到3次了
        if (number >= 3) {
            // 如果到了，给出提示：游戏试玩已结束，想玩请充值
            System.out.println("游戏试玩已结束，想玩请充值");
        } else {
            // 玩游戏
            GuessNumber.start();
            // 次数+1，重新写回文件，用Properties的store()方法实现
            number++;
            properties.setProperty("count", String.valueOf(number));
            FileWriter fileWriter = new FileWriter("java-file-class/game.txt");
            properties.store(fileWriter, null);
            fileWriter.close();
        }
    }
}