Collections工具类基本介绍和使用

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对象的所有旧值

Collections常用方法

package collection_.collectionP.collection_;

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

/**
 * @author: 海康
 * @version: 1.0
 */
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