Java重修笔记 第四十九天 Collections 工具类

• Collections 工具类

1. public static void reverse(List<?> list)

        反转集合中元素的顺序

2. public static void shuffle(List<?> list)

        将集合里的元素顺序打乱

3. public static <T extends Comparable<? super T>> void sort(List<T> list)

        将集合自然排序，该 List 集合元素必须实现Comparable接口

4. public static <T> void sort(List<T> list, Comparator<? super T> c)

        根据自定义的比较器对 List 集合进行比较

5. public static void swap(List<?> list, int i, int j)

        对制定元素进行交换

6. public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

        根据自然排序返回该集合中的最大值，集合中的所有元素必须实现Comparable接口

7. public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

        根据比较器排序返回该集合中的最大值

8. public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

        根据自然排序返回该集合中的最小值，集合中的所有元素必须实现Comparable接口

9. public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

        根据比较器排序返回该集合中的最小值

10. public static int frequency(Collection<?> c, Object o)

        返回指定集合中，该元素出现的次数

11. public static <T> void copy(List<? super T> dest, List<? extends T> src)

        将 src 的内容拷贝到 dest 中

12. public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

        将目标 List 集合中，指定字符串替换为新字符串

public class collection02 {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        ArrayList arrayList1 = new ArrayList();

        arrayList1.add("tom");
        arrayList1.add("smith");
        arrayList1.add("king");
        arrayList1.add("milan");

        System.out.println("原集合 = " + arrayList1);

        // 数组翻转
        Collections.reverse(arrayList1);
        System.out.println("reverse数组翻转: " + arrayList1);

        // 随机排序
        Collections.shuffle(arrayList1);
        System.out.println("shuffle随机排序: " + arrayList1);

        // 自然排序
        Collections.sort(arrayList1);
        System.out.println("sort自然排序: " + arrayList1);

        // 比较器排序
        Collections.sort(arrayList1, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("sort比较器排序: " + arrayList1);

        // 交换元素
        Collections.swap(arrayList1,0,1);
        System.out.println("swap交换元素: " + arrayList1);

        // 根据自然排序取最大值
        System.out.println("max取自然排序最大值: " + Collections.max(arrayList1));

        // 根据比较器取最大值
        System.out.println("max取长度最大值: " + Collections.max(arrayList1, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                if (((String)o1).length() - ((String)o2).length() == 0) {
                    return ((String)o1).compareTo((String)o2);
                } else {
                    return ((String)o1).length() - ((String)o2).length();
                }

            }
        }));

        // 统计元素出现的次数
        System.out.println("frequency统计元素出现的次数: " + Collections.frequency(arrayList1,"tom"));

        // 拷贝集合
        ArrayList arrayList2 = new ArrayList();
        for (int i = 0; i < arrayList1.size(); i++) {
            arrayList2.add("");
        }
        Collections.copy(arrayList2,arrayList1);
        System.out.println("copy将后面的复制给前面的: " + arrayList2);

        // 替换
        Collections.replaceAll(arrayList1,"tom","汤姆");
        System.out.println("replaceAll将目标 List 集合中，指定字符串替换为新字符串: " + arrayList1);
    }
}

运行结果：