Java集合源码剖析-工具类

一.Collections工具类

概述：
    1.Collections(注意不是Collection，而是Collections，多了一个s)
    2.它是一个集合工具类
    3.方法分类：常规操作（查找，最大，最小等）、排序、线程安全（同步）操作、不可变集合

package com.cxy.collection;  
  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.HashMap;  
import java.util.HashSet;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
import java.util.TreeSet;  
  
/** 
 * @author cxy 
 */  
public class CollectionsTest  
{  
    public static void main(String[] args)  
    {  
        List l=new ArrayList();  
        l.add(100);  
        l.add(-66);  
        l.add(0);  
        l.add(88);  
          
        System.out.println("list:"+l);  
          
        Collections.reverse(l);  
        System.out.println("反转后的list:"+l);  
          
        Collections.shuffle(l);  //随机排序，洗牌  
        System.out.println("乱序后的list:"+l);  
          
        Collections.swap(l, 1, 3);  
        System.out.println("互换序号是1，3元素后的list:"+l);  
          
        Collections.sort(l);  //这里是个自然排序，更多排序内容请参见本博客中的《JAVA应用 之 排序》  
        System.out.println("排序后的list:"+l);  
          
        Collections.binarySearch(l, 88); //二分查找，必须保证list处于有序状态，查询成功返回序号，查不到返回负数  
  
        System.out.println("list中最小的元素是："+Collections.min(l));  
        System.out.println("list中最大的元素是："+Collections.max(l));  
        //上面两个方法 是自然排序，当然您可以自己实现一个Comparator的实现类作为第二个参数，具体见《JAVA应用 之 排序》  
          
        l.add(88);  
        //88（第二个参数）在list（第一个参数）出现过多少次  
        System.out.println("88在list中出现了："+Collections.frequency(l, 88)+"次");  
          
        Collections.replaceAll(l, 88, 66); //将88用66去替代  
        System.out.println("替代后的list:"+l);  
          
        Collections.fill(l, 66); //使用66（第二个参数）替换list中的所有元素。  
        System.out.println("list所有元素都被替换成为66："+l);  
          
        //下面写法的意思是创建一个l这么大的l1，不这么写会报异常，因为copy的时候不会自动扩容  
        List l1=new ArrayList(Arrays.asList(new Object[l.size()]));  
        Collections.copy(l1, l);  
        System.out.println("拷贝l的l1："+l1);  
        System.out.println("l和l1是否相等？"+l.equals(l1));  
        System.out.println("l和l1是否是一个引用？"+ (l==l1));  
        l1=l;  
        System.out.println("l和l1是否相等？"+l.equals(l1));  
        System.out.println("l和l1是否是一个引用？"+ (l==l1));  
        l1=new ArrayList(l); //这个是一个浅拷贝，l和l1的引用虽然不同，但是l和l1内部的元素引用还是一样的  
        System.out.println("l和l1是否相等？"+l.equals(l1));  
        System.out.println("l和l1是否是一个引用？"+ (l==l1));  
        //上面的问题有些复杂 以后形成一个专题讲解  
          
        //创建一个类型安全的集合，下面的意思是这个集合只能是再添加Integer类型数据  
        l.add("abc");  //现在还没事~  
        try  
        {  
            Collections.checkedList(l, Integer.class).add("abc");  
        }catch(Exception e)  
        {  
            System.out.println("类型安全操作后，当你再试图添加非Integer类型数据时 发生了异常");  
        }  
        System.out.println("======================");  
          
        /* 注意常用的这些集合（HashSet、HashMap、ArrayList、TreeMap、TreeSet、LinkedList等）， 
         * 都不是线程安全的，如果您的程序是在多线程环境下 并且有可能会同时修改同一个集合，那么 
         * 您就需要使用Collections.synchronizedXxx 方法来保证线程安全 
         */  
        List sl=Collections.synchronizedList(new ArrayList());  
        Map sm=Collections.synchronizedMap(new HashMap());  
        Set ss=Collections.synchronizedSet(new HashSet());  
        Set sts=Collections.synchronizedSortedSet(new TreeSet());  
          
        /* 不可变集合（空集合、指定元素集合、不可变状态） 
         * 1.使用Collections.emptyXxx 方法来创建一个不可变化的空集合 
         * 2.空不可变集合的意义：不会因为赋值null那样带来不可预期的异常，个人理解就是初始化的最佳实践。 
         * 3.指定元素集合：返回一个只包含指定元素的集合,同时也是不可变化的集合 
         *   应用：创建一个不可变化的特殊对象集合，例如：管理员集合,这样这个管理员对象就可以拥有一些集合的方法了 
         *       例如：我判断一些这个用户对象是否是管理员（adminList.contains(user)） 
         * 4.不可变状态：获得这个集合的不可变试图（只读） 
         * 3.这里之用list举例，其他集合类似 
        */  
        List el=Collections.emptyList();  
        System.out.println(el.isEmpty());  
  
        try  
        {  
            el.add("1");  //如果试图改变它 那么就会抛出UnsupportedOperationException异常  
        }catch(Exception e)  
        {  
            System.out.println("UnsupportedOperationException");  
        }  
          
        List el1=null;  //通常我们可能习惯这样定义一个list  
        try  
        {  
            el1.contains("abc");  //可能在某个地方我们不小心的这样用了（假设这个存在于一个低概率发生的地方）  
        }catch(Exception e)  
        {  
            System.out.println("null异常");  
        }  
          
        List singletonL=Collections.singletonList("abcd");  
        System.out.println(singletonL);  
          
        //通过下面的方式就能得到一个不可变化的（只读）集合（视图的感觉，官方其实也是这么介绍的）  
        List listView=Collections.unmodifiableList(l);  
    }  
}  

二.Arrays工具类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
   1.给数组赋值：通过fill方法。
   2.对数组排序：通过sort方法,按升序。
   3.比较数组：通过equals方法比较数组中元素值是否相等。
   4.查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;

public class TestArrays {

public static void output(int[] array) {

if (array!=null) {

for (int i = 0; i < array.length; i++) {

System.out.print(array[i]+" ");

}

}

System.out.println();

}

public static void main(String[] args) {

int[] array = new int[5];

//填充数组

Arrays.fill(array, 5);

System.out.println("填充数组：Arrays.fill(array, 5)：");

TestArrays.output(array);

 

//将数组的第2和第3个元素赋值为8

Arrays.fill(array, 2, 4, 8);

System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");

TestArrays.output(array);

 

int[] array1 = {7,8,3,2,12,6,3,5,4};

//对数组的第2个到第6个进行排序进行排序

Arrays.sort(array1,2,7);

System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");

TestArrays.output(array1);

 

//对整个数组进行排序

Arrays.sort(array1);

System.out.println("对整个数组进行排序：Arrays.sort(array1)：");

TestArrays.output(array1);

 

//比较数组元素是否相等

System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));

int[] array2 = array1.clone();

System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"\n"+Arrays.equals(array1, array2));

 

//使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）

Arrays.sort(array1);

System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"\n"+Arrays.binarySearch(array1, 3));

//如果不存在就返回负数

System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："+"\n"+Arrays.binarySearch(array1, 9));

}

}