Java IO流高级实战：数据处理与序列化-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43847613/article/details/119486323

该博客介绍了使用Java IO流进行高级数据处理的实战案例，包括读取GBK文件，创建Person对象，过滤未成年数据，计算平均年龄、最大最小年龄，排序，筛选特定条件的数据，以及数据的序列化和反序列化操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实战案例一：

已知⼀个⽂本内容如下：

name:xiaoming,age:10岁,gender:male,height:172cm,weight:70kg
age:20岁,height:177cm,name:xiaobai,weight:80kg,gender:male
gender:female,height:176cm,weight:66kg,name:xiaolv,age:21岁

每⼀⾏是数据为⼀个⼈的信息，但是顺序是不固定的。

在桌⾯上创建⼀个GBK⽂件，将内容写到这个⽂件中。（可以使⽤IDEA创建GBK⽂件）
将桌⾯创建的⽂件⽤代码复制到项⽬下的 file\source 路径下。
读取这个⽂本中的数据，将每⼀⾏的数据封装到⼀个 Person 对象中，并存⼊⼀个 List 集合
删除集合中所有的未成年的数据
计算所有⼈的平均年龄、最⼤年龄、最⼩年龄
将集合中的数据按照年龄进⾏降序排序，若年龄相同，按照身⾼降序排序
查询集合中所有的年龄在[20, 25]范围内，体重在[60, 80]范围内的数据，按照身⾼降序排列，截取第4名到第8名。
将集合中的数据序列化到本地
将本地序列化的⽂件反序列化，得到集合，并遍历输出⾥⾯的内容

1.先创建一个Person对象(可以写为静态内部类)

class Person implements Serializable {
    private enum Gender {
        male, female
    }

    private String name;
    private int age;
    private Gender gender;
    private int height;
    private int weight;

    /**
     * 通过⽂本中的⼀⾏数据，实例化⼀个Person对象
     *
     * @param line ⽂本中的⼀⾏数据
     */
    public Person(String line) {
        // 1、实例化⼀个Map集合，存储每⼀个属性的值（键值对）
        Map<String, String> properties = new HashMap<>();

        // 2、切割字符串
        String[] parts = line.split(",");

        // 3、遍历这个数组
        for (String part : parts) {
            String[] tmp = part.split(":");
            properties.put(tmp[0], tmp[1]);
        }

        // 4、遍历map，给每⼀个属性赋值
        properties.forEach((k, v) -> {
            switch (k) {
                case "name":
                    name = v;
                    break;
                case "age":
                    age = Integer.parseInt(v.replace("岁", ""));
                    break;
                case "gender":
                    gender = v.equalsIgnoreCase("male") ? Gender.male : Gender.female;
                    break;
                case "height":
                    height = Integer.parseInt(v.replace("cm", ""));
                    break;
                case "weight":
                    weight = Integer.parseInt(v.replace("kg", ""));
                    break;
            }
        });
    }

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

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", height=" + height +
                ", weight=" + weight +
                '}';
    }
}

2.将桌⾯创建的⽂件⽤代码复制到项⽬下的 file\source 路径下。

private static void two() {
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\22150\\Desktop\\data.txt"), "GBK"));
             BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\soure")))) {
            String line = "";
            while ((line = bufferedReader.readLine()) != null) {
                bufferedWriter.write(line);
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

读取这个⽂本中的数据，将每⼀⾏的数据封装到⼀个 Person 对象中，并存⼊⼀个List 集合

	/**
     * 3、读数据，存集合
     * @return 集合
     */
    private static List<Person> three() {
        // 1、实例化⼀个集合，存储数据
        List<Person> list = new ArrayList<>();

        try (BufferedReader reader = new BufferedReader(new FileReader("D:\\IDEA\\java\\Bigdataday20\\src\\file\\soure"))) {
            //2、定义⼀个字符串，⽤来接收每⼀⾏读取到的数据
            String line = "";
            // 3、循环读取数据
            while ((line = reader.readLine()) != null) {
                list.add(new Person(line));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

删除集合中所有的未成年的数据

private static void four(List<Person> list) {
        list.removeIf(p -> p.getAge() < 18);
    }

计算所有⼈的平均年龄、最⼤年龄、最⼩年龄

private static void five(List<Person> list) {
        IntSummaryStatistics statistics = list.stream().mapToInt(Person::getAge).summaryStatistics();
        System.out.println("最低等级:" + statistics.getMin());
        System.out.println("最高等级:" + statistics.getMax());
        System.out.println("平均等级:" + statistics.getAverage());
    }

将集合中的数据按照年龄进⾏降序排序，若年龄相同，按照身⾼降序排序

private static void six(List<Person> list) {
        list.sort((p1, p2) -> {
            return p1.getAge() != p2.getAge() ? p2.getAge() - p1.getAge() : p2.getHeight() - p1.getHeight();
        });
    }

或者

private static void six(List<Person> list) {
        list.sort((p1, p2) -> {
            if (p1.getAge() != p2.getAge()) {
                return p2.getAge() - p1.getAge();
            }
            else {
                return p2.getHeight() - p1.getHeight();
            }
        });
    }

查询集合中所有的年龄在[20, 25]范围内，体重在[60, 80]范围内的数据，按照身⾼降序排列，截取第4名到第8名。

private static List<Person> seven(List<Person> list) {
        return list.stream()
                .filter(p -> p.getAge() >= 20 && p.getAge() <= 25)
                .filter(p -> p.getWeight() >= 60 && p.getWeight() <= 80)
                .sorted((p1, p2) -> p2.getHeight() - p1.getHeight())
                .limit(8).skip(2).collect(Collectors.toList());
    }

将集合中的数据序列化到本地

private static void eight(List<Person> list) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\serialize"))) {
            oos.writeObject(list);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

将本地序列化的⽂件反序列化，得到集合，并遍历输出⾥⾯的内容

private static void nine() {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\serialize"))) {
            //读取数据
            Object obj = ois.readObject();

            if (obj instanceof List) {
                List<Person> list = (List<Person>) obj;

                for (Person person : list) {
                    System.out.println(person);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

完整代码：

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        two();
        List<Person> list = three();
        four(list);
        five(list);
        six(list);
        seven(list);
        //eight(list);
        nine();
    }

    private static class Person implements Serializable {
        private enum Gender {
            male, female
        }

        private String name;
        private int age;
        private Gender gender;
        private int height;
        private int weight;

        /**
         * 通过⽂本中的⼀⾏数据，实例化⼀个Person对象
         *
         * @param line ⽂本中的⼀⾏数据
         */
        public Person(String line) {
            // 1、实例化⼀个Map集合，存储每⼀个属性的值（键值对）
            Map<String, String> properties = new HashMap<>();

            // 2、切割字符串
            String[] parts = line.split(",");

            // 3、遍历这个数组
            for (String part : parts) {
                String[] tmp = part.split(":");
                properties.put(tmp[0], tmp[1]);
            }

            // 4、遍历map，给每⼀个属性赋值
            properties.forEach((k, v) -> {
                switch (k) {
                    case "name":
                        name = v;
                        break;
                    case "age":
                        age = Integer.parseInt(v.replace("岁", ""));
                        break;
                    case "gender":
                        gender = v.equalsIgnoreCase("male") ? Gender.male : Gender.female;
                        break;
                    case "height":
                        height = Integer.parseInt(v.replace("cm", ""));
                        break;
                    case "weight":
                        weight = Integer.parseInt(v.replace("kg", ""));
                        break;
                }
            });
        }

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

        public Gender getGender() {
            return gender;
        }

        public void setGender(Gender gender) {
            this.gender = gender;
        }

        public int getHeight() {
            return height;
        }

        public void setHeight(int height) {
            this.height = height;
        }

        public int getWeight() {
            return weight;
        }

        public void setWeight(int weight) {
            this.weight = weight;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", gender=" + gender +
                    ", height=" + height +
                    ", weight=" + weight +
                    '}';
        }
    }

    private static void two() {
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\22150\\Desktop\\data.txt"), "GBK"));
             BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\soure")))) {
            String line = "";
            while ((line = bufferedReader.readLine()) != null) {
                bufferedWriter.write(line);
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 3、读数据，存集合
     * @return 集合
     */
    private static List<Person> three() {
        // 1、实例化⼀个集合，存储数据
        List<Person> list = new ArrayList<>();

        try (BufferedReader reader = new BufferedReader(new FileReader("D:\\IDEA\\java\\Bigdataday20\\src\\file\\soure"))) {
            //2、定义⼀个字符串，⽤来接收每⼀⾏读取到的数据
            String line = "";
            // 3、循环读取数据
            while ((line = reader.readLine()) != null) {
                list.add(new Person(line));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }


    private static void four(List<Person> list) {
        list.removeIf(p -> p.getAge() < 18);
    }

    private static void five(List<Person> list) {
        IntSummaryStatistics statistics = list.stream().mapToInt(Person::getAge).summaryStatistics();
        System.out.println("最低等级:" + statistics.getMin());
        System.out.println("最高等级:" + statistics.getMax());
        System.out.println("平均等级:" + statistics.getAverage());
    }

    private static void six(List<Person> list) {
        list.sort((p1, p2) -> {
            return p1.getAge() != p2.getAge() ? p2.getAge() - p1.getAge() : p2.getHeight() - p1.getHeight();
        });
    }

    private static List<Person> seven(List<Person> list) {
        return list.stream()
                .filter(p -> p.getAge() >= 20 && p.getAge() <= 25)
                .filter(p -> p.getWeight() >= 60 && p.getWeight() <= 80)
                .sorted((p1, p2) -> p2.getHeight() - p1.getHeight())
                .limit(8).skip(2).collect(Collectors.toList());
    }

    private static void eight(List<Person> list) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\serialize"))) {
            oos.writeObject(list);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void nine() {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\IDEA\\java\\Bigdataday20\\src\\file\\serialize"))) {
            //读取数据
            Object obj = ois.readObject();

            if (obj instanceof List) {
                List<Person> list = (List<Person>) obj;

                for (Person person : list) {
                    System.out.println(person);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

IO流高级案例