stream常用操作

获取ID

List<String> idList = organs.stream().map(IBaseOrgan::getId).collect(Collectors.toList());

根据字段分组

Map<String, List<LptNavTree>> map =
                tree.stream().collect(Collectors.groupingBy(LptNavTree::getPlatformKey));
        List<LptNavTree> treeData = Lists.newArrayList();

        for (Map.Entry<String, List<LptNavTree>> entry : map.entrySet()) {
            LptNavTree data = new LptNavTree();
            data.setId(entry.getKey());
            data.setName(convertKey(entry.getKey()));
            data.setOpen(true);
            data.setChildren(entry.getValue());
            treeData.add(data);
        }

获取重复数据

        List<String> uniqueList = tree.stream().collect(Collectors.groupingBy(LptNavTree::getName, Collectors.counting()))
                .entrySet().stream().filter(e -> e.getValue() > 1)
                .map(Map.Entry::getKey).collect(Collectors.toList());

数据去重

List<LptNavTree> unique = tree.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(LptNavTree::getName))), ArrayList::new));
        
        

两个List，一个LIST根据另一个list取交集

        List<LptNavTree> intersectA = tree
                .stream() //获取第一个集合的Stream1
                .filter(  //取出Stream1中符合条件的元素组成新的Stream2，lambda表达式1返回值为true时为符合条件
                        a ->  //lambda表达式1，a为lambda表达式1的参数，是Stream1中的每个元素
                                repeatList.stream() //获取第二个集合的Stream3
                                        .map(LptNavTree::getName) //将第二个集合每个元素的id属性取出来，映射成新的一个Stream4
                                        .anyMatch( //返回值（boolean）：Stream4中是否至少有一个元素使lambda表达式2返回值为true
                                                name -> //lambda表达式2，id为lambda表达式2的参数，是Stream4中的每个元素
                                                        Objects.equals(a.getName(), name) //判断name的值是否相等
                                        )
                )
                .collect(Collectors.toList()); //将Stream2转换为List

两个List，一个LIST根据另一个list取差集

        List<LptNavTree> differenceB = tree.stream().filter(b -> repeatList.stream().map(LptNavTree::getName).noneMatch(id -> Objects.equals(b.getId(), id))).collect(Collectors.toList());

下标交换

import java.util.*;
 
 
public class TestAa {
 
    private String name;
 
    private Integer id;
 
    public static void main(String[] args) {
        List<TestAa> list = new ArrayList<>();
        list.add(new TestAa("a", 1));
        list.add(new TestAa("b", 2));
        list.add(new TestAa("c", 3));
        list.add(new TestAa("d", 4));
 
        String name = "a";
        //找到name=德华的第一个对象的下标
        Optional<Integer> first = list.stream().
                filter(i -> Objects.equals(i.getName(), name)).
                map(list::indexOf).findFirst();
        if (first.isPresent()) {
            Integer index = first.get();
            System.out.println("true：" + index);
            //下标数据交换
            Collections.swap(list, 0, index);
        } else {
            System.out.println("false");
        }
        list.forEach(System.out::println);
    }
 
    public TestAa(String name, Integer id) {
        this.name = name;
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    @Override
    public String toString() {
        return "TestAa{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

list集合根据某一元素获取上一个、下一个、第一个、最后一个

说明：

1.NutMap = Map;

2.本文是用List<Map>来实现的,若使用List<T> 或者 List<String> 等原理是一样的；

3.大致思路就是先把所有的数据查询出来，根据某一个元素（或元素里某个唯一属性）来获取当前的下标，利用下标加减来实现。

4.本文仅适用部分场景，数据量太大的话自行处理.(建议使用rowid)

5.stream 好像有自带获取前一个、后一个、下标的方法，感兴趣的请自行查阅

6.数据库Mysql (其实哪种库都一样，反正用的是结果集合，纯属凑字数)
 

  public NutMap listOrder(List<NutMap> listMaps,String nowId){
        // 查询第一个,上一个,下一个,最后一个ID
        String firstId = "";
        String prevId = "";
        String nextId = "";
        String lastId = "";
 
        if(Lang.isEmpty(listMaps)){
            return NutMap.NEW();
        }
        // 当前记录的下标
        int index = 0;
        for (int i = 0; i < listMaps.size(); i++) {
            NutMap billMap = listMaps.get(i);
            if(billMap.getString("id").equals(nowId)){
                index = i;
                break;
            }
        }
 
        firstId = listMaps.get(0).getString("id");
        lastId = listMaps.get(listMaps.size() - 1).getString("id");
        if(index > 0){
            prevId = listMaps.get(index-1).getString("id");
        }
 
        if(index + 1 < listMaps.size()){
            nextId = listMaps.get(index+1).getString("id");
        }
 
        // 第一个值与当前值相同, 把第一个的值和上一个的值置空 (根据需求灵活变动)
        if(firstId.equals(nowId)){
            firstId = "";
            prevId = "";
        }
        // 最后一个值与当前值相同, 把最后一个的值和下一个的值置空 (根据需求灵活变动)
        if(lastId.equals(nowId)){
            nextId = "";
            lastId = "";
        }
        return NutMap.NEW().addv("firstId",firstId).addv("prevId",prevId)
                .addv("nextId",nextId).addv("lastId",lastId);

JS将某元素置顶

meKey.unshift(meKey.splice(meKey.findIndex((item) => item === 'wdgzpt') , 1)[0]);