Collections是一个操作List,Set和Map集合的工具类:
增加元素:
static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合。
List<Integer> list = new ArrayList<>();
Collections.addAll(list,3,5,2,5,6,9,10,-1,6);//9个元素
对List集合进行排序:
void reverse(List list) 反序
void shuffle(List list) 乱序
void sort(List list) 按照元素的自然顺序进行排序
void sort(List list,Comparator) 按照比较器定义的规则进行排序
void swap(List list,int i,int j) 将list集合中第i个和第j个元素互换
void rotate(list,int distance) 当distance为正数时,将list集合的后distance个元素整体移到前面.当distance为负数时,将list集合的前distance个元素整体移到后面.不会改变集合的大小
/**
* Collections集合工具对list集合的排序方法测试
*/
private static void method1() {
List<Integer> list = new ArrayList<>();
Collections.addAll(list,3,5,2,5,6,9,10,-1,6);//9个元素
Collections.sort(list);
System.out.println(list);//[-1, 2, 3, 5, 5, 6, 6, 9, 10]
Collections.sort(list,(i,j)->{
return j-i;//从大到小排序
});
System.out.println(list);//[10, 9, 6, 6, 5, 5, 3, 2, -1]
Collections.swap(list,0,1);
System.out.println(list);//[9, 10, 6, 6, 5, 5, 3, 2, -1]
Collections.rotate(list,8);
System.out.println(list);//[10, 6, 6, 5, 5, 3, 2, -1, 9]
}
查找元素:
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) 使用二叉搜索算法搜索指定对象的指定列表。 Comparator为null,则按照自然顺序进行排序
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 int frequency(Collection<?> c, Object o) 返回指定集合中与指定对象相等的元素数。
static int indexOfSubList(List<?> source, List<?> target) 返回指定源列表中指定目标列表的第一次出现的起始位置,如果没有此类事件,则返回-1。
static int lastIndexOfSubList(List<?> source, List<?> target) 返回指定源列表中指定目标列表的最后一次出现的起始位置,如果没有此类事件则返回-1。
替换:
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
static <T> void fill(List<? super T> list, T obj) 用指定的元素代替指定列表的所有元素。
/**
* Collections对集合元素的查找和替换
*/
private static void method2() {
List<String> list = new ArrayList<>();
Collections.addAll(list,"a","aa","aa","a","aaa","a","aaaa","aaa","aaaaa");
System.out.println(Collections.binarySearch(list,"a"));//0,未排序,不保证搜索的结果
System.out.println();
Collections.sort(list);//自然排序后搜索
System.out.println(list);//[a, a, a, aa, aa, aaa, aaa, aaaa, aaaaa]
System.out.println(Collections.binarySearch(list,"a"));//1
System.out.println(Collections.binarySearch(list,"a",(s1,s2)->{
return s2.length()-s1.length();
}));//-10 搜索不到
System.out.println(Collections.binarySearch(list,"a",null));//1
System.out.println(Collections.max(list));//aaaaa
Comparator<String> comparator = (s1, s2)->{ return s2.length()-s1.length();};
System.out.println(Collections.max(list,comparator));//a
//自定义排序后搜索
Collections.sort(list,comparator);
System.out.println(list);//[aaaaa, aaaa, aaa, aaa, aa, aa, a, a, a]
System.out.println(Collections.binarySearch(list,"a"));//-1 搜索不到
System.out.println(Collections.binarySearch(list,"a",comparator));//6
System.out.println(Collections.max(list));//aaaaa
System.out.println(Collections.max(list,(s1,s2)->{//aaaaa
return s1.length()-s2.length();
}));
System.out.println(Collections.max(list,comparator));//a
System.out.println(Collections.frequency(list,"a"));//3,出现了3次
List<String> list2 = new ArrayList<>();
Collections.addAll(list2,"aaaa","aaa");
System.out.println(Collections.indexOfSubList(list,list2));//1
list2.clear();
Collections.addAll(list2,"aaaa","aa");
System.out.println(Collections.indexOfSubList(list,list2));//-1,两个集合中元素的顺序要一致才认为是子集合
Collections.replaceAll(list,"a","b");
System.out.println(list);//[aaaaa, aaaa, aaa, aaa, aa, aa, b, b, b]
Collections.fill(list,"zz");
System.out.println(list);//[zz, zz, zz, zz, zz, zz, zz, zz, zz]
}
线程安全:
Collections提供了synchoronizedXxx方法,这些方法可以将对应的集合包装成线程同步的集合,从而解决线程安全问题.
ArrayList,LinkedList,ArrayDeque,HashSet,LinkedHashSet,TreeSet,HashMap,LinkedHashMap,TreeMap都是线程不安全的.如果有多个线程访问线程不安全的集合,并且有一个以上的线程要修改该结合,那么就存在线程安全问题.Collections的同步方法就是用来解决这个问题的.
static <T> Collection<T> synchronizedCollection(Collection<T> c) 返回由指定集合支持的同步(线程安全)集合。
static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步(线程安全)列表。
static <T> Set<T> synchronizedSet(Set<T> s) 返回由指定集合支持的同步(线程安全)集。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定地图支持的同步(线程安全)映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 返回由指定的排序集支持的同步(线程安全)排序集。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 返回由指定的排序映射支持的同步(线程安全)排序映射。
static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 返回由指定的可导航集支持的同步(线程安全)可导航集。
static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 返回由指定的可导航地图支持的同步(线程安全)可导航地图。
/**
* 同步方法
*/
private static void mehtod3() {
List list = Collections.synchronizedList(new ArrayList<>());
Collection queue = Collections.synchronizedCollection(new ArrayDeque<>());
Set set = Collections.synchronizedSet(new HashSet());
SortedSet sset = Collections.synchronizedSortedSet(new TreeSet<>());
Map map = Collections.synchronizedMap(new HashMap<>());
SortedMap smap = Collections.synchronizedSortedMap(new TreeMap<>());
}
设置不可变集合:
0个元素
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)。
1个元素
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> Collection<T> unmodifiableCollection(Collection<? extends T> c) 返回指定集合的不可修改视图。
static <T> List<T> unmodifiableList(List<? extends T> list) 返回指定列表的不可修改视图。
static <T> Set<T> unmodifiableSet(Set<? extends T> s) 返回指定集合的不可修改视图。
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 <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) 返回指定排序映射的不可修改视图。
static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 返回指定排序集的不可修改视图。
更改不可变集合,会出不支持操作异常