天天看點
傳回

【Java】集合系列18（Arrays和Collections工具類）

    • 1、Arrays類
        • 1.1Arrays常用方法執行個體
          • asList
          • sort排序和parallelSort并行排序
          • binarySearch
          • copyOf
          • deepEquals深度比較、deepHashCode生成hashcode、deepToString深度列印
          • equals比較
          • fill
          • toString
          • toStream
          • parallelPrefix
    • 2、Collections類
        • Collections的常用方法
          • 排序（Sort）
          • 混排（Shuffling）
          • 反轉（Reverse）
          • 替換所有的元素（Fill）
          • 拷貝（Copy）
          • 傳回Collections中最小元素（min）
          • 傳回Collections中最大元素（max）
          • lastIndexOfSubList
          • IndexOfSubList
          • Rotate

1、Arrays類

Arrays類常用方法概述：

本類所有方法都是靜态的，本類方法是針對數組的操作。

//部分Arrays的靜态方法（JDK1.8）
static <T> List<T> asList(T... a) 
傳回由指定數組支援的固定大小的清單。 

static int binarySearch(byte[] a, byte key) 
使用二進制搜尋算法搜尋指定值的指定位元組數組。  

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

static int[] copyOfRange(int[] 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(int[] a, int[] a2) 
如果兩個指定的int數組彼此 相等 ，則傳回 true 。  

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

static int hashCode(int[] a) 
根據指定數組的内容傳回哈希碼。  

static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) 
對于數組的給定子範圍執行 parallelPrefix(int[], IntBinaryOperator) 。  

static void parallelSetAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函數來并行設定指定數組的所有元素來計算每個元素。  

static void parallelSort(int[] a) 
按照數字順序排列指定的數組。  

static void setAll(int[] array, IntUnaryOperator generator) 
使用提供的生成函數來計算每個元素，設定指定數組的所有元素。  

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

static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) 
傳回Spliterator.OfInt覆寫指定數組的指定範圍内。  

static IntStream stream(int[] array) 
傳回順序IntStream與指定的數組作為源。  

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

1.1Arrays常用方法執行個體

asList

這個方法可以把數組轉換成List,List提供了很多的操作方法，更便于使用。

String[] array = new String[]{"a","c","2","1","b"};
        Integer[] ints = new Integer[]{5,1,4,3,2};
        List<String> lists = Arrays.asList(array);
        List<Integer> lints = Arrays.asList(ints);
        System.out.println(lists);
        System.out.println(lints);

運作結果：

[a, c, , , b]
[, , , , ]
sort排序和parallelSort并行排序

sort比較常用了，根據元素按照自然排序規則排序，也可以設定排序元素的起始位置。

Arrays.sort(array);
        for(String str : array){
            System.out.print(str);
        }
        Arrays.sort(array,,);
        System.out.println(Arrays.deepToString(array));

運作結果：

12abc
[1, 2, a, b, c]

parallelSort則采用并行的排序算法排序.但是我自己測試，可能資料量太小，速度上并沒有明顯的變化。

binarySearch

查找目标元素所在的位置，注意需要先進行排序。

//binarySearch需要保證是排好序的
        System.out.println(Arrays.binarySearch(array,"c"));//-6
        Arrays.sort(array);
        System.out.println(Arrays.binarySearch(array,"c"));//4
copyOf

拷貝數組，第一種用法，如果目标長度不夠，會使用0進行補位。第二種用法，支援拷貝目标起始位置到結束為止的數組。

//如果位數不夠，需要補位
        Integer[] result = Arrays.copyOf(ints,);
        for(int i=;i<result.length;i++){
            System.out.print(result[i]+" ");
        }
        System.out.println();
        //如果位數夠，就取最小的數組
        result = Arrays.copyOf(ints,);
        for(int i : result){
            System.out.print(i+" ");
        }
        System.out.println();
        result = Arrays.copyOfRange(ints,,);
        for(int i : result){
            System.out.print(i+" ");
        }

運作結果：

deepEquals深度比較、deepHashCode生成hashcode、deepToString深度列印

這幾個方法基本都是采用遞歸的寫法使用。

String[] array2 = new String[]{"a","c","2","1","b"};
System.out.println(Arrays.deepEquals(array,array2));//深度比較兩個數組是否相同
System.out.println(Arrays.deepHashCode(array));
System.out.println(Arrays.deepHashCode(array2));//如果兩個數組deepEquals，那麼他們的hashcode一定相同

//格式化輸出數組
System.out.println(Arrays.deepToString(array));

運作結果：

true


[a, c, , , b]
equals比較

對比兩個數組是否相等。

String[] array2 = new String[]{"a","c","2","1","b"};

        //1 對比引用是否相同
        //2 對比是否存在null
        //3 對比長度是否相同
        //4 挨個元素對比
        System.out.println(Arrays.equals(array,array2));//true
fill

基于目标元素填充數組

Arrays.fill(array,"test");
        System.out.println(Arrays.deepToString(array));//[test, test, test, test, test]
toString

列印數組元素

toStream

把數組轉換成stream,然後可以使用java8的stream特性了。

parallelPrefix

這個有點像spark的reduceByKey，即根據傳入的方法一次計算：

Arrays.parallelPrefix(ints,(x,y)->(x+y));
 System.out.println(Arrays.deepToString(ints));//[5, 6, 10, 13, 15]

2、Collections類

Collections常用方法概述：

本類所有方法都是靜态的，本類方法都是針對集合的操作。

//部分Collections的靜态方法（JDK1.8）
static <T> boolean addAll(Collection<? super T> c, T... elements) 
将所有指定的元素添加到指定的集合。  

static <T> Queue<T> asLifoQueue(Deque<T> deque) 
傳回Deque作為先進先出（ Lifo ） Queue的視圖 。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
使用二叉搜尋算法搜尋指定對象的指定清單。  

static <E> Collection<E> checkedCollection(Collection<E> c, 類<E> type) 
傳回指定集合的動态類型安全視圖。  

static <E> List<E> checkedList(List<E> list, 類<E> type) 
傳回指定清單的動态類型安全視圖。  

static <K,V> Map<K,V> checkedMap(Map<K,V> m, 類<K> keyType, 類<V> valueType) 
傳回指定地圖的動态類型安全視圖。 

static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m,
 類<K> keyType, 類<V> valueType) 
傳回指定可導航地圖的動态類型安全視圖。  

static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 類<E> type) 
傳回指定的可導航集的動态類型安全視圖。 

static <E> Queue<E> checkedQueue(Queue<E> queue, 類<E> type) 
傳回指定隊列的動态類型安全視圖。  

static <E> Set<E> checkedSet(Set<E> s, 類<E> type) 
傳回指定集合的動态類型安全視圖。  

static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 類<K> keyType, 類<V> valueType) 
傳回指定排序映射的動态類型安全視圖。 

static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 類<E> type) 
傳回指定排序集的動态類型安全視圖。  

static <T> void copy(List<? super T> dest, List<? extends T> src) 
将所有元素從一個清單複制到另一個清單中。  

static boolean disjoint(Collection<?> c1, Collection<?> c2) 
如果兩個指定的集合沒有共同的元素，則傳回 true 。

static <T> Enumeration<T> emptyEnumeration() 
傳回沒有元素的枚舉。  

static <T> Iterator<T> emptyIterator() 
傳回沒有元素的疊代器。  

static <T> List<T> emptyList() 
傳回空清單（immutable）。

static <T> ListIterator<T> emptyListIterator() 
傳回沒有元素的清單疊代器。  

static <K,V> Map<K,V> emptyMap() 
傳回空的地圖（不可變）。  

static <K,V> NavigableMap<K,V> emptyNavigableMap() 
傳回空導航地圖（不可變）。

static <E> NavigableSet<E> emptyNavigableSet() 
傳回一個空導航集（immutable）。 

static <T> Set<T> emptySet() 
傳回一個空集（immutable）。

static <K,V> SortedMap<K,V> emptySortedMap() 
傳回空的排序映射（immutable）。

static <E> SortedSet<E> emptySortedSet() 
傳回一個空的排序集（immutable）。 

static <T> Enumeration<T> enumeration(Collection<T> c) 
傳回指定集合的枚舉。  

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

static int frequency(Collection<?> c, Object o) 
傳回指定集合中與指定對象相等的元素數。 

static int indexOfSubList(List<?> source, List<?> target) 
傳回指定源清單中指定目标清單的第一次出現的起始位置，如果沒有此類事件，則傳回-1。 

static int lastIndexOfSubList(List<?> source, List<?> target) 
傳回指定源清單中指定目标清單的最後一次出現的起始位置，如果沒有此類事件則傳回-1。 

static <T> ArrayList<T> list(Enumeration<T> e) 
傳回一個數組清單，其中包含由枚舉傳回的順序由指定的枚舉傳回的元素。 

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

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
根據指定的比較器引發的順序傳回給定集合的最大元素。 

static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll) 
根據其元素的 自然順序傳回給定集合的最小元素。  

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
根據指定的比較器引發的順序傳回給定集合的最小元素。  

static <T> List<T> nCopies(int n, T o) 
傳回由指定對象的 n副本組成的不可變清單。  

static <E> Set<E> newSetFromMap(Map<E,Boolean> map) 
傳回由指定地圖支援的集合。  

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

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

static <T> Comparator<T> reverseOrder() 
傳回一個比較器，它對實作 Comparable接口的對象集合施加了 自然排序的相反。  

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
傳回一個比較器，它強制指定比較器的反向排序。  

static void rotate(List<?> list, int distance) 
将指定清單中的元素旋轉指定的距離。  

static void shuffle(List<?> list) 
使用預設的随機源随機排列指定的清單。

static void shuffle(List<?> list, Random rnd) 
使用指定的随機源随機排列指定的清單。  

static <T> Set<T> singleton(T o) 
傳回一個隻包含指定對象的不可變集。 

static <T> List<T> singletonList(T o) 
傳回一個隻包含指定對象的不可變清單。 

static <K,V> Map<K,V> singletonMap(K key, V value) 
傳回一個不可變的地圖，隻将指定的鍵映射到指定的值。 

static <T extends Comparable<? super T>>
void sort(List<T> list) 
根據其元素的natural ordering對指定的清單進行排序。  

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

static void swap(List<?> list, int i, int j) 
交換指定清單中指定位置的元素。  

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

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

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

static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 
傳回由指定的可導航地圖支援的同步（線程安全）可導航地圖。 

static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 
傳回由指定的可導航集支援的同步（線程安全）可導航集。 

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

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

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

static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 
傳回指定集合的不可修改視圖。  

static <T> List<T> unmodifiableList(List<? extends T> list) 
傳回指定清單的不可修改視圖。

static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) 
傳回指定地圖的不可修改視圖。  

static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) 
傳回指定可導航地圖的不可修改視圖。

static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) 
傳回指定的可導航集合的不可修改的視圖。

static <T> Set<T> unmodifiableSet(Set<? extends T> s) 
傳回指定集合的不可修改視圖。  

static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) 
傳回指定排序映射的不可修改視圖。 

static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 
傳回指定排序集的不可修改視圖。

Collections的常用方法

排序（Sort）

使用sort方法可以根據元素的自然順序 對指定清單按升序進行排序。清單中的所有元素都必須實作 Comparable 接口。此清單内的所有元素都必須是使用指定比較器可互相比較的

double array[] = {, , , ,  };
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = ; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：112,111,23,456,231
混排（Shuffling）

混排算法所做的正好與 sort 相反： 它打亂在一個 List 中可能有的任何排列的蹤迹。也就是說，基于随機源的輸入重排該 List，這樣的排列具有相同的可能性（假設随機源是公正的）。這個算法在實作一個碰運氣的遊戲中是非常有用的。例如，它可被用來混排代表一副牌的 Card 對象的一個 List .另外，在生成測試案例時，它也是十分有用的。

Collections.Shuffling(list)
double array[] = {, , , ,  };
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = ; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：112,111,23,456,231
反轉（Reverse）

使用Reverse方法可以根據元素的自然順序 對指定清單按降序進行排序。

Collections.reverse(list)
double array[] = {, , , ,  };
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = ; i < array.length; i++) {
System.out.println(li.get(i));
}
//結果：231,456,23,111,112
替換所有的元素（Fill）

使用指定元素替換指定清單中的所有元素。

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=;j
li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = ; i < li.size(); i++) {
System.out.println("list[" + i + "]=" + li.get(i));

}
//結果：aaa,aaa,aaa,aaa,aaa
拷貝（Copy）

用兩個參數，一個目标 List 和一個源 List， 将源的元素拷貝到目标，并覆寫它的内容。目标 List 至少與源一樣長。如果它更長，則在目标 List 中的剩餘元素不受影響。

Collections.copy（list，li）： 後面一個參數是目标清單 ，前一個是源清單
double array[] = {, , , ,  };
List list = new ArrayList();
List li = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {,};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=;j
li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = ; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：1131,333,23,456,231
傳回Collections中最小元素（min）

根據指定比較器産生的順序，傳回給定 collection 的最小元素。collection 中的所有元素都必須是通過指定比較器可互相比較的

Collections.min(list)
double array[] = {, , , ,  };
List list = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.min(list);
for (int i = ; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：23
傳回Collections中最大元素（max）

根據指定比較器産生的順序，傳回給定 collection 的最大元素。collection 中的所有元素都必須是通過指定比較器可互相比較的

Collections.max(list)
double array[] = {, , , ,  };
List list = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = ; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：456
lastIndexOfSubList

傳回指定源清單中最後一次出現指定目标清單的起始位置，即按從後到前的順序傳回子List在父List中的索引位置。

int count = Collections.lastIndexOfSubList(list,li);
double array[] = {, , , ,  };
List list = new ArrayList();
List li = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=;j
li.add(new Double(arr[j]));
}
Int locations = Collections. lastIndexOfSubList (list,li);
System.out.println(“===”+ locations);
//結果 3
IndexOfSubList

傳回指定源清單中第一次出現指定目标清單的起始位置

int count = Collections.indexOfSubList(list,li);
double array[] = {, , , ,  };
List list = new ArrayList();
List li = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=;j
li.add(new Double(arr[j]));
}
Int locations = Collections.indexOfSubList(list,li);
System.out.println(“===”+ locations);
//結果 1
Rotate

根據指定的距離循環移動指定清單中的元素

Collections.rotate（list，-）；

如果是負數，則正向移動，正數則方向移動
double array[] = {, , , ,  };
List list = new ArrayList();
for (int i = ; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.rotate(list,-);
for (int i = ; i
System.out.println("list[" + i + "]=" + list.get(i));
}
//結果：111,23,456,231,112
java java集合 arrays collections
上一篇: Java Arrays工具類常用方法總結
下一篇: NameNode多次Format後DataNode無法啟動的問題

繼續閱讀