一、Collections概述

  Collections是针对集合进行操作的工具类,都是静态方法

【Collection和Collections的区别】

SRE实战 互联网时代守护先锋,助力企业售后服务体系运筹帷幄!一键直达领取阿里云限量特价优惠。

  Collection:是单列集合的顶层接口,有子接口List和Set。  

  Collections:是针对集合操作的工具类,有对集合进行排序和二分查找的方法

二、Collections的主要方法

  • public static <T> void sort(List<T> list):排序 默认情况下是自然顺序。
  • public static <T> int binarySearch(List<?> list,T key):二分查找,要保证集合是排好序后才能用
  • public static <T> T max(Collection<?> coll):最大值
  • public static void reverse(List<?> list):反转
  • public static void shuffle(List<?> list):随机置换
public class CollectionsDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);

        System.out.println("list:" + list);
        // public static <T> void sort(List<T> list):排序 默认情况下是自然顺序。
        Collections.sort(list);
        // System.out.println("list:" + list);//[10, 20, 30, 40, 50]

        // public static <T> int binarySearch(List<?> list,T key):二分查找
        // System.out.println("binarySearch:" + Collections.binarySearch(list, 30));

        // public static <T> T max(Collection<?> coll):最大值
        // System.out.println("max:" + Collections.max(list));

        // public static void reverse(List<?> list):反转
        // Collections.reverse(list);
        // System.out.println("list:" + list);

        //public static void shuffle(List<?> list):随机置换
        Collections.shuffle(list);
        System.out.println("list:" + list);
    }
}

  Collections可以针对ArrayList存储基本包装类的元素排序,存储自定义对象可不可以排序呢?

public class CollectionsDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        List<Student> list = new ArrayList<>();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("刘晓曲", 28);
        Student s4 = new Student("武鑫", 29);
        Student s5 = new Student("林青霞", 27);

        // 添加元素对象
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);

        // 排序
        // 自然排序,使用前必须保证Student类实现了Comparable接口
        // Collections.sort(list);
        // 比较器排序
        // 如果同时有自然排序和比较器排序,以比较器排序为主
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getAge() - s1.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        // 遍历集合
        for (Student s : list) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

三、综合案例

  模拟斗地主洗牌和发牌

/**
 * 分析:
 *         A:创建一个牌盒
 *         B:装牌
 *         C:洗牌
 *         D:发牌
 *         E:看牌
 */
public class PokerDemo {
    public static void main(String[] args) {
        // 创建一个牌盒
        ArrayList<String> list = new ArrayList<>();

        // 装牌
        // 定义一个花色数组
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 定义一个点数数组
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10",
                "J", "Q", "K", "A", "2"};

        // 装牌
        for (String color : colors) {
            for (String number : numbers) {
                list.add(color.concat(number));
            }
        }
        list.add("大王");
        list.add("小王");

        // 洗牌
        Collections.shuffle(list);

        // 发牌
        ArrayList<String> liuBei = new ArrayList<>();
        ArrayList<String> guanYu = new ArrayList<>();
        ArrayList<String> zhangFei = new ArrayList<>();
        ArrayList<String> diPai = new ArrayList<>();

        for (int x = 0; x < list.size(); x++) {
            if (x >= list.size() - 3) {
                diPai.add(list.get(x));
            } else if (x % 3 == 0) {
                liuBei.add(list.get(x));
            } else if (x % 3 == 1) {
                guanYu.add(list.get(x));
            } else if (x % 3 == 2) {
                zhangFei.add(list.get(x));
            }
        }

        // 看牌
        lookPoker("刘备", liuBei);
        lookPoker("关羽", guanYu);
        lookPoker("张飞", zhangFei);
        lookPoker("底牌", diPai);
    }

    public static void lookPoker(String name, ArrayList<String> list) {
        System.out.println(name + "的牌是:");
        for (String s : list) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

 JavaSE学习笔记(二十三)—— Collections工具类 随笔 第1张

  上面的代码并没有实现对牌进行排序的效果,所以还要进行优化。

  优化思路如下:

JavaSE学习笔记(二十三)—— Collections工具类 随笔 第2张

  1. 创建一个HashMap集合
  2. 创建一个ArrayList集合
  3. 创建花色数组和点数数组
  4. 从0开始往HashMap里面存储编号,并存储对应的牌,同时往ArrayList里面存储编号即可。
  5. 洗牌(洗的是编号)
  6. 发牌(发的也是编号,为了保证编号是排序的,就创建TreeSet集合接收)
  7. 看牌(遍历TreeSet集合,获取编号,到HashMap集合找对应的牌)
public class PokerDemo2 {
    public static void main(String[] args) {
        // 创建一个HashMap集合
        HashMap<Integer, String> map = new HashMap<>();

        // 创建一个ArrayList集合
        ArrayList<Integer> list = new ArrayList<>();

        // 创建花色数组和点数数组
        String[] colors = {"♠", "♥", "♣", "♦"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
                "K", "A", "2",};

        // 从0开始往HashMap里面存储编号,并存储对应的牌,同时往ArrayList里面存储编号即可。
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                String poker = color.concat(number);
                map.put(index, poker);
                list.add(index);
                index++;
            }
        }
        map.put(index, "小王");
        list.add(index);
        index++;
        map.put(index, "大王");
        list.add(index);

        // 洗牌(洗的是编号)
        Collections.shuffle(list);

        // 发牌(发的也是编号,为了保证编号是排序的,就创建TreeSet集合接收)
        TreeSet<Integer> liuBei = new TreeSet<>();
        TreeSet<Integer> guanYu = new TreeSet<>();
        TreeSet<Integer> zhangFei = new TreeSet<>();
        TreeSet<Integer> diPai = new TreeSet<>();

        for (int x = 0; x < list.size(); x++) {
            if (x >= list.size() - 3) {
                diPai.add(list.get(x));
            } else if (x % 3 == 0) {
                liuBei.add(list.get(x));
            } else if (x % 3 == 1) {
                guanYu.add(list.get(x));
            } else if (x % 3 == 2) {
                zhangFei.add(list.get(x));
            }
        }

        // 看牌(遍历TreeSet集合,获取编号,到HashMap集合找对应的牌)
        lookPoker("刘备", liuBei, map);
        lookPoker("关羽", guanYu, map);
        lookPoker("张飞", zhangFei, map);
        lookPoker("底牌", diPai, map);

    }

    // 写看牌的功能
    public static void lookPoker(String name, TreeSet<Integer> set, HashMap<Integer, String> map) {
        System.out.print(name + "的牌是:");
        for (Integer key : set) {
            String value = map.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

 JavaSE学习笔记(二十三)—— Collections工具类 随笔 第3张

 

扫码关注我们
微信号:SRE实战
拒绝背锅 运筹帷幄