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<String> el=Collections.emptyList();  
        System.out.println(el.isEmpty());  
  
        try  
        {  
            el.add("1");  //如果試圖改變它 那麼就會拋出UnsupportedOperationException異常  
        }catch(Exception e)  
        {  
            System.out.println("UnsupportedOperationException");  
        }  
          
        List<String> el1=null;  //通常我們可能習慣這樣定義一個list  
        try  
        {  
            el1.contains("abc");  //可能在某個地方我們不小心的這樣用了（假設這個存在於一個低概率發生的地方）  
        }catch(Exception e)  
        {  
            System.out.println("null異常");  
        }  
          
        List<String> singletonL=Collections.singletonList("abcd");  
        System.out.println(singletonL);  
          
        //通過下面的方式就能得到一個不可變化的（只讀）集合（視圖的感覺，官方其實也是這麼介紹的）  
        List<String> 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));

}

}