写在开头：本文用于作者学习Java常用API
我将官方文档中Collections类中所有API全测了一遍并打印了结果，日拱一卒，常看常新
addAll()
将所有指定元素添加到指定 collection 中
可以添加一个或多个元素
@Test
public void test_addAll(){
/*将所有指定元素添加到指定 collection 中
* 可以添加一个或多个元素*/
ArrayList<String> strings = new ArrayList<>();
strings.add("1");
strings.add("2");
strings.add("3");
Collections.addAll(strings, "a","b","c");
System.out.println(strings);//[1, 2, 3, a, b, c]
System.out.println(Collections.addAll(strings, "d"));
System.out.println(strings);//[1, 2, 3, a, b, c, d]
}asLifQueue()
该方法用于将指定的Deque（双端队列）转换为后进先出（LIFO）队列
@Test
public void test_asLifQueue(){
/*该方法用于将指定的Deque（双端队列）转换为后进先出（LIFO）队列。*/
ArrayDeque<String> deque = new ArrayDeque<>();
deque.add("first");
deque.add("second");
deque.add("third");
System.out.println(deque);//[first, second, third]
Queue<String> queue = Collections.asLifoQueue(deque);
while (!queue.isEmpty()){
String poll = queue.poll();
System.out.println(poll);//转换为后进先出（LIFO）队列时，并不改变元素的顺序，而是将Deque视为LIFO队列。因此，在使用poll方法时，仍然是按照Deque的顺序取出元素，而不是按照后进先出的顺序。
/*first
second
third*/
}
}binarySearch()
输入指定元素，返回对应的下标
-5：该元素不存在
@Test
public void test_binarySearch(){
/*输入指定元素，返回对应的下标
-5：该元素不存在*/
List<Integer> list = Arrays.asList(1, 2, 3, 4);
System.out.println(Collections.binarySearch(list, 1));//0
System.out.println(Collections.binarySearch(list, 2));//1
System.out.println(Collections.binarySearch(list, 5));//-5 表示不存在
System.out.println(Collections.binarySearch(list, 8));//-5
System.out.println(Collections.binarySearch(list, 11));//-5
}copy()
将所有元素从一个列表复制到另一个列表。第一个参数是目标列表，第二个是源列表
目标列表长度必须不小于源列表
@Test
public void test_copy(){
/*将所有元素从一个列表复制到另一个列表。第一个参数是目标列表，第二个是源列表
* 目标列表长度必须不小于源列表*/
List<Integer> src = Arrays.asList(1, 2, 3, 4);
List<Integer> dest = Arrays.asList(0,0,0,0);
Collections.copy(dest,src);
System.out.println(dest);//[1, 2, 3, 4]
List<Object> dest1 = Collections.emptyList();//造一个空列表
/*Collections.copy(dest1,src);//报错：目标列表长度小于源列表长度
System.out.println(dest1);//IndexOutOfBoundsException: Source does not fit in dest*/
List<Object> dest2 = Collections.nCopies(4, null);//会生成一个包含4个null元素的不可变列表
System.out.println(dest2);//[null, null, null, null]
/*Collections.copy(dest2,src);//报错：UnsupportedOperationException
System.out.println(dest2);*/
ArrayList<Integer> dest3 = new ArrayList<>();
dest3.add(0);
dest3.add(0);
dest3.add(0);
dest3.add(0);
dest3.add(0);
Collections.copy(dest3,src);
System.out.println(dest3);//[1, 2, 3, 4, 0]
}disjoint()
判断两个集合是否完全不包含对方集合的元素
完全不包含，返回 true。
哪怕包含1个，都返回false
@Test
public void test_disjoint(){
/*判断两个集合是否完全不包含对方集合的元素
完全不包含，返回 true。
哪怕包含1个，都返回false*/
List<Integer> c1 = Arrays.asList(1, 2, 3, 4);
List<Integer> c2 = Arrays.asList(1, 2, 3, 4);
System.out.println(Collections.disjoint(c1, c2));//false
List<Integer> c3 = Arrays.asList(1, 5, 6);
System.out.println(Collections.disjoint(c1, c3));//false
List<Integer> c4 = Arrays.asList(7, 5, 6);
System.out.println(Collections.disjoint(c1, c4));//true
}emptyList()
返回一个不可变空列表
@Test
public void test_emptyList(){
/*返回一个不可变空列表
* 意义：
* 1. 节省内存：由于空列表是不可变的，可以在不需要实际数据的情况下节省内存空间。在某些场景下，需要一个空列表作为占位符或默认返回值，此时使用Collections.emptyList()可以避免创建多个空列表对象。
2. 避免空指针异常：在某些情况下，需要返回一个空列表而不是null，以避免空指针异常。使用Collections.emptyList()可以提供一个安全的空列表对象。
3. API一致性：在一些API设计中，需要返回一个空列表作为特定情况的标识符，使用Collections.emptyList()可以保持API的一致性和规范性。
虽然Collections.emptyList()返回的空列表不能被修改，但它在某些情况下仍然具有一定的实用性和意义。*/
List<Object> objects = Collections.emptyList();
System.out.println(objects);//[]
// System.out.println(objects.add("dahua"));//UnsupportedOperationException
}emptyMap()
返回1个空的map（不可变的）
@Test
public void test_emptyMap(){
/*返回1个空的map（不可变的）。*/
Map<Object, Object> objectMap = Collections.emptyMap();
System.out.println(objectMap);//{}
}emptySet()
返回1个空的set（不可变的）
@Test
public void test_emptySet(){
/*返回1个空的set（不可变的）*/
Set<Object> objectSet = Collections.emptySet();
System.out.println(objectSet);//[]
}enumeration()
返回一个枚举类型的列表
@Test
public void test_enumeration(){
/*返回一个枚举类型的列表*/
List<String> c = Arrays.asList("dahua", "xiaoyabing", "sangxinran", "fangmangmang");
Enumeration<String> enumeration = Collections.enumeration(c);
System.out.println(enumeration);//java.util.Collections$3@3d82c5f3
while (enumeration.hasMoreElements()){
System.out.println(enumeration.nextElement());
}
/*
dahua
xiaoyabing
sangxinran
fangmangmang
*/
}fill()
使用指定元素替换、填充指定列表中的所有元素
@Test
public void test_fill(){
/*使用指定元素替换、填充指定列表中的所有元素*/
List<String> c = Arrays.asList("dahua", "xiaoxiao", "xiaosang", "xiaofang");
Collections.fill(c,"lgf");
System.out.println(c);//[lgf, lgf, lgf, lgf]
}frequency()
返回集合中指定对象的个数
@Test
public void test_frequency(){
/*返回集合中指定对象的个数*/
List<String> c = Arrays.asList("dahua", "xiaoxiao", "xiaosang", "xiaofang","xiaofang");
System.out.println(Collections.frequency(c, "xiaofang"));//2
System.out.println(Collections.frequency(c, "dahua"));//1
}indexOfSubList()
返回一个数组列表，它按返回顺序包含指定枚举返回的元素
@Test
public void test_indexOfSubList(){
/*返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1*/
List<String> src = Arrays.asList("dahua", "xiaoxiao", "xiaosang", "xiaofang","xiaofang");
List<String> target = Arrays.asList("dahua", "xiaoxiao", "xiaosang", "xiaofang","xiaofang");
System.out.println(Collections.indexOfSubList(src, target));//0
List<String> target1= Arrays.asList("dahua", "xiaoxiao", "xiaosang", "xiaofang","xiaofang","dahai");
System.out.println(Collections.indexOfSubList(src, target1));//-1
}list()
返回一个数组列表，它按返回顺序包含指定枚举返回的元素
@Test
public void test_list(){
/*返回一个数组列表，它按返回顺序包含指定枚举返回的元素*/
List<String> c = Arrays.asList("dahua", "xiaoyabing", "sangxinran", "fangmangmang");
Enumeration<String> enumeration = Collections.enumeration(c);
ArrayList<String> list = Collections.list(enumeration);
System.out.println(list);//[dahua, xiaoyabing, sangxinran, fangmangmang]
Vector<String> vector = new Vector<>();
vector.add("Apple");
vector.add("Banana");
vector.add("Orange");
Enumeration<String> elements = vector.elements();
ArrayList<String> list1 = Collections.list(elements);
System.out.println(list1);//[Apple, Banana, Orange]
}max()
根据元素的自然顺序，返回集合中的最大元素
*
* 也可以自定义排序规则
@Test
public void test_max(){
/*根据元素的自然顺序，返回集合中的最大元素
*
* 也可以自定义排序规则*/
List<String> coll = Arrays.asList("dahua", "xiaoyabing", "sangxinran", "fangmangmang");
System.out.println(Collections.max(coll));//xiaoyabing
/*
自定义大小规则
第二个参数写比较器，返回给定 集合 的最大元素*/
String max = Collections.max(coll, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int i = o1.substring(0).hashCode();
int i1 = o2.substring(0).hashCode();
return i - i1;
}
});
System.out.println(max);//fangmangmang
}min()
返回集合最小元素
@Test
public void test_min(){
/*
* 返回集合最小元素
* */
// Collections.min()
}nCopies()
返回由指定对象的 n 个副本组成的不可变列表
@Test
public void test_nCopies(){
/*返回由指定对象的 n 个副本组成的不可变列表*/
List<String> dahua = Collections.nCopies(5, "dahua");
System.out.println(dahua);//[dahua, dahua, dahua, dahua, dahua]
List<Object> objects = Collections.nCopies(5, null);
System.out.println(objects);//[null, null, null, null, null]
/*objects.add("xiaomei");//UnsupportedOperationException，不可变了
System.out.println(objects);*/
}newSetFromMap()
将Map转成set结构，前提是map必须为空
@Test
public void test_newSetFromMap(){
/*将Map转成set结构，前提是map必须为空*/
Map<String, Boolean> map = new HashMap<>();
map.put("Apple", true);
map.put("Banana", false);
map.put("Orange", true);
// Set<String> set1 = Collections.newSetFromMap(map);//IllegalArgumentException: Map is non-empty:map必须为空
map.clear();
Set<String> set = Collections.newSetFromMap(map);
}replaceAll()
用一个值替换集合原有子串
@Test
public void test_replaceAll(){
/*
我的：用一个值替换集合原有子串
官方：使用另一个值替换列表中出现的所有某一指定值*/
List<String> list = Arrays.asList("dahua", "xiaoyabing", "sangxinran", "fangmangmang");
Collections.replaceAll(list,"dahua","xiaoliang");
System.out.println(list);//[xiaoliang, xiaoyabing, sangxinran, fangmangmang]
}reverse()
列表元素反转
@Test
public void test_reverse(){
/*列表元素反转*/
List<String> list = Arrays.asList("dahua", "xiaoyabing", "sangxinran", "fangmangmang");
Collections.reverse(list);
System.out.println(list);//[fangmangmang, sangxinran, xiaoyabing, dahua]
}rotate()
指定的距离循环滚动
@Test
public void test_rotate(){
/*指定的距离循环滚动*/
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 将列表向右循环移动2个位置，第一个元素往右走两格
Collections.rotate(list, 2);
System.out.println(list);//[4, 5, 1, 2, 3]
}shuffle()
将列表元素随机打乱
@Test
public void test_shuffle(){
/*将列表元素随机打乱*/
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Collections.shuffle(list);
System.out.println(list);//[3, 5, 4, 1, 2] 第一次运行结果
System.out.println(list);//[2, 5, 4, 3, 1] 第二次运行结果
System.out.println(list);//[4, 3, 2, 5, 1] 第三次运行结果
}singleton()
返回一个只包含指定对象的不可变 set
Test
public void test_singleton(){
/*返回一个只包含指定对象的不可变 set*/
List<String> list = Arrays.asList("dahua", "dahua", "sangxinran", "fangmangmang");
Set<List<String>> singleton = Collections.singleton(list);
System.out.println(singleton);//[[dahua, dahua, sangxinran, fangmangmang]]
}
591
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
