Collections 工具类常见方法

Collections 工具类常用方法:

排序

查找,替换操作

同步控制(不推荐，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合)

排序操作

void reverse(List list)//反转

void shuffle(List list)//随机排序

void sort(List list)//按自然排序的升序排序

void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑

void swap(List list, int i , int j)//交换两个索引位置的元素

void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

示例代码:

ArrayList<Integer> arrayList = new ArrayList<Integer>();

arrayList.add(-1);

arrayList.add(3);

arrayList.add(3);

arrayList.add(-5);

arrayList.add(7);

arrayList.add(4);

arrayList.add(-9);

arrayList.add(-7);

System.out.println("原始数组:");

System.out.println(arrayList);

// void reverse(List list)：反转

Collections.reverse(arrayList);

System.out.println("Collections.reverse(arrayList):");

System.out.println(arrayList);

Collections.rotate(arrayList, 4);

System.out.println("Collections.rotate(arrayList, 4):");

System.out.println(arrayList);

// void sort(List list),按自然排序的升序排序

Collections.sort(arrayList);

System.out.println("Collections.sort(arrayList):");

System.out.println(arrayList);

// void shuffle(List list),随机排序

Collections.shuffle(arrayList);

System.out.println("Collections.shuffle(arrayList):");

System.out.println(arrayList);

// void swap(List list, int i , int j),交换两个索引位置的元素

Collections.swap(arrayList, 2, 5);

System.out.println("Collections.swap(arrayList, 2, 5):");

System.out.println(arrayList);

// 定制排序的用法

Collections.sort(arrayList, new Comparator<Integer>() {

@Override

public int compare(Integer o1, Integer o2) {

return o2.compareTo(o1);

}

});

System.out.println("定制排序后：");

System.out.println(arrayList);

查找,替换操作

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的

int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)

int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)

void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。

int frequency(Collection c, Object o)//统计元素出现次数

int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).

boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素

示例代码：

ArrayList<Integer> arrayList = new ArrayList<Integer>();

arrayList.add(-1);

arrayList.add(3);

arrayList.add(3);

arrayList.add(-5);

arrayList.add(7);

arrayList.add(4);

arrayList.add(-9);

arrayList.add(-7);

ArrayList<Integer> arrayList2 = new ArrayList<Integer>();

arrayList2.add(-3);

arrayList2.add(-5);

arrayList2.add(7);

System.out.println("原始数组:");

System.out.println(arrayList);

System.out.println("Collections.max(arrayList):");

System.out.println(Collections.max(arrayList));

System.out.println("Collections.min(arrayList):");

System.out.println(Collections.min(arrayList));

System.out.println("Collections.replaceAll(arrayList, 3, -3):");

Collections.replaceAll(arrayList, 3, -3);

System.out.println(arrayList);

System.out.println("Collections.frequency(arrayList, -3):");

System.out.println(Collections.frequency(arrayList, -3));

System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");

System.out.println(Collections.indexOfSubList(arrayList, arrayList2));

System.out.println("Collections.binarySearch(arrayList, 7):");

// 对List进行二分查找，返回索引，List必须是有序的

Collections.sort(arrayList);

System.out.println(Collections.binarySearch(arrayList, 7));

同步控制

Collections提供了多个synchronizedXxx()方法·，MT4下载教程该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。

我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。

最好不要用下面这些方法，效率非常低，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合。

方法如下：

synchronizedCollection(Collection<T>  c) //返回指定 collection 支持的同步（线程安全的）collection。

synchronizedList(List<T> list)//返回指定列表支持的同步（线程安全的）List。

synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（线程安全的）Map。

synchronizedSet(Set<T> s) //返回指定 set 支持的同步（线程安全的）set。

Collections还可以设置不可变集合，提供了如下三类方法：

emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。

singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。

unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。

上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。

示例代码：

ArrayList<Integer> arrayList = new ArrayList<Integer>();

arrayList.add(-1);

arrayList.add(3);

arrayList.add(3);

arrayList.add(-5);

arrayList.add(7);

arrayList.add(4);

arrayList.add(-9);

arrayList.add(-7);

HashSet<Integer> integers1 = new HashSet<>();

integers1.add(1);

integers1.add(3);

integers1.add(2);

Map scores = new HashMap();

scores.put("语文" , 80);

scores.put("Java" , 82);

//Collections.emptyXXX();创建一个空的、不可改变的XXX对象

List<Object> list = Collections.emptyList();

System.out.println(list);//[]

Set<Object> objects = Collections.emptySet();

System.out.println(objects);//[]

Map<Object, Object> objectObjectMap = Collections.emptyMap();

System.out.println(objectObjectMap);//{}

//Collections.singletonXXX();

List<ArrayList<Integer>> arrayLists = Collections.singletonList(arrayList);

System.out.println(arrayLists);//[[-1, 3, 3, -5, 7, 4, -9, -7]]

//创建一个只有一个元素，且不可改变的Set对象

Set<ArrayList<Integer>> singleton = Collections.singleton(arrayList);

System.out.println(singleton);//[[-1, 3, 3, -5, 7, 4, -9, -7]]

Map<String, String> nihao = Collections.singletonMap("1", "nihao");

System.out.println(nihao);//{1=nihao}

//unmodifiableXXX();创建普通XXX对象对应的不可变版本

List<Integer> integers = Collections.unmodifiableList(arrayList);

System.out.println(integers);//[-1, 3, 3, -5, 7, 4, -9, -7]

Set<Integer> integers2 = Collections.unmodifiableSet(integers1);

System.out.println(integers2);//[1, 2, 3]

Map<Object, Object> objectObjectMap2 = Collections.unmodifiableMap(scores);

System.out.println(objectObjectMap2);//{Java=82, 语文=80}

//添加出现异常：java.lang.UnsupportedOperationException

//        list.add(1);

//        arrayLists.add(arrayList);

//        integers.add(1);

java.utils.Collections 是集合工具类，用来对集合进行操作。

常用方法：

public static <T> boolean addAll(Collection<T> c, T... elements)         往集合中添加一些元素

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list,23,1421,1412,412,547);

System.out.println(list);              //输出:[23,1421,1412,412,547]

public static void shuffle(List<?> list)

打乱集合元素顺序

ArrayList<Integer> list = new ArrayList<>();

ArrayList<Integer> list1 = new ArrayList<>();

Collections.addAll(list,23,1421,1412,412,547);

Collections.shuffle(list);

System.out.println(list);                //输出:[1412, 23, 1421, 412, 547]

注意：Collections.shuffle()方法每次输出的结果都是不一样的

public static <T> void sort(List<T> list)

将集合中元素按照默认规则排序。

ArrayList<Integer> list = new ArrayList<>();

ArrayList<Integer> list1 = new ArrayList<>();

Collections.addAll(list,23,1421,1412,412,547);

Collections.sort(list);

System.out.println(list);                //输出:[23, 412, 547, 1412, 1421]

注意：其他数据类型使用Collections.sort()方法时，java内部有对各种数据类型进行排序(Integer是按升序进行排序)

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<>();

list.add(12);

list.add(33);

list.add(22);

//添加一些元素

Collections.addAll(list, 1, 3, 4, 13);

System.out.println(list);

//对集合进行排序

Collections.sort(list);

System.out.println(list);

ArrayList<String> lsit1 = new ArrayList<>();

lsit1.add("cbb");

lsit1.add("aba");

lsit1.add("sba");

lsit1.add("nba");

//调用Compartor方法比较

Collections.sort(lsit1, new Comparator<String>() {

@Override

public int compare(String o1, String o2) {

//charAt（0）返回索引为0的字符串

return o1.charAt(0) - o2.charAt(0);

}

});

System.out.println(lsit1);

}

基本方法的使用：

代码如下

package com.demo.main;

import java.sql.Array;

import java.util.ArrayList;

import java.util.Collections;

public class Main {

public static void main(String[] args) {

//Collections工具类的一些基本方法。

/*

* 1.sort(List<T> list, Comparator<? super T> c)：排序方法。

*   可以排序实现了Comparator的类型，如String。

*/

ArrayList<String> list = new ArrayList<>() ;

list.add("a");

list.add("f");

list.add("c");

list.add("d");

list.add("g");

Collections.sort(list);

System.out.println(list);//[a, c, d, f, g]

/*

* 2.binarySearch(List<? extends Comparable<? super T>> list, T key) :使用二叉搜索算法搜索指定对象的指定列表。

*   List<? extends Comparable<? super T> List中的类实现了Comparable,可以使用compare（）方法排序，所以使用二分查找的集合最好是有序的。

*/

//list 使用 sort（）排序之后变成了有序的了。

int index1 = Collections.binarySearch(list, "c");

System.out.println(index1);// 1 ;

int index2 = Collections.binarySearch(list,"b");

/*

* 因为Collections 与 Arrays 中的 binarySearch 是 相同的 ，在Arrays中，用二分查找查找集合中不存在的元素，最后返回的索引index的值为：-(插入位置）-1 。

* b的插入位置是在 a 后面 c的前面，所以插入位置 是 index=1 的位置，但是集合中没有b，所以返回的值为：-1-1 = -2 ，返回 -2 。

*/

//3.max（list）方法：找出集合中最大的元素 。

ArrayList<String> list1 = new ArrayList<>() ;

list1.add("a");

list1.add("f");

list1.add("c");

list1.add("d");

list1.add("g");

String maxList = Collections.max(list1);

System.out.println(maxList);//g

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

//list1 = [a f c d g]。

Collections.reverse(list1);

System.out.println(list1);//[g, d, c, f, a]

//5.static void shuffle(List<?> list) : 随机排序 。 就等于洗牌，常常用做洗扑克牌。

ArrayList<String> list2 = new ArrayList<>() ;

list2.add("a");

list2.add("g");

list2.add("d");

list2.add("c");

list2.add("f");

Collections.shuffle(list2);

System.out.println(list2);//每一次随机生成的集合元素顺序都不一样。

}

}