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

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;
            }
        }
    }
}