Collections工具类及List， Map方法

最新推荐文章于 2025-06-23 20:59:12 发布

原创最新推荐文章于 2025-06-23 20:59:12 发布 · 930 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

26 篇文章

订阅专栏

本文详细介绍了Java中Collections工具类的功能及用法，包括排序、查找、替换等操作，并讲解了如何实现集合的同步控制和不可变特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Collections工具类提供了大量针对Collection/Map的操作，总体可分为四类，都为静态（static）方法：

1. 排序操作（主要针对List接口相关）

· reverse(List list)：反转指定List集合中元素的顺序

· shuffle(List list)：对List中的元素进行随机排序（洗牌）

· sort(List list)：对List里的元素根据自然升序排序

· sort(List list, Comparator c)：自定义比较器进行排序

· swap(List list, int i, int j)：将指定List集合中i处元素和j出元素进行交换

· rotate(List list, int distance)：将所有元素向右移位指定长度，如果distance等于size那么结果不变

public void testSort() {

System.out.println("原始顺序：" + list);

Collections.reverse(list);

System.out.println("reverse后顺序：" + list);

Collections.shuffle(list);

System.out.println("shuffle后顺序：" + list);

Collections.swap(list, 1, 3);

System.out.println("swap后顺序：" + list);

Collections.sort(list);

System.out.println("sort后顺序：" + list);

Collections.rotate(list, 1);

System.out.println("rotate后顺序：" + list);

}

输出

原始顺序：[b张三, d孙六, a李四, e钱七, c赵五]
reverse后顺序：[c赵五, e钱七, a李四, d孙六, b张三]
shuffle后顺序：[b张三, c赵五, d孙六, e钱七, a李四]
swap后顺序：[b张三, e钱七, d孙六, c赵五, a李四]
sort后顺序：[a李四, b张三, c赵五, d孙六, e钱七]
rotate后顺序：[e钱七, a李四, b张三, c赵五, d孙六]

2. 查找和替换（主要针对Collection接口相关）

· binarySearch(List list, Object key)：使用二分搜索法，以获得指定对象在List中的索引，前提是集合已经排序

· max(Collection coll)：返回最大元素

· max(Collection coll, Comparator comp)：根据自定义比较器，返回最大元素

· min(Collection coll)：返回最小元素

· min(Collection coll, Comparator comp)：根据自定义比较器，返回最小元素

· fill(List list,Object obj)：使用指定对象填充

· frequency(Collection Object o)：返回指定集合中指定对象出现的次数

· replaceAll(List list, Object old, Object new)：替换

public void testSearch() {

System.out.println("给定的list：" + list);

System.out.println("max：" + Collections.max(list));

System.out.println("min：" + Collections.min(list));

System.out.println("frequency：" + Collections.frequency(list, "a李四"));

Collections.replaceAll(list, "a李四", "aa李四");

System.out.println("replaceAll之后：" + list);

// 如果binarySearch的对象没有排序的话，搜索结果是不确定的

System.out.println("binarySearch在sort之前：" + Collections.binarySearch(list, "c赵五"));

Collections.sort(list);

// sort之后，结果出来了

System.out.println("binarySearch在sort之后：" + Collections.binarySearch(list, "c赵五"));

Collections.fill(list, "A");

System.out.println("fill：" + list);

}

输出

给定的list：[b张三, d孙六, a李四, e钱七, c赵五]
max：e钱七
min：a李四
frequency：1
replaceAll之后：[b张三, d孙六, aa李四, e钱七, c赵五]
binarySearch在sort之前：-4
binarySearch在sort之后：2
fill：[A, A, A, A, A]

3. 同步控制

Collections工具类中提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题。HashSet、ArrayList、HashMap都是线程不安全的，如果需要考虑同步，则使用这些方法。这些方法主要有：synchronizedSet、synchronizedSortedSet、synchronizedList、synchronizedMap、synchronizedSortedMap。

特别需要指出的是，在使用迭代方法遍历集合时需要手工同步返回的集合。

Map m = Collections.synchronizedMap(new HashMap());

...

Set s = m.keySet(); // Needn't be in synchronized block

...

synchronized (m) { // Synchronizing on m, not s!

Iterator i = s.iterator(); // Must be in synchronized block

while (i.hasNext())

foo(i.next());

}

4. 设置不可变集合

Collections有三类方法可返回一个不可变集合：

1. emptyXxx()：返回一个空的不可变的集合对象

2. singletonXxx()：返回一个只包含指定对象的，不可变的集合对象。

3. unmodifiableXxx()：返回指定集合对象的不可变视图

public void testUnmodifiable() {

System.out.println("给定的list：" + list);

List<String> unmodList = Collections.unmodifiableList(list);

unmodList.add("再加个试试！"); // 抛出：java.lang.UnsupportedOperationException

// 这一行不会执行了

System.out.println("新的unmodList：" + unmodList);

}

list常用方法

1.list中添加，获取，删除元素；

　　添加方法是：.add(e)；　　获取方法是：.get(index)；　　删除方法是：.remove(index)；按照索引删除；　　.remove(Object o)；按照元素内容删除；

List<String> person=new ArrayList<>();

person.add("jackie"); //索引为0 //.add(e)

person.add("peter"); //索引为1

person.add("annie"); //索引为2

person.add("martin"); //索引为3

person.add("marry"); //索引为4

person.remove(3); //.remove(index)

person.remove("marry"); //.remove(Object o)

String per="";

per=person.get(1);

System.out.println(per); ////.get(index)

for (int i = 0; i < person.size(); i++) {

System.out.println(person.get(i)); //.get(index)

}

2.list中是否包含某个元素；

　　方法：.contains（Object o）；返回true或者false

List<String> fruits=new ArrayList<>();

fruits.add("苹果");

fruits.add("香蕉");

fruits.add("桃子");

//for循环遍历list

for (int i = 0; i < fruits.size(); i++) {

System.out.println(fruits.get(i));

} String appleString="苹果";

//true or false

System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));

if (fruits.contains(appleString)) {

System.out.println("我喜欢吃苹果");

}else {

System.out.println("我不开心");

}

3.list中根据索引将元素数值改变(替换)；

　　注意 .set(index, element); 和 .add(index, element); 的不同；

String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";

List<String> people=new ArrayList<>();

people.add(a);

people.add(b);

people.add(c);

people.set(0, d); //.set(index, element); //将d唐僧放到list中索引为0的位置，替换a白龙马

people.add(1, e); //.add(index, element); //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位

//增强for循环遍历list

for(String str:people){

System.out.println(str);

}

4.list中查看（判断）元素的索引；　

　　注意：.indexOf（）；和 lastIndexOf（）的不同；

List<String> names=new ArrayList<>();

names.add("刘备"); //索引为0

names.add("关羽"); //索引为1

names.add("张飞"); //索引为2

names.add("刘备"); //索引为3

names.add("张飞"); //索引为4

System.out.println(names.indexOf("刘备"));

System.out.println(names.lastIndexOf("刘备"));

System.out.println(names.indexOf("张飞"));

System.out.println(names.lastIndexOf("张飞"));

5.根据元素索引位置进行的判断;

if (names.indexOf("刘备")==0) {

System.out.println("刘备在这里");

}else if (names.lastIndexOf("刘备")==3) {

System.out.println("刘备在那里");

}else {

System.out.println("刘备到底在哪里？");

}

6.利用list中索引位置重新生成一个新的list（截取集合）；

　　方法： .subList(fromIndex, toIndex)；　　.size() ；该方法得到list中的元素数的和

List<String> phone=new ArrayList<>();

phone.add("三星"); //索引为0

phone.add("苹果"); //索引为1

phone.add("锤子"); //索引为2

phone.add("华为"); //索引为3

phone.add("小米"); //索引为4

//原list进行遍历

for(String pho:phone){

System.out.println(pho);

}

//生成新list

phone=phone.subList(1, 4); //.subList(fromIndex, toIndex) //利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3

for (int i = 0; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和

System.out.println("新的list包含的元素是"+phone.get(i));

}

map常用方法

keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。

Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。

Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
map.put(4, "d");
Set keys1 = map.keySet();
Set keys2 = map.keySet();
Set keys3 = map.keySet();
System.out.println(keys1);
System.out.println(map.values());
for(Object x: map.values()) {
System.out.print(x+"~");
}
System.out.println();
for(Entry<?, ?> y:map.entrySet()) { //常用遍历方法
System.out.print(y.getKey()+":"+y.getValue()+" ");
}
System.out.println();
map.remove(1);
System.out.println(keys2);
System.out.println(keys3);

输出结果如下

[1, 2, 3, 4]
[a, b, c, d]
a~b~c~d~
1:a 2:b 3:c 4:d
[2, 3, 4]
[2, 3, 4]