java集合工具类Collections

前言

java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

一、元素操作

1、增加值

static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合中。 

案例

ArrayList<Number> a = new ArrayList<Number>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
Collections.addAll(a,new Integer[]{9,8}); 
System.out.println(a);[1, 2, 3, 4, 9, 8] 

2、填充

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

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1); 
a.add(2);
a.add(3);
a.add(1); 
Collections.fill(a,0); 
System.out.println(a);[0, 0, 0, 0] 

3、元素的数目

static int frequency(Collection<?> c, Object o) 返回指定集合中等于指定对象的元素的数目。 

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(1); 
System.out.println(Collections.frequency(a,1));2 

4、替换

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 将列表中的某一特定值的所有出现替换为另一个。 

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(1); 
Collections.replaceAll(a,1,9); 
System.out.println(a);[9, 2, 3, 9] 

5、反转

static void reverse(List<?> list) 反转指定列表中元素的顺序。

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
Collections.reverse(a); 
System.out.println(a);//[4, 3, 2, 1] 

6、随机置换指定列表值的顺序

static void shuffle(List<?> list) //随机置换指定列表使用随机默认源。   
static void shuffle(List<?> list, Random rnd) //随机排列指定列表使用指定的随机源。   

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
Collections.shuffle(a); 
System.out.println(a);[1, 4, 3, 2] 

7、指定的距离旋转

static void rotate(List<?> list, int distance) 按指定的距离旋转指定列表中的元素。

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
System.out.println(a);//[1, 2, 3, 4] 
Collections.rotate(a,2); 
System.out.println(a);//[3, 4, 1, 2] 

8、指定位置交换元素

static void swap(List<?> list, int i, int j) 在指定的列表中的指定位置上交换元素。

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
System.out.println(a);[1, 2, 3, 4] 
Collections.swap(a,1,2) ; 
System.out.println(a);[1, 3, 2, 4] 

9、有没有共同的元素？

static boolean disjoint(Collection<?> c1, Collection<?> c2) //如果两个指定集合没有共同的元素返回 true 

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(2);
a.add(3);
a.add(4); 
ArrayList<Integer> b = new ArrayList<Integer>(); 
b.add(4);
b.add(6);
b.add(7);
b.add(8);          
System.out.println(Collections.disjoint(a,b));//false 

10、复制

注意：dest - 目标列表长度必须大于等于src - 源列表长度否则抛出异常

static <T> void copy(List<? super T> dest, List<? extends T> src) //将所有的元素从一个列表复制到另一个列表中。 

案例

ArrayList<Integer> a = new ArrayList<Integer>(); 
a.add(1);
a.add(1);
a.add(3);
a.add(1); 
ArrayList<Integer> b = new ArrayList<Integer>(); 
b.add(6);
b.add(5);
b.add(7); 
Collections.copy(a,b); 
System.out.println(b);[6, 5, 7] 
System.out.println(a);[6, 5, 7, 1] 

11、二分法查找

list - 要搜索的列表，key - 要搜索的值；如果找到就返回值在集合中的位置，否则返回负数

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 

12、查询列表

target- 要搜索的列表；指定源列表中第一次出现指定目标列表的起始位置，如果不存在，则返回-1

static int indexOfSubList(List<?> source, List<?> target) 返回指定的源列表中指定的目标列表的第一个发生的起始位置。  

static int lastIndexOfSubList(List<?> source, List<?> target) 返回指定的源列表中指定的目标列表的最后一个发生的起始位置，

案例

List<String>listSources=Arrays.asList("1","2","3","4","5","6");
List<String>listTarget=Arrays.asList("2","3");
int a =Collections.indexOfSubList(listSources,listTarget);
System.out.println(a);1

13、排序

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 <T> Comparator<T> reverseOrder()// 返回一个比较器，对一系列的实施 Comparable界面对象的自然顺序相反。   
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) //返回一个对指定比较器的反向排序的比较器。   

14、最值

//返回最小的元素的集合，根据其元素的自然排序。  
static <T extends Object & Comparable<? super T>>T min(Collection<? extends T> coll) 

//返回最大元素的集合，根据其元素的自然排序。 
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> T min(Collection<? extends T> coll, Comparator<? super T> comp) 

二、返回集合

1、返回一个Collection

//将一个Collection变为一个不可修改的视图。
static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 
//将将一个非线程安全Collection变为一个线程安全的Collection。
static <T> Collection<T> synchronizedCollection(Collection<T> c) 
static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type) 返回一个指定集合的动态类型安全的观点。  	

2、返回一个List

static <T> List<T> emptyList() //返回一个空列表（不可变）。

static <T> List<T> unmodifiableList(List<? extends T> list) //返回指定列表中的一个不可修改的视图。 
 
static <T> List<T> synchronizedList(List<T> list) //返回由指定列表支持的同步（线程安全）列表。
  
static <T> List<T> singletonList(T o) //返回只包含指定对象的不可改变的列表

static <T> List<T> nCopies(int n, T o)//返回一个不可变列表组成的n个拷贝的指定对象

static <T> ArrayList<T> list(Enumeration<T> e) //返回一个数组列表，该列表包含在返回的顺序中由枚举返回的元素的元素。

static <E> List<E> checkedList(List<E> list, Class<E> type) //返回一个动态类型安全的查看指定的列表。

案例

List<String> stringList = Collections.nCopies(2, "A");
stringList.forEach(System.out::print);AA
stringList.add("v");//Exception in thread "main" java.lang.UnsupportedOperationException

2、返回一个Queue

static <E> Queue<E> checkedQueue(Queue<E> queue, 类<E> type) //返回一个动态类型安全的查看指定队列。

static <T> Queue<T> asLifoQueue(Deque<T> deque) //返回一个 Deque视图为后进先出（LIFO） Queue。

3、返回一个Set

static <T> Set<T> unmodifiableSet(Set<? extends T> s) //返回指定的设置不可修改的视图。
static <T> Set<T> synchronizedSet(Set<T> s) //返回一个由指定集合支持的同步（线程安全）集。  
static <E> Set<E> newSetFromMap(Map<E,Boolean> map) //返回一个由指定的映射支持的集合。
static <E> Set<E> checkedSet(Set<E> s, 类<E> type) //返回一个指定的动态类型安全的观点。
static <T> Set<T> emptySet() //返回一个空集（不可变）。   
static <T> Set<T> singleton(T o) //返回只包含指定对象的不可改变的集合。  

4、返回一个SortedSet

static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 返回指定的排序设置不可修改的视图。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 返回一个由指定的排序集支持的同步（线程安全）排序集。
static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 类<E> type) 返回一个mj的排序设置。  
static <E> SortedSet<E> emptySortedSet() 返回一个空的排序集（不可变）。

5、返回一个NavigableSet

static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) 返回指定通航设置不可修改的视图。  
static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 返回由指定的导航集支持的同步（线程安全）导航集。  
static <E> NavigableSet<E> emptyNavigableSet() 返回一个空的导航集（不可变）。
static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 类<E> type) 返回一个动态类型安全的集合视图指定通航。

6、返回一个Map

static <K,V> Map<K,V> emptyMap()//返回一个空Map，且是不可变的 
static <K,V> Map<K,V> singletonMap(K key, V value) //返回只包含指定对象的不可改变的列表
static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) //这个方法是将一个map变成一个不可修改的map
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) //讲一个map变成一个SynchronizedMap（线程安全）
static <K,V> Map<K,V> checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType) //返回一个动态类型安全的查看指定的Map。  

7、返回一个SortedMap

static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) //返回指定的排序图上一个不可修改的视图。  
//返回一个由指定的排序映射支持的同步（线程安全）排序的Map。  
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 
static <K,V> SortedMap<K,V> emptySortedMap() //返回一个空的排序映射（不可变）。
//返回一个动态类型安全的查看指定的排序图。 
static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType) 

8、返回一个NavigableMap

//返回指定的导航电子Map的一个不可修改的视图。  
static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) 
//返回一个动态类型安全的查看指定的导航电子Map。
static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType) 
//返回指定的导航Map支持的同步（线程安全）导航Map。  
static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 
static <K,V> NavigableMap<K,V> emptyNavigableMap() //返回一个空的导航Map（不可变）。

9、返回一个Enumeration

static <T> Enumeration<T> enumeration(Collection<T> c) //返回指定集合的枚举数。  
static <T> Enumeration<T> emptyEnumeration() //返回一个没有元素的枚举。

10、返回一个迭代器

static <T> Iterator<T> emptyIterator() //返回一个没有元素的迭代器。     
static <T> ListIterator<T> emptyListIterator() //返回一个没有元素的列表迭代器。