Collections工具类

Collections工具类

Collections工具类介绍

• collections是一个操作Set，List，Map等集合的工具类
• collections中提供了一系列静态的方法对集合元素进行排序，查询和修改等操作。

排序操作

• reverse（List），反转List中元素的顺序
• shuffle（list）：对List集合元素进行随机排序
• sort（List）：根据元素的自然顺序对指定的List集合元素按升序排序
• sort（List，Comparator）：根据指定的Comparator产生的顺序对list集合元素进行排序
• swap（List，int，int）：将指定List中的i出元素和j处元素进行交换

案例演示

reverse（List），反转List中元素的顺序
shuffle（list）：对List集合元素进行随机排序
sort（List）：根据元素的自然顺序对指定的List集合元素按升序排序
sort（List，Comparator）：根据指定的Comparator产生的顺序对list集合元素进行排序
swap（List，int，int）：将指定List中的i出元素和j处元素进行交换          

shuffle（list）：对List集合元素进行随机排序
sort（List）：根据元素的自然顺序对指定的List集合元素按升序排序
sort（List，Comparator）：根据指定的Comparator产生的顺序对list集合元素进行排序
swap（List，int，int）：将指定List中的i出元素和j处元素进行交换*/

package com.lyc._collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建arrayList
        ArrayList a1 = new ArrayList();

        a1.add("1");
        a1.add("23");
        a1.add("345");
        a1.add("46666");
        a1.add("1313131235");
        //反转List中元素的顺序
        Collections.reverse(a1);
        System.out.println(a1);
        //对list集合进行随机排序
        /*for (int i = 0; i < 5; i++) {
            Collections.shuffle(a1);
            System.out.println(a1);
        }*/
        //自然排序：根据元素的自然顺序(根据元素的开头字符的大小)对指定list集合元素按升序排列
        Collections.sort(a1);
        System.out.println(a1);
        //根据指定的comparator产生的顺序对list集合元素进行排序
        //比如我们希望对传入的元素长度进行比较，并进行排序
        //我们可以传入一个比较器
        Collections.sort(a1, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                 return ((String)o1).length()-((String)o2).length();
            }
        });
        System.out.println(a1);

        //将list中的指定位置元素进行换位
        Collections.swap(a1,0,4);
        System.out.println(a1);



    }

}

查找和替换操作

• Object max （collection）根据元素的自然顺序返回集合元素中最大的元素

• Object max （collection，comparator）根据comparator指定的顺序，返回给定集合中最大的元素

• int frequency（collection，object）返回指定集合中的指定元素出现的次数

• void copy（list a ，list b）将集合 a 中的元素拷贝到元素b 中（注意不能直接进行此操作，需要先将新的集合给与长度，a.size（））否则会有异常，

  • copy方法源码如下

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())//所以必须先给新集合一个长度，否则会报异常
            throw new IndexOutOfBoundsException("Source does not fit in dest");
    
        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }
    

• collections.replaceALL（List list，Object oldVal ，newVal）集合元素的替换

package com.lyc._collections;

import java.sql.Array;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");
        arrayList.add("lyc");
        arrayList.add("xiaowww");
        arrayList.add("ab");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("b");
        //根据元素的自然顺序返回集合元素中最大的元素
        System.out.println(Collections.max(arrayList));
        //根据comparator指定的顺序，返回给定集合中最大的元素
        Object maxobj = Collections.max(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length()-((String)o2).length();
            }
        });
        System.out.println(maxobj);
        //最小的同理
        System.out.println(Collections.min(arrayList));
        //长度最小的同理
        Object minobj = Collections.min(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length()-((String)o2).length();
            }
        });
        System.out.println(minobj);
        //返回指定集合中的指定元素出现的次数
        Object A1 = Collections.frequency(arrayList,"b");
        System.out.println("b出现的次数为 "+A1);
        //将集合 a 中的元素拷贝到元素b 中
        ArrayList b = new ArrayList();
        // 集合的复制
        for (int i = 0; i < arrayList.size(); i++) {
            b.add(" ");
        }
        Collections.copy(b,arrayList);
        System.out.println("拷贝到的集合内容为 " + b);
        //集合元素的替换 
        Collections.replaceAll(b,"xiaowww","yc");
        System.out.println(b);

    }
}