Collections
1.sort(Comparator<? super E>):void List 对集合中的元素排序：
2.reverse(List<?>):void 反转集合中的元素：
3.shuffle(List<?>):void 打乱元素中的元素：
4.fill(List<? super T>,T):void 用T元素替换掉集合中的所有的元素：
5.copy(List<? super T>,List<? extend T>):void 复制并覆盖相应索引的元素:
6.min/max(Collection<? extends T>):T 找到集合中最大/小的元素:
7.swap(List<?>,int,int):void 交换集合中指定元素索引的位置:
8.rotate(List<?>,int):void 集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来.
9.indexOfSubList(List<?>,List<?>):int / lastIndexOfSubList(List<?>,List<?>):int 找出参数2在参数1第一次出现的位置：
10.replaceAll(List,T,T):boolean 替换成指定的元素：
11.synchronizedXxx方法 可以将某集合转化成线程安全的容器之后再使用：
12.unmodifiableCollection(Collection<? extends T>):Collection将集合变为不可修改：
Guava
依赖
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1.1-jre</version>
</dependency>
1.BiMap提供了一种key和value双向关联的数据结构2.Multimap提供了将一个键映射到多个值的形式
3.RangeMap描述了一种从区间到特定值的映射关系，让我们能够以更为优雅的方法来书写代码
4.ClassToInstanceMap是一个比较特殊的Map，它的键是Class，而值是这个Class对应的实例对象
5.Joiner指定分隔符关联集合，可以过滤空值
6.Splitter可以对字符串进行分割，其分割的方式有两种——按字符/字符串分割和按正则进行分割，结果是集合
?
Hutool
依赖
<dependency>
? ? <groupId>cn.hutool</groupId>
? ? <artifactId>hutool-all</artifactId>
? ? <version>4.5.15</version>
</dependency>?
MapUtil，针对Map的一一列工具方法的封装
.isEmpty、isNotEmpty 判断Map为空和非空方法，空的定义为null或没有值
.newHashMap 快速创建多种类型的HashMap实例
.createMap 创建自定义的Map类型的Map
.of 此方法将一个或多个键值对加入到一个新建的Map中
.toListMap 行转列，合并相同的键，值合并为列表
.toMapList 列转行。将Map中值列表分别按照其位置与key组成新的map
.join、joinIgnoreNull 将Map按照给定的分隔符转换为字符串
.filter 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃 2、修改元素对象，返回集合中为修改后的对象
.reverse Map的键和值互换
.sort 排序Map
.getAny 获取Map的部分key生成新的Map
.get、getXXX 获取Map中指定类型的值集合工具-CollUtil
1. join 方法 将集合转换为字符串
2. sortPageAll 将给定的多个集合放到一个列表（List）中，根据给定的Comparator对象排序，然后分页取数据
3.newHashMap、newHashSet、newArrayList方法 这些方法是新建相应的数据结构
4.sub方法 对集合切片，其他类型的集合会转换成List
5.zip方法 给定两个集合，然后两个集合中的元素一一对应
常用操作
1.8以前map操作
按照value排序
// Map的value值降序排序
public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
int compare = (o1.getValue()).compareTo(o2.getValue());
return -compare;
}
});
Map<K, V> returnMap = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
returnMap.put(entry.getKey(), entry.getValue());
}
return returnMap;
}
// Map的value值升序排序
public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
int compare = (o1.getValue()).compareTo(o2.getValue());
return compare;
}
});
Map<K, V> returnMap = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
returnMap.put(entry.getKey(), entry.getValue());
}
return returnMap;
}
/**
* 利用Collections.sort 对map排序
*/
public void testSort(){
List<Map.Entry<String, Integer>> res = new ArrayList();
Map<String,Integer> map=new HashMap<>();
for(Map.Entry<String, Integer> entry : map.entrySet()) {
res.add(entry);
}
Collections.sort(res, new Comparator<Map.Entry<String, Integer>>(){
public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
if(e2.getValue() != e1.getValue()) {
return e1.getValue() - e2.getValue();
} else {
return e1.getKey().compareTo(e2.getKey());
}
}
});
}
// map截取
public static <K, V extends Comparable<? super V>> Map<K, V> subMap(Map<K, V> map,int subN) {
Map<K, V> returnMap = new LinkedHashMap<K, V>();
int i=0;
for (Map.Entry<K, V> entry : map.entrySet()) {
if(++i>subN){
break;
}
returnMap.put(entry.getKey(),entry.getValue());
}
return returnMap;
}
按照key排序
public static void main(String[] args) {
TreeMap<Student2,String> treeMap = new TreeMap<>(new Comparator<Student2>() {
@Override
public int compare(Student2 o1, Student2 o2) {
// 基本和key实现Comparable接口，重写compareTo方法一致
// 升序排序就是这么写的
if(o1.getAge() > o2.getAge()){
return 1;
}else if(o1.getAge() < o2.getAge()){
return -1;
}
// 相等的时候不能返回0
return o1.getAge();
}
});
treeMap.put(new Student2("大哥",24),"大哥");
treeMap.put(new Student2("二哥",23),"二哥");
treeMap.put(new Student2("三哥",22),"三哥");
treeMap.put(new Student2("四哥",21),"四哥");
Set<Student2> studentSet = treeMap.keySet();
for (Student2 student : studentSet) {
System.out.println(student.toString());
}
}
1.8以后对map排序
import com.alibaba.fastjson.JSON;
import java.util.*;
import java.util.stream.Collectors;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ) {
Map<String,Integer> mapRepeat = new HashMap<>();
mapRepeat.put("aa", 1);
mapRepeat.put("bb", 45);
mapRepeat.put("cc", 32);
mapRepeat.put("dd", 226);
mapRepeat.put("ee", 16);
mapRepeat.put("ff", 320);
mapRepeat.put("gg", 99);
// 1.8以后 使用lambda表达式和Stream处理
// 1.对Map的value进行降序排序，并取前5个key
List<String> mobileList = mapRepeat.entrySet().stream()
.sorted((Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) -> e2.getValue() - e1.getValue())
.map(entry -> entry.getKey()).collect(Collectors.toList())
.subList(0, 5);
System.out.println(JSON.toJSONString(mobileList));
// 2、正向对Map的value排序并将结果输出到LinkedHashMap
final Map<String, Integer> sortedByCount1 = mapRepeat.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
System.out.println(JSON.toJSONString(sortedByCount1));
// 3、反向 reversed对Map的value排序并将结果输出到LinkedHashMap
final Map<String, Integer> sortedByCount2 = mapRepeat.entrySet()
.stream()
.sorted((Map.Entry.<String, Integer>comparingByValue().reversed()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
System.out.println(JSON.toJSONString(sortedByCount2));
// 4.正向 Comparator 对Map的value排序并将结果输出到LinkedHashMap
final Map<String, Integer> sortedByCount3 = mapRepeat.entrySet()
.stream()
.sorted((e1, e2) -> e1.getValue().compareTo(e2.getValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
System.out.println(JSON.toJSONString(sortedByCount3));
//反向 Comparator 对Map的value排序并将结果输出到LinkedHashMap
final Map<String, Integer> sortedByCount4 = mapRepeat.entrySet()
.stream()
.sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
System.out.println(JSON.toJSONString(sortedByCount4));
// 1.8以前
List<Map.Entry<String, Integer>> list1 = new ArrayList<>();
list1.addAll(mapRepeat.entrySet());
Collections.sort(list1, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
return o1.getValue() - o2.getValue();
}
});
for (Map.Entry<String, Integer> entry : list1) {
System.out.println("key:" + entry.getKey() + ",value:" + entry.getValue());
}
}
}List操作
/**
* 将一组数据固定分组，每组n个元素
* @param source 要分组的数据源
* @param n 每组n个元素
* @param <T>
* @return
*/
public static <T> List<List<T>> fixedGrouping(List<T> source, int n) {
if (null == source || source.size() == 0 || n <= 0)
return null;
List<List<T>> result = new ArrayList<List<T>>();
int sourceSize = source.size();
int size = (source.size() / n) + 1;
for (int i = 0; i < size; i++) {
List<T> subset = new ArrayList<T>();
for (int j = i * n; j < (i + 1) * n; j++) {
if (j < sourceSize) {
subset.add(source.get(j));
}
}
result.add(subset);
}
return result;
}
/**
* 将一组数据平均分成n组
*
* @param source 要分组的数据源
* @param n 平均分成n组
* @param <T>
* @return
*/
public static <T> List<List<T>> averageAssign(List<T> source, int n) {
List<List<T>> result = new ArrayList<List<T>>();
int remainder = source.size() % n; //(先计算出余数)
int number = source.size() / n; //然后是商
int offset = 0;//偏移量
for (int i = 0; i < n; i++) {
List<T> value = null;
if (remainder > 0) {
value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
remainder--;
offset++;
} else {
value = source.subList(i * number + offset, (i + 1) * number + offset);
}
result.add(value);
}
return result;
}
来源
Guava 中 Map 的骚操作 - Nihaorz - 博客园
Java中的Collections类(工具类)十二大常用方法总结 - 47号Gamer丶 - 博客园
Guava之Maps教程_梦想画家的博客-CSDN博客_guava map
JAVA 对Map里的value值进行排序(升序或者降序);_花伦同学ko的博客-CSDN博客_map value排序?JAVA实现数据等分，一个List分成多个List_越努力越幸福的博客-CSDN博客_list分成多个list
Java8 对Map(key/value)排序后取TopN_天～嘿的博客-CSDN博客_map取top5
?
