Collections

最新推荐文章于 2024-10-12 22:35:37 发布

VirtualBool

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量436

点赞数 6

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/m0_73603082/article/details/141996182

版权

java学习专栏收录该内容

31 篇文章 0 订阅

订阅专栏

Collections 是 Java 中的一个实用工具类，提供了一系列静态方法来操作集合。以下是其详细介绍：
前置知识

在 Java 中，可变参数（Varargs）允许方法接受可变数量的参数。使用可变参数时，可以传递任意数量的参数给方法，包括不传递参数。

语法

使用省略号 ... 来定义可变参数：

方法可以接受不同数量的参数调用。

可变参数在方法内部被视为数组。

可变参数必须是方法的最后一个参数。
一个方法只能有一个可变参数。

public class test {
    public static void main(String[] args) {

        System.out.println(add(11, 1, 2, 3, 4, 5, 6));//21
        System.out.println(add(1));//0

    }
    public static int add (int age, int... num){

        int sum = 0;
        for (int i = 0; i < num.length; i++) {
            sum += num[i];
        }
        return sum;
    }
}

添加操作

addAll( Comparator<? super T> c,ele1,ele2...) 批量添加元素

排序操作
sort(List<T> list)：对列表进行升序排序。

sort(List<T> list, Comparator<? super T> c)：使用指定的比较器进行排序。

查找和最大最小值
binarySearch(List<? extends Comparable<? super T>> list, T key)：在有序（升序）列表中进行二分查找。查找到返回下标，未查找到返回-1。
查找相同元素时，返回的索引可能是任何一个相同元素的索引

max(Collection<? extends T> coll)：返回集合中的最大元素。

min(Collection<? extends T> coll)：返回集合中的最小元素。

修改操作

reverse(List<?> list)：反转列表中元素的顺序。

shuffle(List<?> list)：随机打乱列表中的元素。

fill(List<? super T> list, T obj)：用指定元素替换列表中的所有元素。
copy(List<? super T> dest, List<? extends T> src)：将源列表中的所有元素复制到目标列表中。src复制到dest,且两列表大小相同。

swap(List<?> list, int i, int j)：交换列表中两个指定位置的元素。

其他实用方法
frequency(Collection<?> c, Object o)：返回元素在集合中出现的次数。

disjoint(Collection<?> c1, Collection<?> c2)：判断两个集合是否没有交集。有交集返回false,无交集返回true

public class test {
    public static void main(String[] args) {

        List<Integer> c = new ArrayList<>();
        Collections.addAll(c, 12, 13, 24, 5, 3);
        System.out.println(c);//[12, 13, 24, 5, 3]

        Collections.sort(c, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(c);//[3, 5, 12, 13, 24]

        System.out.println(Collections.binarySearch(c, 5));//1

        System.out.println(Collections.min(c));//3
        System.out.println(Collections.max(c));//24

        Collections.reverse(c);
        System.out.println(c);//[24, 13, 12, 5, 3]

        List<Integer> a = new ArrayList<>(Arrays.asList(0,0,0,0,0));

        Collections.copy(a, c);
        System.out.println(a);//[24, 13, 12, 5, 3]

        Collections.swap(c,0,4);
        System.out.println(c);//[3, 13, 12, 5, 24]



        System.out.println(Collections.frequency(c,5));//1
        System.out.println(Collections.frequency(c,0));//0

        System.out.println(Collections.disjoint(a, c));//false

        Collections.shuffle(c);
        System.out.println(c);//

        Collections.fill(c,4);
        System.out.println(c);//[4, 4, 4, 4, 4]

        System.out.println(Collections.disjoint(a, c));//true

    }
}