集合架構的工具類。

Collections:集合架構的工具類。裡面定義的都是靜态方法。

Collections和Collection有什麼差別？

Collection是集合架構中的一個頂層接口，它裡面定義了單列集合的共性方法。

它有兩個常用的子接口:

List：對元素都有定義索引。有序的。可以重複元素。

Set：不可以重複元素。無序。

Collections是集合架構中的一個工具類。該類中的方法都是靜态的

提供的方法中有可以對list集合進行排序，二分查找等方法。

通常常用的集合都是線程不安全的。因為要提高效率。

如果多線程操作這些集合時，可以通過該工具類中的同步方法，将線程不安全的集合，轉換成安全的。

Collections常用方法

排序

static <T extends Comparable<? super T>> void
    sort(List<T> list)
根據元素的自然順序 對指定清單按升序進行排序 <T extends Comparable> 要排序的對象必須是Comparable的子類

static <T> void
    sort(List<T> list, Comparator<? super T> c)
根據指定比較器産生的順序對指定清單進行排序。   自定義比較器排序

最大值最小值

static <T extends Object & Comparable<? super T>> T
    max(Collection<? extends T> coll)
根據元素的自然順序，傳回給定 collection 的最大元素。

static <T> T
    max(Collection<? extends T> coll, Comparator<? super T> comp)
根據指定比較器産生的順序，傳回給定 collection 的最大元素。
最小值同理

二分法查找

static <T> int
    binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜尋法搜尋指定清單，以獲得指定對象。
如果搜尋鍵包含在清單中，則傳回搜尋鍵的索引；否則傳回 (-(插入點) - 1)。
插入點：即第一個大于此鍵的元素索引

static <T> int
    binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜尋法搜尋指定清單，自定義比較器，以獲得指定對象。

替換所有

static <T> void
    fill(List<? super T> list, T obj)
使用指定元素替換指定清單中的所有元素。

static <T> boolean
    replaceAll(List<T> list, T oldVal, T newVal)
使用另一個值替換清單中出現的所有某一指定值。

反轉

static void
    reverse(List<?> list)
反轉指定清單中元素的順序。

static <T> Comparator<T>
    reverseOrder()
傳回一個比較器，它強行逆轉實作了 Comparable 接口的對象 collection 的自然順序。

static <T> Comparator<T>
    reverseOrder(Comparator<T> cmp)
傳回一個比較器，它強行逆轉指定比較器的順序。

洗牌

static void
    shuffle(List<?> list)
使用預設随機源對指定清單進行置換。

static void
    shuffle(List<?> list, Random rnd)
使用指定的随機源對指定清單進行置換。

将集合轉換成線程安全的集合

static <T> Collection<T>
    synchronizedCollection(Collection<T> c)
傳回指定 collection 支援的同步（線程安全的）collection。

static <T> List<T>
    synchronizedList(List<T> list)
傳回指定清單支援的同步（線程安全的）清單。

static <K,V> Map<K,V>
    synchronizedMap(Map<K,V> m)
傳回由指定映射支援的同步（線程安全的）映射。

static <T> Set<T>
    synchronizedSet(Set<T> s)
傳回指定 set 支援的同步（線程安全的）set。

static <K,V> SortedMap<K,V>
    synchronizedSortedMap(SortedMap<K,V> m)
傳回指定有序映射支援的同步（線程安全的）有序映射。

static <T> SortedSet<T>
    synchronizedSortedSet(SortedSet<T> s)
傳回指定有序 set 支援的同步（線程安全的）有序 set。

public class CollectionsDemo {
    public static void main(String[] args) {
//        sort1();
//        sort2();
//        binarySearchDemo();
//        binarySearchDemo2();
//        fillDemo();
//        reverseOrderDemo();
        shuffleDemo();
    }

    public static void shuffleDemo(){
        ArrayList<String> al = new ArrayList<String>();
        al.add("a");
        al.add("b");
        al.add("c");
        al.add("d");
        al.add("e");

        System.out.println("原集合:"+al); // 原集合:[a, b, c, d, e]

        Collections.shuffle(al);
        System.out.println("洗牌後的集合:"+al);  //洗牌後的集合:[e, b, a, d, c]
    }

    public static void reverseOrderDemo(){

        // reverseOrder(Comparator<T> cmp) 強行逆轉自定義的比較器
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StringLengthComparator()));
        ts.add("abb");
        ts.add("azcc");
        ts.add("aeee");
        ts.add("bc");

        for(Iterator<String> it = ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }
         /*  azcc
            aeee
            abb
            bc*/
    }

    public static void reverseOrderDemo2(){

        // Collections.reverseOrder()強行逆轉實作了 Comparable 接口的對象 collection 的自然順序
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
        ts.add("abb");
        ts.add("azcc");
        ts.add("aeee");
        ts.add("bc");

        for(Iterator<String> it = ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }

    }

    public static void fillDemo(){
        ArrayList<String> al = new ArrayList<String>();

        al.add("aa");
        al.add("bbb");
        al.add("d");
        al.add("cccc");
        al.add("eee");
        al.add("eee");

        System.out.println("原集合："+al);  // 原集合：[aa, bbb, d, cccc, eee, eee]
        // Collections.fill(al,"sd");
        // System.out.println("替換後的："+al);  // 替換後的：[sd, sd, sd, sd, sd, sd]

        Collections.replaceAll(al,"eee","fff");
        System.out.println("替換後的："+al);   //替換後的：[aa, bbb, d, cccc, fff, fff]

    }

    public static void binarySearchDemo(){
        ArrayList<String> al = new ArrayList<String>();

        al.add("aa");
        al.add("bbb");
        al.add("d");
        al.add("cccc");
        al.add("eee");
        al.add("eee");

        Collections.sort(al);
        System.out.println("排序後："+al);  // 排序後：[aa, bbb, cccc, d, eee, eee]

        System.out.println(Collections.binarySearch(al,"eee"));  // 4
        System.out.println(Collections.binarySearch(al,"bbbb"));  //-3 -(插入點)-1
    }

    // 自定義比較器查找
    public static void binarySearchDemo2(){
        ArrayList<String> al = new ArrayList<String>();

        al.add("aa");
        al.add("bbb");
        al.add("d");
        al.add("cccc");
        al.add("eee");
        al.add("eee");

        Collections.sort(al,new StringLengthComparator());
        System.out.println("排序後："+al);  // 排序後：[d, aa, bbb, eee, eee, cccc]

        System.out.println(Collections.binarySearch(al,"bbb",new StringLengthComparator()));  // 2
        System.out.println(Collections.binarySearch(al,"bbbb",new StringLengthComparator()));  //-6 -(插入點)-1
    }

    public static void sort1() {
        ArrayList<String> al = new ArrayList<String>();

        al.add("aa");
        al.add("bbb");
        al.add("d");
        al.add("cccc");
        al.add("eee");
        al.add("eee");

        System.out.println("原集合："+al);  // 原集合：[aa, bbb, d, cccc, eee, eee]

        Collections.sort(al);

        System.out.println("排序後的集合"+al);  // 排序後的集合[aa, bbb, cccc, d, eee, eee]
        System.out.println("最大值："+Collections.max(al));  // 最大值：eee

    }

    public static void sort2() {
        ArrayList<String> al = new ArrayList<String>();

        al.add("aa");
        al.add("bbb");
        al.add("d");
        al.add("cccc");
        al.add("eee");
        al.add("eee");

        System.out.println("原集合："+al);  // 原集合：[aa, bbb, d, cccc, eee, eee]

        Collections.sort(al,new StringLengthComparator());

        System.out.println("排序後的集合"+al);  // 排序後的集合[d, aa, bbb, eee, eee, cccc]
        System.out.println("最大值："+Collections.max(al,new StringLengthComparator()));  // 最大值：eee


    }
}

// 自定義比較器,按照長度進行排序
class StringLengthComparator implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {

        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if(num == 0){
            return o1.compareTo(o2);
        }
        return num;
    }
}

Arrays

此類包含用來操作數組（比如排序和搜尋）的各種方法。此類還包含一個允許将數組作為清單來檢視的靜态工廠

Arrays常用方法

查找（支援各種類型）

static int
    binarySearch(byte[] a, byte key)
使用二分搜尋法來搜尋指定的 byte 型數組，以獲得指定的值。

static int
    binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
使用二分搜尋法來搜尋指定的 byte 型數組的範圍，以獲得指定的值。

static <T> int
    binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
使用二分搜尋法來搜尋指定數組的範圍，以獲得指定對象。 自定義比較器

static <T> int
    binarySearch(T[] a, T key, Comparator<? super T> c)
使用二分搜尋法來搜尋指定數組，以獲得指定對象。  自定義比較器

複制（支援各種類型）

static float[]
    copyOf(float[] original, int newLength)
複制指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。

static char[]
    copyOfRange(char[] original, int from, int to)
将指定數組的指定範圍複制到一個新數組。

比較是否相等（支援各種類型）

static boolean
    deepEquals(Object[] a1, Object[] a2)
如果兩個指定數組彼此是深層相等 的，則傳回 true。

static int
    deepHashCode(Object[] a)
基于指定數組的“深層内容”傳回哈希碼。

static String
    deepToString(Object[] a)
傳回指定數組“深層内容”的字元串表示形式。

static boolean
    equals(boolean[] a, boolean[] a2)
如果兩個指定的 boolean 型數組彼此相等，則傳回 true。

替換（支援各種類型）

static void
    fill(int[] a, int val)
将指定的 int 值配置設定給指定 int 型數組的每個元素。

排序

static void
    sort(int[] a)
對指定的 int 型數組按數字升序進行排序。

static void
    sort(int[] a, int fromIndex, int toIndex)
對指定 int 型數組的指定範圍按數字升序進行排序。

static <T> void
    sort(T[] a, Comparator<? super T> c)
根據指定比較器産生的順序對指定對象數組進行排序。 自定義比較器（進行降序）

static <T> void
    sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根據指定比較器産生的順序對指定對象數組的指定範圍進行排序。

數組以字元串形式輸出

static String
    toString(long[] a)
傳回指定數組内容的字元串表示形式。

數值轉集合

static <T> List<T>
    asList(T... a)
傳回一個受指定數組支援的固定大小的清單。(不支援增删)

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {

        /*
		如果數組中的元素都是對象。那麼變成集合時，數組中的元素就直接轉成集合中的元素。
		如果數組中的元素都是基本資料類型，那麼會将該數組作為集合中的元素存在。
		*/
        int[] arr = {2,3,5};

        // toString(arr)
        System.out.println(Arrays.toString(arr));  // [2, 3, 5]


        // 數組轉List
        //把數組變成list集合有什麼好處？
		/*
		可以使用集合的思想和方法來操作數組中的元素。

		注意：将數組變成集合，不可以使用集合的增删方法。
		因為數組的長度是固定。
		contains。
		get
		indexOf()
		subList();

		如果你增删。那麼會反生UnsupportedOperationException,

		*/
		String[] s ={"aaa","bbb","c"};

        List<String> list = Arrays.asList(s);
        System.out.println(list);  // [aaa, bbb, c]
        System.out.println(list.contains("ss"));  // false

        /*
		如果數組中的元素都是對象。那麼變成集合時，數組中的元素就直接轉成集合中的元素。
		如果數組中的元素都是基本資料類型，那麼會将該數組作為集合中的元素存在。
		*/

        //int[] nums = {2,4,5};  // 會是一個位址清單中有個位址
        Integer[] nums = {2,4,5};
        List<Integer> li = Arrays.asList(nums);
        System.out.println(li);  // [2, 4, 5]


    }
}

集合轉數組

Collection 類中的方法

 Object[]

toArray()

傳回包含此 collection 中所有元素的數組。

<T> T[]

toArray(T[] a)

傳回包含此 collection 中所有元素的數組；傳回數組的運作時類型與指定數組的運作時類型相同。

import java.util.ArrayList;
import java.util.Arrays;

public class toArrayDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

		/*
		1,指定類型的數組到底要定義多長呢？
		當指定類型的數組長度小于了集合的size，那麼該方法内部會建立一個新的數組。長度為集合的size。
		當指定類型的數組長度大于了集合的size，就不會新建立了數組。而是使用傳遞進來的數組。
		是以建立一個剛剛好的數組最優。


		2,為什麼要将集合變數組？
		為了限定對元素的操作。不需要進行增删了。

		*/

        String[] arr = al.toArray(new String[al.size()]);

        System.out.println(Arrays.toString(arr));

    }
}

1.5 新特性

進階for循環

格式：

for(資料類型變量名 : 被周遊的集合(Collection)或者數組)

{

}

對集合進行周遊。隻能擷取集合元素。但是不能對集合進行操作。

疊代器除了周遊，還可以進行remove集合中元素的動作。

如果是用ListIterator，還可以在周遊過程中對集合進行增删改查的動作。

傳統for和進階for有什麼差別呢？

進階for有一個局限性。必須有被周遊的目标。

建議在周遊數組的時候，還是希望是用傳統for。因為傳統for可以定義腳标。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class forDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        for(String s : al){
            System.out.println(s);
        }
        
        HashMap<Integer,String> map = new HashMap<Integer, String>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");

        //使用keySet進行周遊
        Set<Integer> keySet= map.keySet();
        for (Integer k : keySet){
            System.out.println(k+":"+map.get(k));
        }

        //使用entrySet進行周遊
        Set<Map.Entry<Integer,String>> entryKey = map.entrySet();
        for (Map.Entry<Integer,String > entry : entryKey){
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }

        // 簡化
        for(Map.Entry<Integer,String> entry : map.entrySet()){
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
    }
}

方法的可變參數。

import java.util.Arrays;

/*
JDK1.5版本出現的新特性。

方法的可變參數。
在使用時注意：可變參數一定要定義在參數清單最後面。
*/
public class ParamMethodDemo {
    public static void main(String[] args) {
        /*
		可變參數。
		其實就是上一種數組參數的簡寫形式。
		隻要将要操作的元素作為參數傳遞即可。
		隐式将這些參數封裝成了數組。
		*/
        show("hahaha",1,2,3);  // 可變參數一定要定義在參數清單最後面。

        int[] b = {1,33,6};
        show("hahaha",b);

    }

    public static void show(String s, int ... a){
        System.out.println(s);
        System.out.println(a); //[[email protected]
        System.out.println(Arrays.toString(a));
    }
}

靜态導入

/*
StaticImport  靜态導入。

當類名重名時，需要指定具體的包名。
當方法重名是，指定具備所屬的對象或者類。
*/
import java.util.Arrays;

import static java.util.Arrays.*; //導入的是Arrays這個類中的所有靜态成員。
import static java.lang.System.*; // 導入了System類中所有靜态成員。
public class StaticImport {
    public static void main(String[] args) {
        int[] arr = {1,2,3,5};
        sort(arr);
        int index = binarySearch(arr,5);
        out.println(index);  // 3

        // toString(); // 報錯，因為類中本來就有toString方法，引起沖突，是以需要寫上類名或對象名
        out.println(Arrays.toString(arr));  // [1, 2, 3, 5]
    }
}

工具類Collections和Arrays1.5 新特性