面试题实操——一些简单的集合面试题

案例一：从控制台接收10个整数进行排序，按降序在控制台输出。

①：方法一

此方法需要定义ArrayList集合储存输入的10个整数，然后调用list.sort(null)升序排序，此时我们可以倒着遍历，或者对此升序集合进行倒转输出，需要用到集合工具类：Collections.sort(list,comparator.rexerseOrder())

private static void testA(){
        //1.1) 定义扫描器对象
        Scanner sc = new Scanner(System.in);
        //1.2) 定义存储输入数的集合
        System.out.println("请输入10个整数：");
        List<Integer> list = new ArrayList<>();
        //1.3）提示用户输入10个整数
        //1.4) 循环输入10个数，将输入的数添加到集合中
        for (int i = 0; i < 10; i++) {
            int a = sc.nextInt();
            //1.5) 添加到数组中
            list.add(a);
        }
        //1.6) 使用sort方法进行排序（默认的是升序）
//        list.sort(null);                                              (写法一)
        //Collections.sort(list);                                      //（写法二）
        Collections.sort(list,Comparator.reverseOrder());           //(写法三,直接逆序排序)

        //1.7) 逆序遍历集合
        for (int i = list.size() - 1; i >= 0 ; i--) {
            System.out.print(list.get(i) + "\t");
        }

②：方法二（传统方法）

此方法为常规方法，需要用到工具类中的比较器方法，在匿名内部类中重写comparator方法决定他们最终排序的是升序还是降序。注意：o1-o2 =负数:升序。o1 - o2 =0:相等。o1 - o2 = o2 - o1 = 正数：降序:

public static void testB(){
        //1.1) 定义扫描器对象
        Scanner sc = new Scanner(System.in);
        //1.2) 定义存储输入数的集合
        System.out.println("请输入10个整数：");
        List<Integer> list = new ArrayList<>();
        //1.3）提示用户输入10个整数
        //1.4) 循环输入10个数，将输入的数添加到集合中
        for (int i = 0; i < 10; i++) {
            int a = sc.nextInt();
            //1.5) 添加到数组中
            list.add(a);
        }
        //1.6) 进行降序排序,new一个比较器，其o1 - o2 返回负数，代表o1 > o2 升序， o1 = o2 返回0代表相等，o2 - o1 代表正数，代表降序
//        list.sort(new Comparator<Integer>() {                     //传统写法
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                //return o1 - o2;   升序
//                return o2 - o1;     //降序
//            }
//        });
        list.sort((o1, o2) -> o2-o1);               //相当于上面的简写格式
        Collections.sort(list,Comparator.reverseOrder());//直接降序排序
        list.forEach(System.out::println);
    }

③：方法三（TreeSet集合）

此方法是用TreeSet集合特点是升序排序，但是因为它是无序不能遍历从后往前拿值，那么我们需要把它的元素储存到ArrayList（set）中，再对其进行倒转或者使用传统方法（详细看第一第二方法）

public static void testC(){
        //1.1) 定义扫描器对象
        Scanner sc = new Scanner(System.in);
        //1.2) 定义存储输入数的集合
        System.out.println("请输入10个整数：");
        Set<Integer> set = new TreeSet<>();
        //1.3）提示用户输入10个整数
        //1.4) 循环输入10个数，将输入的数添加到集合中
        for (int i = 0; i < 10; i++) {
            int a = sc.nextInt();
            //1.5) 添加到数组中
            set.add(a);
        }
        //1.6) 将TreeSet集合放入到List集合中
        List<Integer> list = new ArrayList<>(set);
        //1.7） 将集合进行逆序输出（方法一）
//        for (int i = list.size() - 1 ; i >= 0 ; i--) {
//            Integer integer = list.get(i);
//            System.out.print( integer + "\t") ;
//        }
        //1.7） 调用sort方法重写comparator方法（方法二,传统方法）
//        list.sort(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o2 - o1;
//            }
//        });
//        list.forEach(a-> System.out.print(a + "\t"));
        //1.7） 调用sort方法进行倒转然后直接遍历（方法三,）
//        list.sort(Comparator.reverseOrder());
//        list.forEach(a-> System.out.print(a + "\t"));
        //1.7） 调用sort方法重写comparator方法（方法三,传统方法简写）
        list.sort((o1,o2) -> o2 - o1);
        list.forEach(a-> System.out.print(a + "\t"));
    }

案例二：写一个程序向 List 集合类添加”a”,”abc”,”ab”,”ac”,”ab”,”b”,”b”,”b”,”b”,”ab”等字符串，找出集合中存在重复的字符串在控制台输出，不重复的不输出。（实现思想很重要）

分析一下需求：集合中的都是字符串，且重复，那么用ArrayList集合存储，拿到重复的输出，结合Set集合特点无序不重复，我们可以遍历原始集合拿到每个元素，将第一次出现的元素放到list1集合中，多次出现的集合放到set集合中，这样就拿到了重复的元素是什么

@Test
    public void testD(){
        //1.定义集合储存需要进行查重的字符串
        List<String> list = new ArrayList<>();
        //2.将字符串添加到集合里
        list.add("a");
        list.add("abc");
        list.add("ab");
        list.add("ac");
        list.add("ab");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("ab");
        //3.定义储存第一次出现的元素的集合，
        List<String> list1 = new ArrayList<>();
        //4.定义储存重复元素的set集合，set集合特点：无序且唯一，它会将重复元素覆盖掉，这就保证了集合中只有一个原集合的重复元素
        Set<String> set = new HashSet<>();
        //5.遍历list集合，拿到每一个元素，然后判断在list1中有没有包含，如果有，那么存储到set集合中，没有就存储到list1中
        for (int i = 0; i < list.size(); i++) {
            //6.判断list1集合是否存在此元素
            if (list1.contains(list.get(i))){
                //7.存在，那么存储到set集合中
                set.add(list.get(i));
            }else
                // 8.不存在，那么存储到list1集合中
                list1.add(list.get(i));
        }
        //9.遍历set集合拿到重复元素
       System.out.println("重复的元素如下：");
        for (String string : set) {
            System.out.print(string + "\t");
        }
        System.out.println("\n====================================================================");
    }

案例三：写一个方法排除掉List集合中的重复对象后输出。

这是案列二的衍生题，很显然，我们可以通过移除set集合中的重复元素，输出新的list集合即可

@Test
    public void testE(){
        //1.定义集合储存需要去重的元素
        List<String> list = new ArrayList<>();
        //2.将元素添加到集合中
        list.add("a");
        list.add("abc");
        list.add("ab");
        list.add("ac");
        list.add("ab");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("ab");
        //3.定义List1集合储存第一次出现的元素
        List<String> list1 = new ArrayList<>();
        //4.定义Set集合存储重复出现的元素
        Set<String> set = new HashSet<>();
        //5.遍历list集合，将第一次出现的元素放到list1中，将重复的元素放到set中
        for (int i = 0; i < list.size(); i++) {
            //5.1) 判断list1集合里是否已经存在此元素
            if (list1.contains(list.get(i))){
                //5.2) 有，那么放到set集合中
                set.add(list.get(i));
            }else
                //5.3） 否则放到list中
                list1.add(list.get(i));
        }
        //6. 在list集合中移除set小集合中的重复元素
        //6.1) 判断是否set为空
        if (set.size() == 0){
            //6.2) 如果为空，说明没有重复元素
            System.out.println("没有重复元素");
            list.forEach(a-> System.out.print(a + "\t"));
        }else {
            //6.3） 如果不为空，那么移除小集合，再打印
            list.removeAll(set);
            System.out.println("删除重复元素后的集合为：");
            list.forEach(a-> System.out.print(a + "\t"));
        }

    }

案例四：有以下字符串String str=“56.89.5.3.75.98.98.26.15.44”,请定义一个类，写个方法，实现对该字符串按照.号进行分隔，并将结果按照从大到小的顺序进行排列。

（上来我就分析一波）我们看到字符串的特点是点号分割的数字，那么，直接利用String类的分割方法spilt（“正则表达式\.”）分割出来的是一个String【】数组，将每个经过String转化为Integer类型元素储存到ArrayList集合中，然后排序请看案例一

 @Test
    public void testF(){
        //1. 定义字符串并初始化
        String str="56.89.5.3.75.98.98.26.15.44";
        //2. 将字符串按照.分割
        String[] split = str.split("\\.");
        //3. 定义一个list集合
        List<Integer> list = new ArrayList<>();
        //4. 遍历split数组拿到每个字符串转化为integer类型再添加到集合中
        for (int i = 0; i < split.length; i++) {
            //4.1) 字符串转化为integer类型
            Integer a = new Integer(split[i]);
            //4.2） 将其放到集合里
            list.add(a);

        }
        //5.排序集合子再打印（方法一：sort升序，倒遍历）
//        list.sort(null);
//        Collections.sort(list);
//        list.sort(Comparator.reverseOrder());
//        list.forEach(a-> System.out.print(a + "\t"));
        //6.方法二：重写comparator方法
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;     //降序
            }
        });
//        list.sort((o1, o2) -> o2 - o1);       (简写)
        list.forEach(a-> System.out.print(a + "\t"));

    }

案例五：编一段代码，实现在控制台输入一组数字后，排序后在控制台输出,输出end代表结束

分析一波需求：我们看到此处可以输入任何字符串，但是最终我们存储到集合中进行排序的只有integer类型，这样，我们就需要判断输入的值是end结束循环，是数字转化为integer类型才添加到集合中，判断是否是数字可以使用String.matches（“【0-9】+”），排序同案例一；

public static void testG(){
        //1. 定义扫描器对象
        Scanner sc = new Scanner(System.in);
        //2. 定义储存输入值的集合，重复有序用ArrayList
        List<Integer> list = new ArrayList<>();
        //3.提示用户输入一组数据
        System.out.println("请输入一组数：");
        //4.循环进行输入
        while (true){
            //4.1） 输入一个字符串
            String s = sc.next();
            //4.2）进行判断输入的是否为end
            if (s.equals("end")){
                //4.3) 如果是那么跳出当前循环
                break;
            }else {
                //4.4） 如果不是，那么判断是integer的值才添加到集合中
                if (s.matches("[0-9]+")){
                    //4.5) 如果是数字，那么转化为integer储存到集合中
                    list.add(new Integer(s));
                }
            }
        }
        //5. 对集合进行排序遍历
        list.sort(null);        //升序
        for (Integer integer : list) {
            System.out.print(integer + "\t");
        }
    }

案例六：从类似如下的文本文件中读取出所有的姓名，并打印出重复次数最多的姓名和重复的次数。（重点）

分析一下：我们获得的文本有姓名，性别，但是求的是重复出现的人名还有次数。两个条件输出。此时想到的集合应该是键值对集合HashMap。键值对集合特点是：键是唯一的，重复放到同一个键中会会出现新值覆盖旧值的情况。此时我们只要姓名作为键，出现的次数作为值，每此出现就会count++覆盖前面的值，实现次数累加的目的。再说说求最大值：我们利用Collections工具类的max方法求集合中value（）值的最大值，遍历集合，只要值相同就打印即可

 public void testH(){
        //1.1） 定义字符串数组
        String[] str = new String[]{"1,张三,28", "2,李四,35", "3,张三,28", "4,王五,35", "5,张三,28", "6,李四,35", "7,赵六,28", "8,田七,35", "9,李四,39"};
        //1.2) 定义一个HashMap键值对集合,键key = naem，value = count；
        Map<String, Integer> map = new HashMap<>();
        //1.3) 遍历字符串每个元素进行分割字符串
        for (int i = 0; i < str.length; i++) {
            //1.3.1) 分割每个字符串，
            String[] split = str[i].split(",");
            //1.3.2) 拿到第二个位置的姓名
            String name = split[1];
            //1.3.3) 拿到键的值
            Integer count = map.get(name);
            //1.3.3) 判断这个姓名是否在集合中出现过
            if (count == null){
                //1.3.4) 如果这个姓名这个键的值还是null说明还没有相同名字在集合里，那么就将其值改为1
                count = 1;
            }else {
                //1.3.5）如果值不为null，那么值++
                ++ count ;
            }
            //1.3.6） 将键值对储存到集合中
            map.put(name, count);
        }
        //1.4) 遍历集合
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            Integer value = entry.getValue();
            String key = entry.getKey();
            System.out.println(key + "\t" + value);
        }
        System.out.println("=======================================");
        //1.5） 判断次数最大值.调用集合工具类的max方法
        Integer max = Collections.max(map.values());
        //1.6) 遍历集合，判断value == max?等于就输出其键值
        for (Map.Entry<String, Integer> entry : entries) {
            if (entry.getValue() == max){
                System.out.println(entry.getKey() + "\t"+ max);
            }
        }

    }