List常用方法

排序

//正序
dayZAmplitudeVos.sort(Comparator.comparing(DayAmplitudeVo::getTm));

//倒叙
dayZAmplitudeVos.sort(Comparator.comparing(DayAmplitudeVo::getTm).reversed());

//倒排
Collections.reverse(echartList);
 
 //先顺序 再顺序
 aList.sort(Comparator.comparing(a::getNum).thenComparing(a::getTm));
 
 //先倒序 再顺序
 aList.sort(Comparator.comparing(a::getNum).reversed().thenComparing(a::getTm));
 
 //先倒叙 再倒序 
aList.sort(Comparator.comparing(a::getNum).thenComparing(a::getTm).reversed());

//先顺序 再倒序
aList.sort(Comparator.comparing(a::getNum).reversed().thenComparing(a::getTm).reversed());

//空大于非空
riverVoQSortList.sort(Comparator.comparing(RiverVo::getQ, Comparator.nullsLast(Double::compareTo)));

//空小于非空
  riverVoQSortList.sort(Comparator.comparing(RiverVo::getQ, Comparator.nullsFirst(Double::compareTo)));

分组

//跟据某个属性分组
Map<String, List<PersonData>> collect = list.stream().collect(Collectors.groupingBy(PersonData::getType));
System.out.println(collect);
  
//每位作者著作中定价最高的那本书
Map<String, Double> collect = list.stream().collect(Collectors.toMap(Book::getAuthor, Book::getPrice, BinaryOperator.maxBy(Comparator.comparingDouble(p -> (p)))));
  
  
        //根据某个属性分组，汇总某个属性
Map<String, Integer> collect2 = list.stream().collect(Collectors.groupingBy(PersonData::getType,Collectors.summingInt(PersonData::getAge)));
System.out.println(collect2);
  
//根据某个属性添加条件过滤数据，
list = list.stream().filter(u -> !u.getType().equals("访客")).collect(Collectors.toList());
System.out.println(list);
  
//判断一组对象里面有没有属性值是某个值
boolean add = list.stream().anyMatch(m -> "王五".equals(m.getName()));
System.out.println(add);
  
//取出一组对象的某个属性组成一个新集合  
List<String> names=list.stream().map(PersonData::getName).collect(Collectors.toList());
System.out.println(names);

//按name分组取按创建时间取最后一条数据，输出list
 List<Item> lastItemsPerGroup = items.stream()
            .collect(Collectors.groupingBy(Item::getName)) // 按name分组
            .values().stream() // 获取分组的值
            .map(group -> Collections.max(group, Comparator.comparing(Item::getCreateTime))) // 在每个组内取最后一条数据
            .collect(Collectors.toList()); // 转换为List

深复制

List<ExtremumYearEchartsVo> htzList=new ArrayList<>(list);

排序

1.对象顺序
htzList.sort(Comparator.comparingInt(ExtremumYearEchartsVo::getHtzranking));

移动

//替换位置
Collections.swap(list,a,b);
list是你需要换位置的List。
a是你当前需要换位置的元素的索引。
b是你需要将这个元素换到哪个位置的索引。

//替换位置
List.add(a,List.remove(b));
list是你需要换位置的List。
a是你当前需要换位置的元素的索引。
b是你需要将这个元素换到哪个位置的索引。

//移动到指定位置  后面的对象后移
test.add(0,"test0");
需要调用add插入你需要的位置，后面的自动就会像后移动

判断空

CollectionUtils.isEmpty()
例1: 判断集合是否为空:
CollectionUtils.isEmpty(null): true　　
CollectionUtils.isEmpty(new ArrayList()): true　　　　
CollectionUtils.isEmpty({a,b}): false

例2: 判断集合是否不为空:　　
CollectionUtils.isNotEmpty(null): false　　
CollectionUtils.isNotEmpty(new ArrayList()): false　　
CollectionUtils.isNotEmpty({a,b}): true

list 转 map

  Map<String,RRMeanValueVo> rrMeanValueVoMap=rrMeanValueVos.stream().collect(
                    Collectors.toMap(RRMeanValueVo::getIdtmStr, o->o));
  
 Map<String,RRMeanValueVo> rrMeanValueVoMap=rrMeanValueVos.stream().collect(
                    Collectors.toMap(RRMeanValueVo::getIdtmStr,RMeanValueVo::getTm));

去重

//根据id字段去重
List<DataModel> dataList = datas.stream().map(DataModel::getId).distinct().collect(Collectors.toList());

//根据id和name字段去重
List<DataModel> dataList = datas.stream()
                .map(t -> t.getId() + t.getName())
                .distinct().collect(Collectors.toList());

//根据id字段去重
List<DataModel> dataList = datas.stream().filter(distinctByKey(DataModel::getId)).collect(Collectors.toList());

//根据id和name字段去重
List<DataModel> dataList = datas.stream().filter(distinctByKey(t -> t.getId() + t.getName())).collect(Collectors.toList());

//通过map的putIfAbsent方式去重
//putIfAbsent : 如果所指定的 key 已经在 HashMap 中存在，返回和这个 key 值对应的 value, 如果所指定的 key 不在 HashMap 中存在，则返回 null。
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> function) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(function.apply(t), Boolean.TRUE) == null;
}

//通过id字段去重，并且返回数据按照id的asicc码升序排列
private static List<DataModel> distinct(List<DataModel> orderList) {
    Set<DataModel> set = new TreeSet<DataModel>(new Comparator<DataModel>() {
        public int compare(DataModel a, DataModel b) {
            return a.getId().compareTo(b.getId());
        }
    });
    return null;
}

//将想要去重的字段作为key，对象作为Value,以此获得去重后的对象数据
Map<Integer, DataModel> entityMap= datas.stream().collect(Collectors.toMap(t -> t.getId() + t.getName(), Function.identity());

//加入(entity1,entity2) -> entity1) 该代码代表如果出现重复的key，则用最新的数据作为值
Map<Integer, DataModel> entityMap= datas.stream().collect(Collectors.toMap(t -> t.getId() + t.getName(), Function.identity(), (entity1,entity2) -> entity2));

//获取某个字段并去重
List<String> entitySet=list.stream().map(PersonInfo::getDepartment).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());

分组求总数

Map<String, Long>groupcounts =recordList.stream()
                    .collect(Collectors.groupingBy(o->(o.getIp()+"#"+o.getAgent()),Collectors.counting()));