IO流案例

已知⽂件 source.txt 中的内容如下

username=root,password=1234,id=1,level=10
username=adimin,mima=1234,id=2,level=11
yonghu=xiaoming,dengji=12,password=1234,id=3

其中，username、yonghu 都表示⽤户名，password、mima都表示密码，level、dengji都表示等级

• 在桌⾯上的这个source.txt⽂件拷⻉到项⽬ file\data.txt 中（注意：⽅式不限，不是移动！）
• 读取⽂本中的数据，将每⼀⾏的数据封装成模型，存⼊ List 中
• 去除集合中id重复的数据，只保留重复id的第⼀个数据
• 计算这些⽤户的平均等级、最⾼等级、最低等级
• 将集合中的数据按照等级降序排序
• 查询集合中等级为[7,15]范围内的第[4,8]个，并将结果按照id升序
• 将这个集合序列化到本地，并反序列化遍历

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;

public class Test {
    private static class User implements Serializable {
        private String username;
        private String password;
        private int id;
        private int level;

        /**
         * 根据⽂本中每⼀⾏的数据，实例化⼀个User对象
         *
         * @param info ⽂本中的每⼀⾏的数据
         */
        public User(String info) {
            String[] parts = info.split(",");

            for (String part : parts) {
                String[] pair = part.split("=");

                String key = pair[0].trim();
                String value = pair[1].trim();

                if (key.matches("username|youghu")) {
                    this.username = value;
                } else if (key.matches("password|mima")) {
                    this.password = value;
                } else if (key.matches("id")) {
                    this.id = Integer.parseInt(value);
                } else if (key.matches("level|dengji")) {
                    this.level = Integer.parseInt(value);
                }
            }
        }

        public String getUsername() {
            return username;
        }

        public String getPassword() {
            return password;
        }

        public int getId() {
            return id;
        }

        public int getLevel() {
            return level;
        }

        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", id=" + id +
                    ", level=" + level +
                    '}';
        }
    }

    public static void main(String[] args) {
        //1.将⽂件拷⻉到项⽬ file\data.txt 中
        copyFile("C:\\Users\\22150\\Desktop\\source.txt","Bigdataday20\\src\\file\\data.txt");

        //2.读取⽂本中的数据，存⼊集合
        List<User> list = getData();
        //System.out.println(list);

        //3.按照id进⾏去重
        distinct(list);

        //4.计算这些⽤户的平均等级、最⾼等级、最低等级
        calculateUser(list);

        //5.将集合中的数据按照等级降序排序
        list.sort((u1,u2)->u2.getLevel()-u1.getLevel());
        System.out.println("等级降序排序后:"+list);

        //6.序列化
        //save(list);

        // 7、反序列化
        load();

    }

    /**
     * 文件拷贝
     *
     * @param src 源路径
     * @param dst 目标路径
     */
    private static void copyFile(String src, String dst) {
        try {
            // 创建⽂件夹
            Files.createDirectory(Paths.get("file"));
            // 拷⻉⽂件
            Files.copy(Paths.get(src), Paths.get(dst));
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 读取⼀个⽂件中的每⼀⾏内容，将其封装成User对象，存⼊集合
     *
     * @return 存储了所有的User对象的集合
     */
    private static List<User> getData() {
        // 1、实例化⼀个List集合
        List<User> list = new ArrayList<>();

        // 2、读取⽂本中的内容
        try (Scanner scanner = new Scanner(new File("Bigdataday20\\src\\file\\data.txt"))) {
            // 3、判断是否还有下⼀⾏的数据可读
            while (scanner.hasNextLine()) {
                // 4、读取每⼀⾏
                String line = scanner.nextLine();
                // 5、将每⼀⾏的数据封装成User对象，存⼊集合
                list.add(new User(line));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 将集合中的元素按照id去重
     * @param list  需要去重的集合
     */
    private static void distinct(List<User> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if(list.get(i).getId() == list.get(j).getId()){
                    list.remove(j--);
                }
            }
        }
    }

    /**
     * 计算这些⽤户的平均等级、最⾼等级、最低等级
     * @param list  存储所有⽤户的集合
     */
    private static void calculateUser(List<User> list){
        // 将集合中的元素，映射成⼀个个的等级数据，并分析这个IntStream中的元素
        IntSummaryStatistics summaryStatistics = list.stream().mapToInt(User::getLevel).summaryStatistics();

        System.out.println("最低等级:"+summaryStatistics.getMin());
        System.out.println("最高等级:"+summaryStatistics.getMax());
        System.out.println("平均等级:"+summaryStatistics.getAverage());
    }

    /**
     * 查询集合中等级为[7,15]范围内的第[4,8]个，并将结果按照id升序
     * @param list  需要排序的集合
     * @return  排完序的集合
     */
    private static List<User> findUsers(List<User> list){
        return list.stream().sorted((u1,u2)->u2.getLevel()-u1.getLevel()).filter(u->u.getLevel()>=7&&u.getLevel()<=15).limit(15).skip(6).sorted(Comparator.comparingInt(User::getId)).collect(Collectors.toList());
    }

    private static void save(List<User> list){
        try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("Bigdataday20\\src\\file\\data.txt")))){
            oos.writeObject(list);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void load(){
        try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("Bigdataday20\\src\\file\\data.txt")))){
            Object object = ois.readObject();

            // 强转成集合
            if(object instanceof List){
                List<User> list = (List<User>) object;

                for (User user : list) {
                    System.out.println("反序列化:"+user);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}