Java学习笔记之IO流&Properties集合

0x00 概述

本文涉及Java知识点有IO流，Properties集合。

0x01 流案例

1.1 集合到文件数据排序改进版

需求：键盘录入5个学生信息，姓名，语文成绩，数学成绩，英语成绩，要求按照成绩总分从高到低写入文本文件
格式：姓名，语文成绩，数学成绩，英语成绩

步骤分析：

1. 创建学生类

2. 创建TreeSet集合，通过比较器排序进行排序

3. 键盘录入学生数据

4. 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量

5. 把学生对象添加到TreeSet集合

6. 创建字符缓冲输出流对象

7. 遍历集合，得到每一个学生对象

8. 把学生对象的数据拼接成指定格式的字符串

9. 调用字符缓冲输出流对象的方法写数据

10. 释放资源

示例

package Set2FileDemo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Treeset2FileDemo {
    public static void main(String[] args) throws IOException {
        // 创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 成绩总分从高到低
                int num = s2.getSum() - s1.getSum();
                // 次要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s2.getEnglish() - s1.getEnglish() : num3;
                return num4;
            }
        });

        // 键盘录入学生数据
        for (int i = 0; i < 5; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + (i+1) + "个学生的信息");
            System.out.println("姓名： ");
            String name = sc.nextLine();
            System.out.println("语文成绩： ");
            int Chinese = sc.nextInt();
            System.out.println("数学成绩： ");
            int Math = sc.nextInt();
            System.out.println("英语成绩： ");
            int English = sc.nextInt();

            // 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
            Student s = new Student();
            s.setName(name);
            s.setChinese(Chinese);
            s.setMath(Math);
            s.setEnglish(English);

            // 把学生对象添加到TreeSet集合
            ts.add(s);
        }

        // System.out.println(ts.size());

        // 创建字符缓冲流输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "TestFolder/ts.txt"));

        // 遍历集合，得到每一个学生对象
        for (Student s : ts) {
            // 把学生对象的数据拼接成指定格式的字符串
            // 格式： 姓名，语文成绩，数学成绩，英语成绩
            StringBuilder sb = new StringBuilder();

            sb.append(s.getName()).append(", ").append(s.getChinese()).append(", ").append(s.getMath()).
                    append(", ").append(s.getEnglish()).append(", ").append(s.getSum());

            // System.out.println(sb.toString());

            // 调用字符缓冲输出流对象的方法写数据

            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        // 释放资源  TestFolder
        bw.close();
        
    }
}

1.2 复制单级文件夹

需求：把"E:\\itcast"这个文件夹复制到模块目录下

分析步骤：

1. 创建数据源目录File对象，路径是E:\itcast

2. 获取数据源目录File对象的名称

3. 创建目的地目录File对象，路径由（模块名+第2步获取的名称）组成

4. 判断第3步创建的File是否存在，如果不存在，就创建

5. 获取数据源目录下所有文件的File数组

6. 遍历File数据，得到每一File对象，该File对象，其实就是数据源文件

7. 获取数据源文件File对象的名称

8. 创建目的地文件File对象，路径由（目的地目录+第七步获取的名称）组成

9. 复制文件，由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件，采用参数为File的构造方法

示例

package CopyFolderDemo;

import java.io.*;

public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 创建数据源目录File对象，路径是E:\\itcast
        File srcFolder = new File("E:\\itcast");

        // 获取数据源目录File对象的名称（itcast）
        String srcFolderName = srcFolder.getName();

        // 创建目的地目录File对象，路径名是模块名+itcast组成（myCharStream\\itcast  ）
        File destFolder = new File("myCharStream", srcFolderName);

        // 判断目的地目录对应的File是否存在，如果不存在，就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        // 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for (File srcFile : listFiles) {
            // 数据源文件 E:\\itcast\\mn.jpg
            // 获取数据源文件File对象的名称(mn.jpg)
            String srcFileName = srcFile.getName();

            // 创建目的地文件File对象，路径名是目的地目录+mn.jpg组成myCharStream\\itcast\\mn.jpg
            File destFile = new File(destFolder, srcFileName);

            // 复制文件
            copyFile(srcFile, destFile);

        }
    }

    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}

1.3 复制多级文件夹

需求：把"E:\\itcast"这个文件夹复制到F盘目录下

分析步骤：

1. 创建数据源File对象，路径是E:\\itcast

2. 创建目的地File对象，路径是F

3. 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象

4. 判断数据源File是否是文件

　　是文件：直接复制，用字节流

　　不是文件：在目的地创建目录，遍历该目录下的所有文件的File数组，得到每一个File对象，回到3继续

示例

package CopyFolderDemo2;

import java.io.*;

public class CopyFolderDemo2 {
    public static void main(String[] args) {
        // 创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("E:\\itcast");

        // 创建目的地File对象，路径是F:\\
        File destFile = new File("F:\\");

        // 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        copyFolder(srcFile, destFile);

    }

    private static void copyFolder(File srcFile, File destFile) {
        // 判断数据源File是否是目录
        if (srcFile.isDirectory()) {
            // 在目的地目录下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile, srcFile);
            if (!newFolder.exists()) {
                newFolder.mkdir();
            }

            // 获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();

            // 遍历File数组，得到每一个File对象
            for (File file : fileArray) {
                // 把File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file, newFolder);
            }

        } else {
            // 说明是文件，直接复制，用字节流
            File newFile = new File(destFile, srcFile.getName());
        }

    }

    // 字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new
                FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new
                FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}

1.4 复制文件的异常处理

基本做法

package CopyFileDemo3;

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

public class CopyFileDemo3 {
    public static void main(String[] args) {

    }

    // try---catch---finally
    private static void method2() {
        FileReader fr = null;
        FileWriter fw = null;

        try {
            fr = new FileReader("fr.txt");
            fw = new FileWriter("fw.txt");

            char[] chs = new char[1024];
            int len;
            while ((len = fr.read(chs)) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace()
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");

        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
        }
        
        fw.close();
        fr.close();
    }
}

JDK7版本改进

package CopyFileDemo3;

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

public class CopyFileDemo31 {
    public static void main(String[] args) {

    }

    // JDK7的改进方案
    private static void method() throws IOException {
        try (FileReader fr = new FileReader("fr.txt");
             FileWriter fw = new FileWriter("fw.txt"); ){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9版本改进

package CopyFileDemo3;

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

public class CopyFileDemo32 {
    public static void main(String[] args) {

    }

    // JDK9的改进方案
    private static void method() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");

        try (fr; fw) {
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

0x02 IO特殊操作流

2.1 标准输入流

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

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

自己实现键盘录入数据

package SystemInDemo;

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

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        // public static final InputStream in: 标准输入流
        /*
        InputStream is = System.in;

        int by;
        while ((by = is.read()) != -1) {
            System.out.println((char) by)
        }

         */

        // 如何把字节流转换为字符流？用转换流
        InputStream is = System.in;
        InputStreamReader isr = new InputStreamReader(is);
        // 使用字符流能不能实现一次读取一行数据？ 可以的
        // 但是，一次读取一行数据的方法是字符花虫输入流的特有方法
        // BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串");
        String line = br.readLine();
        System.out.println("你输入的字符串是： " + line);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是： " + i);
        
        // 自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}

2.2 标准输出流

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

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

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

PrintStream ps = System.out;

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

示例

package SystemOutDemo;

import java.io.PrintStream;

public class SystemOutDemo {
    public static void main(String[] args) {
        // public static final PrintStream out: 输出流
        PrintStream ps = System.out;
        
        // 能够方便打印各种数据值
        ps.print("hello");
        ps.print(100);
        
        ps.println("hello");
        ps.println(100);
        
        // System.out的本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);
    
        System.out.println();
    }
}

2.3 字节打印流

打印流分类

　　　　字节打印流： PrintStream

　　　　字符打印流：PrintWriter

打印流的特点

　　　　只负责输出数据，不负责读取数据

　　　　永远不会抛出IOException

　　　　有自己的特有方法

字节打印流

　　　　PrintStream(String fileName): 使用指定的文件名创建新的打印流

　　　　使用继承父类的方法写数据，查看的时候会转码，使用自己的特有方法写数据，查看的数据原样输出

　　　　可以改变输出语句的目的地

　　　　　　public static void setOut(PrintStream out): 重新分配“标准”输出流

示例

package PrintStreamDemo;

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

public class PrintStreamDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // PrintStream(String FileName): 使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("myOtherStream//ps.txt");

        // 写数据
        // 字节输出流的所有方法
        ps.write(97);
        
        // 使用特有方法写数据
        ps.print(97);
        ps.println();
        ps.print(98);
        ps.println(97);
        ps.println(98);

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

2.4 字符打印流

字符打印流构造方法

示例

package PrintWriterDemo;

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

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // PrintWriter(String fileName): 使用指定的文件创建一个新的PrintWriter，而不需要自动执行行行刷新
        PrintWriter pw = new PrintWriter("myOtherStream//pw.txt");

        pw.write("hello");
        pw.write("\r\n");
        pw.flush();
        pw.write("world");
        pw.write("\r\n");
        pw.flush();

        pw.println("hello");
        pw.flush();
        
        pw.println("world");
        pw.flush();
        
        // PrintWriter(Writer out, boolean autoFlush): 创建一个新的PrintWriter
        PrintWriter pw2 = new PrintWriter(new
                FileWriter("myOtherStream//pw.txt"), true);
        // PrintWriter pw2 = new PrintWriter(new FileWriter("myOtherStream//pw.txt"), false);
        
        pw2.println("hello");

        pw.close();
    }
}

2.5 复制Java文件打印流改进版

需求：把模块目录下的PrintSteamDemo.java复制到模块目录下的Copy.java

分析步骤：

　　根据数据源创建字符输入流对象

　　根据目的地创建字符输出流对象

　　读写数据，复制文件　　

　　释放资源

示例

package CopyJavaDemo;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        /*
        // 根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new
                FileReader("myOtherStream//PrintStreamDemo.java"));

        // 根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new
                FileWriter("myOtherStream//copy.java"));

        // 读写数据，复制文件
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        
        // 释放资源
        bw.close();
        br.close();
        
         */

        // 根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new
                FileReader("myOtherStream//PrintStreamDemo.java"));

        // 根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new
                FileWriter("myOtherStream//copy.java"), true);

        // 读写数据，复制文件
        String line;
        while ((line = br.readLine()) != null) {
            pw.println(line);
        }

        // 释放资源
        pw.close();
        br.close();

    }
}

2.6 对象序列化流

对象序列化介绍

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

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

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

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

对象序列化流：ObjectOutputStream

　　　　将Java对象的原始数据类型和属性写入OutputStream，可以使用ObjectOutputStream读取（重构）对象，可以通过使用流的文件来实现

　　　　对象的持久存储，如果流是网络套接字流，则可以在另一个主机或另一个进程中重构对象

构造方法

序列化对象的方法

示例

package ObjectOutputStreamDemo;

public class Student implements Serializable{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package ObjectOutputStreamDemo;

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

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("myOtherStream//oos.txt"));

        // 创建对象
        Student s = new Student("alice", 30);

        // void writeObject(Object obj): 将指定的对象写入ObjectOutputStream
        oos.writeObject(s);

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

注意事项：

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

2.7 对象反序列化流

对象反序列化流：ObjectInputStream

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

构造方法

反序列化对象的方法

示例

package ObjectInputStreamDemo;

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

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // ObjectInputStream(InputStream in): 创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("myOtherStream//oos.txt"));

        // Object readObject(): ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        
        Student s = (Student) obj;
        System.out.println(s.getName()+", "+s.getAge());

        ois.close();

    }
}

2.8 serialVersionUID & transient

serialVersionUID

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

　　　　　　会出问题，会抛出InvalidClassException异常

　　　　如果出问题了，如何解决？

　　　　　　重新序列化

　　　　　　给对象所属的类加一个serialVersionUID

　　　　　　　　private static final log serialVersionUID = 42L;

transient

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

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

示例

package ObjectInputStreamDemo;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package ObjectInputStreamDemo;

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

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // ObjectInputStream(InputStream in): 创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("myOtherStream//oos.txt"));

        // Object readObject(): ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName()+", "+s.getAge());

        ois.close();

    }
}

0x03 Properties集合

3.1 Properties作为Map集合的使用

Properties介绍

　　　　是一个Map体系的集合类

　　　　Propeties可以保存到流中或者从流中加载

　　　　属性列表的每个键及其对应的值都是一个字符串

基本使用方法

package PropertiesDemo1;

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

public class PropertiesDemo1 {
    public static void main(String[] args) {
        // 创建集合对象
        // Properties<String, String> prop = new Properties<String, String>(); 错误
        Properties prop = new Properties();

        // 存储元素
        prop.put("001", "Alice");
        prop.put("002", "Bob");
        prop.put("003", "Charlie");

        // 遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key+", "+value);
        }
    }
}

3.2 Properties作为mao集合的特有方法

特有方法

示例

package PropertiesDemo2;

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

public class PropertiesDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        Properties prop = new Properties();

        // Object setProperty(String key, String value) : 设置集合的键和值，都
        // 是String类型，底层调用Hashtable方法put
        prop.setProperty("001", "Alice");

        /*
            Object setProperty(String key, String value) {
                return put(key, value);
            }

            Object put(Object key, Object value) {
                return map.put(key, value);
            }
         */
        prop.setProperty("002", "Bob");
        prop.setProperty("003", "Charlie");

        // String getProperty(String key): 使用此属性列表中指定的键搜索属性
        System.out.println(prop.getProperty("001"));
        System.out.println(prop.getProperty("002"));
        System.out.println(prop.getProperty("003"));

        System.out.println(prop);
        System.out.println("-----------------");

        // Set<String> stringPropertyName()：从该属性列表中返回一个不可修改的键集，
        // 其中键及其对应的值都是字符串
        Set<String> names = prop.stringPropertyNames();
        for(String key: names) {
            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key+", "+value);
        }
    }
}

3.3 Properties和IO流相结合的方法

和IO流结合的方法

示例

package PropertiesDemo3;

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

public class PropertiesDemo3 {
    public static void main(String[] args) throws IOException {
        // 把集合中的数据保存到文件
        myStore();

        // 把文件中的数据加载到集合
        // myLoad();
    }

    private static void myLoad() throws IOException {
        Properties prop = new Properties();

        // void load(Reader, Reader):
        FileReader fr = new FileReader("TestFolder/ts1.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("001", "Alice");
        prop.setProperty("002", "Bob");
        prop.setProperty("003", "Charlie");

        // void store(Writer writer, String comments)
        FileWriter fw = new FileWriter("TestFolder/ts1.txt");
        prop.store(fw, "This is a test");
        fw.close();
    }
}

3.4 游戏次数案例

案例需求：

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

分析步骤：

　　　　1. 写一个游戏类，里面有一个猜数字的小游戏

　　　　2. 写一个测试类，测试类中有main()方法，main()方法中写如下代码：

　　　　　　从文件中读取数据到Properties集合，用load()方法实现

　　　　　　文件已经存在TestFolder/game.txt

　　　　　　里面有一个数据值: count=0

　　　　　　通过Properties集合获取到游玩的次数

　　　　　　判断次数是否已经超过3次

　　　　　　如果到了，给出提示：游戏试玩已经结束，继续的话需要充值

　　　　　　如果不到3次，次数+1，重写到文件，用Properties的store()方法实现玩游戏

package PropertiesTest;

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

public class PropertiesTest {

    public static void main(String[] args) throws IOException {
        // 从文件中读取数据到Properties集合，用load()方法实现
        Properties prop = new Properties();

        FileReader fr = new FileReader("TestFolder/game.txt");

        prop.load(fr);
        fr.close();
        // System.out.println(prop);

        // 通过Properties集合获取到游玩的次数
        String count = prop.getProperty("count");
        int num = Integer.parseInt(count);
        // System.out.println(num);

        // 判断次数是否到3次
        if (num >= 3) {
            // 如果到了，给出提示，游戏试玩结束，需要充值
            System.out.println("试玩超过3次，游戏已结束，请充值");
        } else {
            // 玩游戏
            GuessNumber.start();

            // 次数+1，写回文件，用Properties的store()方法实现
            num += 1;
            prop.setProperty("count", String.valueOf(num));
            FileWriter fw = new FileWriter("TestFolder/game.txt");
            prop.store(fw, "writing process");
            fw.close();
        }
    }
}

package PropertiesTest;

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

public class GuessNumber {

    private GuessNumber() {
    }

    public static void start() {
        // 要完成猜数字游戏，首先要有一个已经确定的数字，使用随机数方法生成该数字，范围1到100
        Random r = new Random();
        int num = r.nextInt(100) + 1;

        while (true) {
            // 使用程序实现猜数字，输入使用键盘输入实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入你要猜的数字: >> ");
            int guessNum = sc.nextInt();

            // 比较输入的数字和系统产生的数据，需要使用分支语句if...else if...else
            if (guessNum > num) {
                System.out.println("你猜的数字" + guessNum + "大了");
            } else if (guessNum < num) {
                System.out.println("你猜的数字" + guessNum + "小了");
            } else {
                System.out.println("猜中了");
                break;
            }
        }
    }
}