java的集合工具類Collections

集合框架的工具類。

          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); //[I@4554617c

        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]

    }

}

————————————————

原文連接：https://blog.csdn.net/qq_37482956/article/details/100577776