java阶段八之文件IO流----IO流&Properties属性集----练习题

知识点

特殊流，Properties集合+I/O流基础，练习

一、简答题

1.什么是java序列化，什么java反序列化？
对象序列化介绍

• 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
  • 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
  • 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
  • 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化
    2.选择
    1.计算机处理的数据最终分解为▁AD▁的组合。（多选）
    A 0
    B 数据包
    C 字母
    D 1
    2.计算机处理的最小数据单元称为▁B▁。
    A 位
    B 字节
    C 兆
    D 文件
    3.字母、数字和特殊符号称为▁C▁。
    A 位
    B 字节
    C 字符
    D 文件
    4.在FilterOutputStream类的构造方法中，下面哪个类是合法：▁C▁
    A File
    B InputStream
    C OutputStream
    D FileOutputStream
    5.在BufferedWriter类的构造方法中，下面哪个类是合法;▁D▁
    A FileRead
    B InputStream
    C OutputStream
    D FileWriter
    3.特殊流有哪些？分别有什么作用？
    答： 一、标准输出/输入流：代表了系统的输入和输出设备，默认输入设备是键盘，默认输出设备是显示器。
    二、字节/字符打印流：只能操作目的地，不能操作数据。可以操作任意类型的数据。有两个构造方法，可启动刷新就不用flash。是可以直接操作文件的流。
    三、对象序列化/反序列化流：核⼼作⽤就是对象状态的保存和重建。

二、程序题

​ 1.用代码实现以下需求：

(1)已知配置文件config.txt中有三个键值对
name=zhangsan
score=80
address=beijing
(2)使用IO字节流对象和Properties类结合使用,将配置文件中的score键的值修改为100

public class Work8_IOStream_1 {
    public static void main(String[] args) throws IOException {
        //创建IO字节流对象--字符输入流对象--数据源
        FileReader fr = new FileReader("E:\\JavaSE_Code\\myFile\\day37\\src\\com\\IOStreamWork01\\config.txt");
        //创建Properties Map集合
        Properties prop = new Properties();
        //将文本数据加载到集合
        prop.load(fr);
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet){
            //修改集合中的值
            prop.setProperty("score","100");
        }
        //将集合中的值存储到文本中
        FileWriter fw = new FileWriter("E:\\JavaSE_Code\\myFile\\day37\\src\\com\\IOStreamWork01\\config.txt");
        prop.store(fw,null);
        //释放资源
        fr.close();
        fw.close();
    }
}

2.编写一个小程序，记录程序运行的次数，满足5次后，给出提示，试用次数已到，请注册！
分析：
1.将配置文件封装成File对象，判断文件是否存在，不存在则自己创建
2.需要计数器；
3.计数器的值，生命周期要比应用程序的生命周期要长，需要对计数器的值进行持久化。count = 1，里面存储的应该是键值方式，Map集合，要和设备上的数据关联，需要IO技术。集合 + IO = Properties。

class LittleProgram {
    public static void program(){
        //随便一个小程序
        System.out.println("这是一个小程序！");
    }
}

public class Work8_02 {
    public static void main(String[] args) throws IOException {
        //1.将配置文件封装成File对象，判断文件是否存在，不存在则自己创建
        File file = new File("E:\\JavaSE_Code\\myFile\\day37\\src\\com\\IOStreamWork02\\count.txt");
        Properties prop = new Properties();
        //判断文件是否存在
        if (!file.exists()){
            //不存在就自己创建
            file.createNewFile();
            //创建目的地
            FileWriter fw = new FileWriter(file);
            //写入数据到集合，配置文件内容的初始化
            prop.setProperty("count","0");
            //将集合数据存储到文件
            prop.store(fw,null);
        }

        //创建字符输入流数据源对象
        FileReader fr = new FileReader(file);
        //将配置文件数据加载到集合
        prop.load(fr);
        //通过键得到配置文件中的值
        String s = prop.getProperty("count");
        //字符串转整型
        int i = Integer.parseInt(s);
        //判断次数
        if (i>=3){
            //大于三次就输出提示
            System.out.println("试用次数已达到，请注册！");
        }else {
            //不大于三次就调用小程序
            LittleProgram.program();
            //创建字符输出流数据源对象
            FileWriter fw = new FileWriter(file);
            //次数加一
            i++;
            //整型转字符串
            String number = String.valueOf(i);
            //更新集合
            prop.setProperty("count",number);
            //集合数据存储到文件中
            prop.store(fw,null);
            //释放资源
            fw.close();
        }
        //释放资源
        fr.close();
    }
}

3.用代码实现以下需求

(1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,生成空参有参构造,set和get方法,toString方法
(2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
(3)将存有6个学员信息的ArrayList集合对象写入到D:\StudentInfo.txt文件中
(4)读取D:\StudentInfo.txt文件中的ArrayList对象
(5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
(6)将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\StudentInfo.txt文件中(写入格式：张三-男-25)

public class Work8_03 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\StudentInfo.txt");
        //(2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
        Scanner scanner = new Scanner(System.in);
        ArrayList<Student> arrayList = new ArrayList<>();
        System.out.println("请输入6个学员信息（逗号隔开）,需要两个相同信息。");
        for (int i=1;i<=3;i++){
            System.out.println("请输入第"+i+"个学员信息(录入格式:张三,男,25)：");
            String line = scanner.nextLine();
            String[] split = line.split(",");
            String name = split[0];
            String gender = split[1];
            String ii = split[2];
            int age = Integer.parseInt(ii);
            arrayList.add(new Student(name,gender,age));
        }

        //(3)将存有6个学员信息的ArrayList集合对象写入到D:\\StudentInfo.txt文件中
        //创建字符输出对象
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        for (Student student : arrayList){
            //拼接学生信息
            String line = student.getName()+","+student.getGender()+","+student.getAge();
            bw.write(line);
            bw.write("\r\n");
            bw.flush();
        }
        bw.close();

        //(4)读取D:\\StudentInfo.txt文件中的ArrayList对象
        //创建字符输入流对象
        BufferedReader fr = new BufferedReader(new FileReader(file));
        System.out.println("D:\\\\StudentInfo.txt文件中的ArrayList对象为：");
        String line;
        while ((line=fr.readLine())!=null){
            System.out.println(line);
        }

        //(5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge()-o2.getAge();
                return num;
            }
        });
        for (Student student : arrayList){
            treeSet.add(student);
        }

        //(6)将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\\StudentInfo.txt文件中(写入格式：张三-男-25)
        PrintWriter pw = new PrintWriter(new FileWriter("E:\\\\StudentInfo.txt"));
        for (Student student : treeSet){
            //拼接学员信息
            String line1 = student.getName()+"-"+student.getGender()+"-"+student.getAge();
            pw.println(line1);
        }
        pw.close();
    }
}

4，（综合案列 闲得慌的同学优先考虑）

有一个TransRecord.txt文件,保存的是交易记录明细。一行是一条交易明细，每行分7列。
请编码，实现如下功能：
1、设计一个交易记录类TransRecord (金额字段数据类型定为double)
2、解析文件(IO流)，将文件中数据，将每条交易明细封装为1个TransRecord对象。所有TransRecord对象，添加到一个集合中，并且打印到控制台；（就是将对象添加到集合并打印集合）BufferedReader 方法readLine()
3、完成一个功能（方法）：输入客户号，查询交易明细记录并打印出来，封装成一个方法，通过传入客户号作为参数
4、定义一个方法，计算总金额并打印到控制台；（遍历集合中对象，获取每个对象的金额相加）
5、定义一个方法，按金额升序排序，并且打印到控制台；Set自然或定制排序

TransRecord.txt文件如下：

客户号 客户姓名 所属机构号 性别 账号 发生时间 发生额

000001 小刘 0000 1 4155990188888888 2014-07-20 300.00
000201 小赵 0002 1 4155990199999999 2019-07-20 500.00
000101 小钱 0012 0 4155990100000000 2019-05-20 1000.50
000102 小孙 0012 1 4155990155555555 2014-07-20 600.99
000301 小李 0013 0 41559901111111111 2014-07-22 5000.00
000001 小周 0000 1 155990188888888 2020-01-25 21200.00

测试类：

public class Work04 {
    public static void main(String[] args) throws IOException, ParseException {
        //2、解析文件(IO流)，将文件中数据，将每条交易明细封装为1个TransRecord对象。所有TransRecord对象，添加到一个集合中，并且打印到控制台；（就是将对象添加到集合并打印集合）BufferedReader 方法readLine()
        //创建字符缓冲输入流对象（数据源）
        BufferedReader br = new BufferedReader(new FileReader("E:\\JavaSE_Code\\myFile\\day38\\src\\stage8_IOStream_Work04\\TransRecord.txt"));
        //创建集合存储数据
        ArrayList<TransRecord> arrayList = new ArrayList<>();
        String line;
        while((line=br.readLine())!=null){
            String[] split = line.split("\\s+");//正则表达式，匹配任意空格字段
            //id name number sex account date money
            String id=split[0];
            String name = split[1];
            String number = split[2];
            int sex = Integer.parseInt(split[3]);
            String account = split[4];
            String date = split[5];
            double money = Double.parseDouble(split[6]);
            arrayList.add(new TransRecord(id,name,number,sex,account,date,money));
        }
        br.close();
        for (TransRecord transRecord : arrayList){
            System.out.println(transRecord);
        }

        //3、完成一个功能（方法）：输入客户号，查询交易明细记录并打印出来，封装成一个方法，通过传入客户号作为参数
        System.out.println("请输入要查找的客户号：");
        Scanner scanner = new Scanner(System.in);
        String getId = scanner.nextLine();
        foundDetails(getId,arrayList);

        //4、定义一个方法，计算总金额并打印到控制台；（遍历集合中对象，获取每个对象的金额相加）
        getSumMoney(arrayList);

        //5、定义一个方法，按金额升序排序，并且打印到控制台；Set自然或定制排序
        moneySort(arrayList);
    }

    private static void moneySort(ArrayList<TransRecord> arrayList) {
        System.out.println("-------------");
        TreeSet<TransRecord> treeSet = new TreeSet<TransRecord>(new Comparator<TransRecord>() {
            @Override
            public int compare(TransRecord o1, TransRecord o2) {
                return (int)(o1.getMoney()- o2.getMoney());
            }
        });
        for (TransRecord transRecord:arrayList){
           treeSet.add(transRecord);
        }
        for (TransRecord transRecord:treeSet){
            System.out.println(transRecord);
        }
    }

    private static void getSumMoney(ArrayList<TransRecord> arrayList) {
        int sum=0;
        for (TransRecord transRecord:arrayList){
            sum += transRecord.getMoney();
        }
        System.out.println("-----------");
        System.out.println("交易总金额为："+sum);
    }

    private static void foundDetails(String getId,ArrayList<TransRecord> arrayList) {
        System.out.println("------------");
        System.out.println("客户号为"+getId+"的交易明细为：");
        for (TransRecord transRecord:arrayList){
            if (transRecord.getId().equals(getId)){
                System.out.println(transRecord);
            }
        }
    }
    
}

TransRecord实体类

public class TransRecord {
    /**
     * 客户号
     */
    private String id;
    /**
     * 客户姓名
     */
    private String name;
    /**
     * 所属机构号
     */
    private String number;
    /**
     * 性别
     */
    private int sex;
    /**
     * 账号
     */
    private String account;
    /**
     * 发生时间
     */
    private String date;
    /**
     * 发生额
     */
    private double money;

    public TransRecord() {
    }

    public TransRecord(String id, String name, String number, int sex, String account, String date, double money) {
        this.id = id;
        this.name = name;
        this.number = number;
        this.sex = sex;
        this.account = account;
        this.date = date;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return  "客户号：" + id +
                ", 客户姓名：" + name +
                ", 所属机构号：" + number +
                ", 性别：" + sex +
                ", 账号：" + account +
                ", 发生时间：" + date +
                ", 发生额：" + money;
    }
}

配置文件内容：

000001   小刘       0000     1   4155990188888888        2014-07-20        300.00
000201   小赵       0002     1    4155990199999999       2019-07-20        500.00
000101   小钱       0012     0    4155990100000000       2019-05-20        1000.50
000102   小孙       0012     1    4155990155555555       2014-07-20        600.99
000301   小李       0013     0    41559901111111111      2014-07-22        5000.00
000001   小周       0000     1    155990188888888        2020-01-25        21200.00