Collection和Collections的使用

Collection

Collection是集合框架的基础，它声明了所有集合都将拥有的核心方法。

所有实现Collection接口的类都必须提供两个标准的构造函数：
无参数的构造函数用于创建一个空的Collection，
一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。

public interface Collection<E> extends Iterable<E> {
    // 基本方法
    int size();
    boolean isEmpty();
    boolean contains(Object element);
    boolean add(E element);//可选,也就是不一定有实现
    boolean remove(Object element);//可选
    Iterator<E> iterator();
    // 批量操作
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c); //可选
    boolean removeAll(Collection<?> c);//可选
    boolean retainAll(Collection<?> c);//可选
    void clear();//可选
    // 数组操作
    Object[] toArray();
    <T> T[] toArray(T[] a);
}

遍历

//增强型for遍历,不可在遍历过程中删除元素
for (Object o : collection){
    System.out.println(o);
}
//迭代器遍历,可以遍历过程中删除
static void filter(Collection<?> c) {
    for (Iterator<?> it = c.iterator(); it.hasNext(); )
        if (!cond(it.next()))
            it.remove();
}

Collections,集合使用的工具类

排序

//初始化数据
        ArrayList<Double> list = new ArrayList<>();
        double array[] = {112, 111, 23, 456, 231 };
        for (int i = 0; i <array.length ; i++) {
            list.add(array[i]);
        }

        //默认升序
        Collections.sort(list);
        //自定义比较器,降序排序
        Collections.sort(list, new Comparator<Double>() {
            @Override
            public int compare(Double o1, Double o2) {
                if (o1 > o2)
                {
                    return 1;
                }
                else if (o1 < o2)
                {
                    return -1;
                }
                else
                {
                    return 0;
                }
            }
        });

混排,将排序打乱

        Collections.shuffle(list);

反转排序

        Collections.reverse(list);

将元素全部替换为

       Collections.fill(list,123.1);

复制

        //注意目标Collection大小要大于等于源Collection
        Collections.fill(list,123.1);
        ArrayList<Double> list2 = new ArrayList<>();
        list2.add(1.1);
        list2.add(1.1);
        list2.add(1.1);
        list2.add(1.1);
        list2.add(1.1);
        Collections.copy(list2,list);

获取集合中最小的元素

        Double min = Collections.min(list);

        //可自定义比较器
        Double min2 = Collections.min(list, new Comparator<Double>() {
            @Override
            public int compare(Double o1, Double o2) {
                return 0;
            }
        });

获取集合中最大的元素

//用法类似,也可以自定义比较器
Double max = Collections.max(list);

获取子集合在父集合最后一次出现的位置

        list3.add("你好啊");//0
        list3.add("很高兴见到你");//1
        list3.add("很高兴见到你");//2
        list3.add("很高兴见到你");//3
        list3.add("这个不行");
        list3.add("诶咻");
        list3.add("55555");
        ArrayList<String> list4 = new ArrayList<>();
        list4.add("很高兴见到你");
        list4.add("很高兴见到你");
        int i = Collections.lastIndexOfSubList(list3, list4);
        //i=2

获取子集合在父集合第一次出现的位置

Collections.indexOfSubList(list3,list4);

循环移位

        ArrayList<Integer> list5 = new ArrayList<>();
        list5.add(1);
        list5.add(2);
        list5.add(3);
        list5.add(4);
        list5.add(5);
        Logger.d(list5);//[1, 2, 3, 4, 5]
        //正数为右移,负数为左移
        Collections.rotate(list5,1);
        Logger.d(list5);//[5, 1, 2, 3, 4]