IO与集合习题综合练习

编程题

1. 文件IO练习

事先在当前目录下准备好一个 test.txt 的文本文件，要求该文本文件是使用
GBK 编码的多行文本文件。如：

窗前明月光
疑是地上霜
举头望明月
低头思故乡

利用字节流+桥转换+缓冲流读入这个文本文件，然后按照行的顺序，以 UTF-8 的编码方
式，写到 test2.txt 文件中，例：

低头思故乡
举头望明月
疑是地上霜
窗前明月光

public class TestPoem {

    public static void main(String[] args) throws IOException {
        BufferedReader a1 = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\lenovo\\Desktop\\诗.txt"),"gbk"));
        PrintWriter w1 = new PrintWriter(new OutputStreamWriter(new FileOutputStream("C:\\Users\\lenovo\\Desktop\\诗2.txt"),"utf-8"));
        List<String> list = new ArrayList<>();
        while(true) {
            String line = a1.readLine();
            if(line == null) {
                break;
            }
            list.add(line);
        }
        Collections.reverse(list);
        for (String line : list) {
            w1.println(line);
        }
        w1.close();
        a1.close();
    }
}

2. 文件IO练习(外部排序)

有三个文本文件，里面都是排序的多行数字，如：
1.txt
1
4
8

2.txt

2
5
9
3.txt
3
6
7

利用流读取这三个文件内容，并按数字顺序输出到一个新的文件中：result.txt
1
2
3
4
5
6
7
8
9

解题要点: 要想象这三个文件内容特别大，不能一次性全部将数据读入内存，要那么做就失去流的好处了。

class Value implements Comparable<Value>{
    private BufferedReader reader;// 存储reader
    private String value; // 存储reader获取的下一行值
    public Value(BufferedReader reader) {
        this.reader = reader;
    }
    // 获取转换为数字后的结果
    public Integer getValue() {
        return Integer.parseInt(value);
    }
    // 获取下一行值
    public void next() {
        try {
            value = reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    // 检查是否有下一行值
    public boolean hasNext() {
        return value != null;
    }
    // 根据整数值进行比较
    @Override
    public int compareTo(Value o) {
        return getValue().compareTo(o.getValue());
    }
    @Override
    public String toString() {
        return "Value{" +
                "value='" + value + '\'' +
                '}';
    }
}
public class TestSort {
    public static void main(String[] args) throws Exception {
        BufferedReader a1 = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\lenovo\\Desktop\\a.txt")));
        BufferedReader a2 = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\lenovo\\Desktop\\b.txt")));
        BufferedReader a3 = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\lenovo\\Desktop\\c.txt")));
        // 构造Value对象，每个Value对象对应一个输入流，用来获取一个文件的内容
        Value v1 = new Value(a1);
        Value v2 = new Value(a2);
        Value v3 = new Value(a3);
        // 每个文件先读取第一行
        v1.next();
        v2.next();
        v3.next();
        // 用TreeSet集合保存3个Value对象，保证其中的对象按数字大小排序
        TreeSet<Value> set = new TreeSet<>();
        set.add(v1);
        set.add(v2);
        set.add(v3);
        while(true) {
            System.out.println(set);
            // set中没有更多元素，退出循环
            if(set.size()==0) {
                break;
            }
            // 移除最小的value对象，并打印
            Value value = set.pollFirst();
            System.out.println(value.getValue());
            // 因为这个value对象可能还会有下一行数据未读取，调用next读取下一行数据
            value.next();
            // 如果还有下一行数据，将它重新放入set集合排序
            if(value.hasNext()) {
               set.add(value);
            }
        }
        a1.close();
        a2.close();
        a3.close();
    }
}

3. 查看output.txt完成如下功能

功能1
从一个文本文件output.txt读取数据并转换为List<Person>集合
文本文件的格式为：

1   阿会喃 云南  男   190 225 74
2   伊籍  江陵  男   162 226 24
...

每行数据代表一条武将信息，同时也对应一个Person对象，武将多个属性之间使用\t分隔，多个武将之间使用\r\n即回车换行分隔

解题思路
1. String 的 split() 方法可以根据分隔符将其分隔为一个String[]
2. 将分隔后的每一列数据与Person对象的属性相对应
3. 注意Person对象有的属性是整数类型，Integer.parseInt()方法可以用来将字符串转为整数

功能2
在功能1的基础上，求出武力最高的3名武将
例如：

吕布  100
张飞  98
关羽  97

解题思路
1. List集合有 sort(Comparator comparator)方法可以用来对List集合排序
2. Comparator 是个接口，需要实现一个带两个参数的抽象方法 public int compare(Person a, Person b)，比较返回正数表示a对象大于b对象，返回负数表示a对象小于b对象，返回0表示a与b大小相等，这时sort方法根据a与b谁大谁小就可以完成排序
3. 排序之后，再利用 List.subList() 方法截取前3个对象
4. 如果对jdk8的stream api 比较熟悉，可以尝试换用stream api来解

功能3
在功能1的基础上，求出武力排名前三的武将，与上题不同的是排名需要考虑武力相同的情况
例如：

吕布  100 第一名
张飞  98  第二名
关羽  97  第三名
马超  97  第三名

其中关羽和马超并列第三，都应该纳入结果

解题思路
1. 先想办法求出最高的武力有哪几个，武力去重，排序，求前三
2. 既需要去重，又需要排序，可以考虑将所有武力放入TreeSet<Integer> set = new TreeSet(Comparator<Integer> comparator) 集合
3. 再比较哪些武将的武力与上一步三个武力值一样，即为最终结果

功能4
按所在地分组，并显示平原出身的有哪些武将
例如：

平原
    郭淮
    刘备
    裴元绍
    张角
    郭氏
上庸
    申耽
    申仪
南皮
    ...

解题思路
1. Map集合比较适合此题，可以使用地名作为key，List作为值
2. 对于List应做如下判断，如果是一个地区的第一个武将，则应当创建新的集合，如果本地区剩余的武将，应当追加至集合

功能5
统计所有武将的男女比例段（女性比例按1计算）

解题思路
1. 有多种解法，建议使用Map解答，为下一题做铺垫

功能6
统计各个年龄段的武将
输出结果类似于：

10~19岁
    刘琮,曹冲
20~29岁
    孙策,孙尚香,孙翊,袁尚,夏侯恩,赵弘,严纲,公孙续,曹昂,刘谌,貂蝉
...

解题思路
1. 使用Map求解，年龄段作为key，List作为值

功能7
统计各个年龄段的男女比例
输出结果类似于：

10~19岁 男:女为    2:0
20~29岁 男:女为    9:2
30~39岁 男:女为    95:9
40~49岁 男:女为    129:7
50~59岁 男:女为    89:8
60岁以上   男:女为    119:5

解题思路
1. 先按照年龄段分组，在按照性别分组，java的数据结构表示为Map<年龄段, Map<性别, List<武将>>>
2. 两次分组，Map集合就嵌套两次

功能8
统计平均年龄

功能9
统计最长寿的地区

解题思路
1. 先按照地区分组，再求每组平均年龄，最后找到最大值
2. 需要分组的题目，都可以考虑用Map集合来实现

import org.junit.Test;

import java.io.*;
import java.util.*;

/**
 * *************************************
 * Copyright (c) 2018 feiyan.com
 * All rights reserved.
 * *************************************
 * *************************************
 *
 * @Author: think
 * @Project: JavaSE
 * @Date: Created in 2018/8/9 8:34
 * @Since: JDK 1.8
 * @Version: 1.0
 * @Modified By:
 * @Description：
 */
public class WorkingDemo {

    public static List<Hero> heroes;

    static {
        heroes = createHero();
    }

public static List<Hero> createHero(){
    List<Hero> list = new ArrayList<>();
    try {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(
                "src/org/westos/homework/day16/output.txt")));

        String line = null;
        while ((line = bufferedReader.readLine()) != null){
            // 分割出来英雄的每个属性
            String[] split = line.split("\\s+");
            Hero hero = new Hero();

            // 给英雄的属性赋值
            int k = 0;
            hero.setId(Integer.parseInt(split[k++]));
            hero.setName(split[k++]);
            hero.setBirthPlace(split[k++]);
            hero.setGender(split[k++]);
            hero.setBirthYear(split[k++]);
            hero.setDeadYear(split[k++]);
            hero.setForceValue(Integer.parseInt(split[k]));

            // 添加到英雄列表
            list.add(hero);
        }

        bufferedReader.close();

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return list;
}


@Test
public void test2(){
    Collections.sort(heroes, (o1, o2)->o2.getForceValue() - o1.getForceValue());
    List<Hero> top3Heroes = WorkingDemo.heroes.subList(0, 3);
    System.out.println(top3Heroes);
}

@Test
public void test3(){

    TreeSet<Integer> treeSet = new TreeSet<>((o1, o2) -> o2 - o1);

    // 对武力值去重
    for (Hero hero : heroes) {
        treeSet.add(hero.getForceValue());
    }

    // treeSet.forEach(System.out::println);

    HashSet<Integer> set = new HashSet<>();
    // 获取并删除第一个（也就是最小的）元素
    set.add(treeSet.pollFirst());
    set.add(treeSet.pollFirst());
    set.add(treeSet.pollFirst());
    for (Hero hero : heroes) {
        if(set.contains(hero.getForceValue())){
            System.out.println(hero);
        }
    }

// 武力值排名前三
// 计数变量
//        int n = 0;
//        int t = 0;
//        for (Integer i : treeSet) {
//            t++;
//            for (Hero hero : heroes) {
//                if(hero.getForceValue() == i){
//                    System.out.println(hero.getName() + " : " + hero.getForceValue() +
//                            "  第" + (++n) + "名");
//                }
//            }
//            if(t == 3){
//                break;
//            }
//        }
    }

@Test
public void test4(){
    // HashMap 用于存储键（出生地）值（英雄姓名）对的英雄
    HashMap<String, List<String>> hashMap = new HashMap<>();

    // 创建新的list用于存储对应出生地的英雄
    for (Hero hero : heroes) {
        List<String> names = hashMap.get(hero.getBirthPlace());
        // 如果这个地方没有英雄
        if(names == null){
            names = new ArrayList<>();
            hashMap.put(hero.getBirthPlace(), names);
        }
        names.add(hero.getName());
    }


    /*String place = heroes.get(0).getBirthPlace();
    list.add(heroes.get(0));
    for (int i = 1; i < heroes.size(); i++) {
        if(hashMap.containsKey(place)){
            list.add(heroes.get(i));
        }else{
            hashMap.put(place, list);
            place = heroes.get(i).getBirthPlace();
            list.clear();
            list.add(heroes.get(i));
        }
    }*/

    for (Map.Entry<String, List<String>> entry : hashMap.entrySet()) {
        System.out.println(entry.getKey() + ":");
        for (String name : entry.getValue()) {
            System.out.print("\t" + name + "  ");
        }
        System.out.println();
    }


}

@Test
public void test5(){

    // HashMap 用于存储键（性别）值（英雄）对的英雄
    Map<String, List<String>> map = new HashMap<>();
    map.put("男", new ArrayList<>());
    map.put("女", new ArrayList<>());
    for(Hero hero: heroes) {
        map.get(hero.getGender()).add(hero.getName());
    }
    System.out.println(map.get("男").size() +":" + map.get("女").size());
}

@Test
public void test6(){
    Map<String, List<String>> map = new TreeMap<>();
    map.put("10~19岁", new ArrayList<>());
    map.put("20~29岁", new ArrayList<>());
    map.put("30~39岁", new ArrayList<>());
    map.put("40~49岁", new ArrayList<>());
    map.put("50~59岁", new ArrayList<>());
    map.put("60岁以上", new ArrayList<>());
    for(Hero hero : heroes) {
        if(hero.getAge() >=10 && hero.getAge() <= 19) {
            map.get("10~19岁").add(hero.getName());
        } else if(hero.getAge() >=20 && hero.getAge() <= 29) {
            map.get("20~29岁").add(hero.getName());
        } else if(hero.getAge() >=30 && hero.getAge() <= 39) {
            map.get("30~39岁").add(hero.getName());
        } else if(hero.getAge() >=40 && hero.getAge() <= 49) {
            map.get("40~49岁").add(hero.getName());
        } else if(hero.getAge() >=50 && hero.getAge() <= 59) {
            map.get("50~59岁").add(hero.getName());
        } else if(hero.getAge() >=60) {
            map.get("60岁以上").add(hero.getName());
        }
    }
    map.forEach((k, v) -> {
        System.out.println(k);
        System.out.println(v);
    });
}

@Test
public void test7(){
    Map<String, Map<String, List<String>>> map = new TreeMap<>();
    map.put("10~19岁", new HashMap<>());
    map.put("20~29岁", new HashMap<>());
    map.put("30~39岁", new HashMap<>());
    map.put("40~49岁", new HashMap<>());
    map.put("50~59岁", new HashMap<>());
    map.put("60岁以上", new HashMap<>());
    map.forEach((k,v)->{
        v.put("男", new ArrayList<>());
        v.put("女", new ArrayList<>());
    });

    for (Hero hero : heroes) {
        if(hero.getAge() >=10 && hero.getAge() <= 19) {
            map.get("10~19岁").get(hero.getGender()).add(hero.getName());
        } else if(hero.getAge() >=20 && hero.getAge() <= 29) {
            map.get("20~29岁").get(hero.getGender()).add(hero.getName());
        } else if(hero.getAge() >=30 && hero.getAge() <= 39) {
            map.get("30~39岁").get(hero.getGender()).add(hero.getName());
        } else if(hero.getAge() >=40 && hero.getAge() <= 49) {
            map.get("40~49岁").get(hero.getGender()).add(hero.getName());
        } else if(hero.getAge() >=50 && hero.getAge() <= 59) {
            map.get("50~59岁").get(hero.getGender()).add(hero.getName());
        } else if(hero.getAge() >=60) {
            map.get("60岁以上").get(hero.getGender()).add(hero.getName());
        }
    }
    map.forEach((k,v)->{
        System.out.println(k);
        System.out.println(v.get("男").size() +":"+v.get("女").size());
    });
}

@Test
public void test8(){
    int totalAge =0;
    for(Hero hero : heroes) {
        totalAge += hero.getAge();
    }
    System.out.println("平均年龄：" + totalAge / heroes.size());
}

@Test
public void test9(){
    Map<String, List<Hero>> map = new HashMap<>();
    for (Hero hero : heroes) {
        List<Hero> list = map.get(hero.getBirthPlace());
        if(list == null) {
            list = new ArrayList<>();
            map.put(hero.getBirthPlace(), list);
        }
        list.add(hero);
    }

    // 求平均年龄
    TreeMap<Integer, String> treeMap = new TreeMap<>((a,b)->b-a);
    map.forEach( (k,v) -> {
        int total = 0;
        for (Hero hero : v) {
            total += hero.getAge();
        }

        // System.out.println(k +"的平均年龄："+total/v.size());

        treeMap.put(total / v.size(), k);
    });

    System.out.println(treeMap.firstEntry());
}

}