Collections工具类的使用

た入场券 2023-09-30 19:22 66阅读 0赞

Collections工具类
    该工具类提供了大量针对Collection/Map的操作，总体可分为四类，都为静态(staic)方法：
    
    1、排序操作（主要针对List接口相关）
    reverse(List list):反转指定List集合中元素的顺序
    shuffle(List list):对List中的元素进行随机排序(洗牌)
    sort(List list):对List里的元素根据自然升序排序
    sort(List list,Comparator c):自定义比较器进行排序
    swap(List list,int i,int j):将指定List集合中i 处元素和j 处元素进行交换
    rotate(List list,int distance):将所有元素向右移位指定长度，如果distance等于size那么结果不变
    
    2、查找和替换（主要针对Collection接口相关）
    binarySearch(List list,Object key):使用二分法查找，以获得指定对象在List中的索引，前提是集合已经排序
    max(Collection coll):返回最大元素
    max(Collection coll,Comparator comp):根据自定义比较器，返回最大元素
    min(Collection] coll):返回最小元素
    min(Collection coll,Comparator comp):根据自定义比较器，返回最小元素
    fill(List list,Object obj):使用指定对象填充
    frequency(Collection Object obj):返回指定集合中指定对象出现的次数
    replaceAll(List list,Object old,Object new):替换
    
    
    3、同步控制
    Collections工具类提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时
    线程的安全问题。HashSet、ArrayList、HashMap都是线程不安全的，如果需要考虑同步，则使用这些方法。
    这些方法主要有：synchronizedSet、synchronizedSortedSet、
    synchronizedList、synchronizedMap、synchronizedSortedMap
    特别需要注意：在使用迭代方法遍历集合时需要手工同步返回的集合。{
        否则会有线程安全的问题}
    
    4、设置不可变得结合
    Collections工具类有三种方法返回一个不可变集合
    emptyXxx():        返回一个空的不可变的集合对象
    singletonXxx():    返回一个只包含指定对象的，不可变的集合对象
    unmodifiableXxx(): 返回指定集合对象的不可变视图
    
    5、其它
    disjoint(Collections<?>c1,Collections<?>c2) 如果两个指定collection中没有相同的元素，则返回true
    addAll(Collection<?super T>c,T...a) 一种方便的方式，将所有指定元素添加到指定collection中
    Comparator<T>reverseOrder(Comparator<T>cmp)返回一个比较器，它强行反转指定比较器的顺序。如果指定比较器为null，则
    此方法等同于reverseOrder(){
        返回一个比较器，它对实现 Comparable接口的对象集合施加了 自然排序的相反}

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class CollectionsDemo {
        
    
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("jack");
            list.add("tom");
            list.add("lily");
            
            //1、排序方法
    //      Collections.reverse(list);   //结果是：lily、jack、tom;
    //      Collections.shuffle(list);   //结果是：随机排序的
    //      Collections.sort(list);      //结果是：自然排序：jack、lily、tom
    //      Collections.sort(list,c);    //结果是：按照指定的比较器排序Comparator c
    //      Collections.swap(list, 0, 2);//结果是：lily、tom、jack  {都是对原list的操作}
    //      Collections.rotate(list, 1); //结果是：lily、jack、tom  {是将lsit的每个元素右移一位}
            
            //2、查找和替换方法
    //      System.out.println(Collections.binarySearch(list, "tom")); //结果是：1
    //      System.out.println(Collections.max(list)); //结果是：tom
    //      System.out.println(Collections.min(list)); //结果是：jack
    //      Collections.fill(list, "jerry"); //结果是：jerry, jerry, jerry
    //      System.out.println(Collections.frequency(list, "lily"));
    //      Collections.replaceAll(list, "lily","bin");
            
            //3、同步控制
    //      List<String> syncList = Collections.synchronizedList(new ArrayList<String>()); //相当于是把new ArrayList<String>()这个list包装了下，编程可同步的新的list
    //      Collections.synchronizedCollection(c)
    //      Collections.synchronizedMap(m)
    //      Collections.synchronizedSortedMap(m)
    //      Collections.synchronizedSet(s)
    //      Collections.synchronizedSortedSet(s)
            
            System.out.println(list);
            
            //4、设置不可变得集合
            List<String> emList = Collections.emptyList();
            //emList.add("lily"); //空list是不能添加元素的返回错误：UnsupportedOperationException
            
            //5、其它
            Collections.sort(list,Collections.reverseOrder()); //先对list进行sort自然排序jack, lily, tom，然后强行反转结果：tom, lily, jack
            System.out.println(list);
            
        }
         
        /**
        Collections.emptyList()的使用技巧：
        List<String> li = query();
        这里接收到query()时就不会报错，不会报空指针；因为为空时返回：Collections.emptyList();是有长度的，只不过是为0
        */
        public static List<String> query(){
        
            List<String> list = null;
            //...
            return Collections.emptyList();
        }
    }

--------------------

##### `Collections`工具类 #####

**基本介绍：**

1.  `Collections` 是一个操作`Set` `List` 和 `Map`等集合的工具类
2.  `Collections` 中提供一系静态的方法对集合元素进行排序 ， 查询和修改等操作

**常用方法【均为`static`方法】**

排序操作
    1.		reverse(List)：反转List中元素的顺序
    2.		shuffle(List)：对List集合元素进行随机排序
    3.		sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
    4.		sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
    
    替换 和 查找操作
    5.		swap(List, int ,int )：将指定List集合中的 i 处元素 和 j 处元素进行交换
    6.		Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    7.      Object max(Collection, Comparator)：根据Comparator指定的顺序，返回给集合中的最大元素
    8.		Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
    9.		Object min(Collection, Comparator)：根据Comparator指定的顺序，返回给集合中的最大元素
    10.		int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
    11.		void copy(List dest,List src)：将src中的内容复制到dest中
            注意复制的目标集合的长度必须大于源集合，否则会抛出空指针异常
        
    12.     boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LjSVJSZ4-1647575644942)(E:\\Typora笔记\\java笔记\\img\\image-20220223110421145.png)\]][img-LjSVJSZ4-1647575644942_E_Typora_java_img_image-20220223110421145.png]

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JWgDcpmC-1647575644943)(E:\\Typora笔记\\java笔记\\img\\image-20220223110500106.png)\]][img-JWgDcpmC-1647575644943_E_Typora_java_img_image-20220223110500106.png]

**`Collections`常用方法**

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    
    public class Collection01 {
        
        public static void main(String[] args) {
        
            ArrayList list = new ArrayList();
            list.add("湛江");
            list.add("海康");
            list.add("南宁");
            list.add("广州");
            list.add("佛山");
            // reverse(List) 反转中元素的顺序 就是将原来的顺序反转
            Collections.reverse(list);
            System.out.println(list);
    
            // shuffle(list) 对List集合元素进行随机排序
            Collections.shuffle(list);
            System.out.println(list);
    
            // sort 根据元素的自然顺序对指定List集合元素按升序排序
            System.out.println("自然顺序排序");
            Collections.sort(list);
            // sort(list , Comparator) 根据指定的Comparator 产生的顺序对List集合元素进行排序
            System.out.println("Comparator制定排序");
            Collections.sort(list, new Comparator<Object>() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    String str1 = (String) o1;
                    String str2 = (String) o2;
                    return str1.compareTo(str2);
                }
            });
            System.out.println(list);
    
            // swap(List,int ,int) 将指定List集合中 i 处元素  和  j 处元素进行交换
            Collections.swap(list,0,2);
            System.out.println("交换后的位置="+list);
    
            //Object max(Collection) 根据元素的自然顺序，返回给定集合中最大元素
            Comparable max = Collections.max(list);
            System.out.println("自然排序后的最大值max="+max);
            // Object max(Collection,Comparator) 根据Comparator指定的顺序返回给定集合中的最大元素
            Object max1 = Collections.max(list, new Comparator<Object>() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    return ((String) o1).compareTo((String) o2);
                }
            });
            System.out.println("指定排序规则的最大值="+max1);
    
            // Object min(Collection) 根据元素的自然排序，返回给定集合的最小值
            // Object min(Collection , Comparator) 根据Comparator指定的顺序返回给定集合中的最小值
    
            // int frequency(Collection ,Object) 返回指定集合中指定元素的出现次数
            // Collection：集合  Object 该元素出现次数
            int tom = Collections.frequency(list, "tom");
            System.out.println("tom出现的次数="+tom);
    
            // copy(List dest ,List src)：将src中的内容复制到dest中【】
            ArrayList dest = new ArrayList();
            for (int i = 0; i < list.size(); i++) {
        
                dest.add(i);
            }
            Collections.copy(dest,list);
            //注意复制的目标集合的长度必须大于源集合，否则会抛出空指针异常
            System.out.println("复制后的集合="+dest);
            /**   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");
             *
             *        如果源集合的长度小于10或源集合和目标集合类型是RandomAccess，则执行if块代码，否则执行else代码
             *         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());
             *             }
             *         }
             *     }
             */
            
            // boolean replaceAll(List list,Object oldVal ,Object newVal)：使用新值替换List对象的所有旧值
            Collections.replaceAll(list,"tom","汤姆");//将tom 替换成 汤姆
            System.out.println(list);
        }
    }

`Collections`集合中的`cpoy`方法源码剖析

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");
    
        COPY_THRESHOLD【10】或源集合和目标集合是RandomAccess类型，则执行if代码块，否则执行else代码块
        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());
            }
        }
    }

##### 总结-开发中如何选择集合实现类【记住】 #####

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：

**1.先判断存储的类型【一组对象【单列】或一组键值对象【双列】】**

###### 一组对象【单列】：`collection`接口 ######

**允许重复：**`List`

增加删除多：`LinkedList`【底层是维护一个双向链表)】

修改查询多：`ArrayList`【底层是维护`Object`类型的可变数组】

**不允许重复：**`Set`

无序：`HashSet`【底层是`HashMap`，维护一个哈希表即（数组+链表+红黑树）】

排序：`TreeSet`【底层是`TreeMap`】

插入和取出顺序一致：`LinkedHashSet`【底层数组+双向链表`LinkedHashSet`的底层是`LinkedHashMap`，`LinkedHashMap`的是底层是`HashMap`】

###### 一组键值对象【双列】：`Map` ######

键无序：`HashMap`【底层是：哈希表 在`jdk7`：数组+链表 在`jdk8`：数组+链表+红黑树】

键排序：`TreeMap`

键插入和取出顺序一致：`LinkedHashMap`【底层是`HashMap`】

读取文件：`Properties`

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yn6CeV8L-1647575644944)(E:\\Typora笔记\\java笔记\\img\\image-20220222175510975.png)\]][img-Yn6CeV8L-1647575644944_E_Typora_java_img_image-20220222175510975.png]

[img-LjSVJSZ4-1647575644942_E_Typora_java_img_image-20220223110421145.png]: https://img-blog.csdnimg.cn/e22141955058420f82f6241b3eff2fde.png
[img-JWgDcpmC-1647575644943_E_Typora_java_img_image-20220223110500106.png]: https://img-blog.csdnimg.cn/89c9da774da74727a5459fb4b7824f86.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5pix5pmfMTY4,size_20,color_FFFFFF,t_70,g_se,x_16
[img-Yn6CeV8L-1647575644944_E_Typora_java_img_image-20220222175510975.png]: https://img-blog.csdnimg.cn/a7d0b956c23e411183f8247b259c5c96.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5pix5pmfMTY4,size_20,color_FFFFFF,t_70,g_se,x_16