List集合常用API笔记大全，排序转换

1.String转类对象使用fastjson.JSON转

String转类对象使用fastjson.JSON转
方法： JSON.parseObject(“string”, ContrastModelEntryDTO.class);
场景: 当数据库字段存储是一个Json对象

public class test {
    public static void main(String[] args) {
  		 //ContrastModelEntryDTO对象
        String a = "{\"dataLength\":0,\"dataType\":0,\"entryCnName\":0,\"entryRemark\":0,\"isNull\":0,\"isTechnicalPrimaryKey\":1,\"physicalModelCnName\":0,\"physicalModelRemark\":0}";
        //1、对象JSON相互转换  JSON.parseObject
        ContrastModelEntryDTO contrastModelEntryDTO1 = JSON.parseObject(a, ContrastModelEntryDTO.class);
        System.out.println(contrastModelEntryDTO1.getIsTechnicalPrimaryKey());

        //2、集合JSON 转换  JSON.parseArray
        List<Object> arrayList = new ArrayList<>();
        //JSON转String
        String jsonString = JSON.toJSONString(arrayList);
        //String转JSON
        List<Object> objectList = JSON.parseArray(jsonString, Object.class);
}}

1.2 处理多层嵌套的JSON 字符串 new TypeReference 来解决

    					//多层嵌套的JSON 
                        String marketingExecString = (String)maps.get("marketingExecDto");
                            CouponMarketingExecDto CouponMarketingExecDto = JSON.parseObject(marketingExecString, new TypeReference<返回对象多层dto类型>() { }.getType());

2. java8 map 转List

场景：因为去重的是按照顺序，所以hashSet 不适用。由于Set的无序性，不会保持原来顺序
先根据事件ID 降序排序 ，先添加，再根据hashMap.containsKey（）方法进行判断key是否存在，筛选出最新的去重信息。
定义 map
HashMap<String, MetaDataEventTable> mapDuplicateRemoval = new HashMap<>();
map 转List：mapDuplicateRemoval.values().stream().collect(Collectors.toList());

 //mapDuplicateRemoval转list 第一张用法
 HashMap<String, MetaDataEventTable> mapDuplicateRemoval = new HashMap<>(36);
List<MetaDataEventTable> collect = new ArrayList<>(mapDuplicateRemoval.values());
 //mapDuplicateRemoval转list 第二张用法
 log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
        log.info("筛选最近一次的字段操作记录去重");
        HashMap<String, MetaDataEventTable> mapDuplicateRemoval = new HashMap<>();
        for (MetaDataEventTable metaDataEventTable : newModel) {
            if (!mapDuplicateRemoval.containsKey(metaDataEventTable.getColumnID())){
                mapDuplicateRemoval.put(metaDataEventTable.getColumnID(),metaDataEventTable);
            }
        }
        log.info("元数据事件eventId降序排序,开始比对逻辑");
        List<MetaDataEventTable> collect = mapDuplicateRemoval.values().stream().collect(Collectors.toList());

3. java8 List 转 map 排序 指定字段

指定字段a.getEventId()

 //map转List
 List<MetaDataEventTable> collect =mapDuplicateRemoval.values().stream().collect(Collectors.toList());`
 //List 排序方法
 collect.sort((a, b) -> b.getEventId().compareTo(a.getEventId()));`

4. java 8 List 转map key重复，value 不能为null (key1 , key2)-> key2 ) 如果key存在就覆盖前一个key

map 大全:https://cloud.tencent.com/developer/article/1837444

// 此写法可以去重 且 当key null 的时候不会报错空指针
Map<String, String> nmap = sdsTests.stream().collect(HashMap::new,(k, v) -> k.put(v.getName(), v.getAge()), HashMap::putAll);
System.out.println("nmap->:" + nmap.toString());

5.list 去重 根据一个字段 或者多个字段

java 8 通过某个字段去重

// xxx 表示你需要去重AddEventAndProperty的字段 列如((PhysicalEntryDraft::getEntryName)  指定对象的字段 返回已经去重集合

List<AddEventAndProperty> nameDistinct = list.stream().collect(Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(PhysicalEntryDraft::getEntryName))), ArrayList::new));

// 通过多个字段去重,返回已经去重集合 只需要修改o.id()
List<AddEventAndProperty> distinctClass = list.stream().collect(Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.id() + ";" + o.getName()))), ArrayList::new));

5.1 去重 返回 指定对象字段 类型

List<String> shopCodeList = item.stream().map(CommoditySalesItemAnalysisRespDto::getShopCode).distinct().collect(Collectors.toList());

5.2 list 分组 根据某一个对象字段

Map<String, List<DmmPhysicalModel>> collect = list.stream().collect(Collectors.groupingBy(DmmPhysicalModel::getPhysicalModelName));

list复制拷贝 注意：元对象与目标对象（属性名称必须保持一致）集合复制方式
使用：import com.alibaba.fastjson.JSON;

 //词条DTO
        List<PhysicalEntryDraftDTO> physicalEntryDraftDto = saveEntryDraftDto.getPhysicalEntryDraftList();
 //DTO 转 PO
        List<PhysicalEntryDraft> po = JSON.parseArray(JSON.toJSONString(physicalEntryDraftDto), PhysicalEntryDraft.class);

单个对象之间拷贝:

  //dto转po 源: dto   目标:PhysicalModelDraft.class
        PhysicalModelDraft po = BeanUtil.copy(dto, PhysicalModelDraft.class);

如何将元素添加到ArrayList的中间部分
在ArrayList中插入元素的索引和元素本身。如果在ArrayList.add()指定的索引处已经存在一个元素，则该元素和所有后续元素向右移动一个。
注意：（arraylist是动态数组，中间每一个插入都需要将后面的元素往后移动一个位置，效率低。推荐使用LinkedList）。

		List aList = new ArrayList();
        aList.add(0, "Apple");
        aList.add(1, "Mango");
        aList.add(2, "Banana");
        aList.add(1, "Melon");
        aList.add(2, "Guava");
        System.out.println("The ArrayList elements are: " + aList);
        //The ArrayList elements are: [Apple, Melon, Guava, Mango, Banana]

ArrayList，LinkedList，多线程场景下就不能使用ArrayList么

        //首先arrayList是 线程不安全的，数据组结构
        //优点随机查询快，擅长查询和更新，内存占用相比linkedList小
        //缺点集合中间插入和删除 效率低 因为是每次增删都需要移动后面的数组的坐标位置
        //多线程下不可以使用arrayList吗 ?
        //答案 可以 代码如下 使用Collections.synchronizedList()方法 变成线程安全 上同步锁
        ArrayList<Object> arrayList = new ArrayList<>();
        //使用包装类 线程安全
        List<Object> synchronizedList = Collections.synchronizedList(arrayList);
        //首先LinkedList是线程 不安全的，双向链表结构
        //优点插入和删除速度快 插入操作只需要修改当前元素的前后项，删除数据只需要修改指针的指向
        //缺点随机查询慢 因为是链表结构，每一次查询都要从头或者尾巴依次遍历。效率低
        //缺点内存占用相比arrayList大因为每一个元素还多存储俩个引用
        LinkedList<Object> linkedList = new LinkedList<>();
        //总结：实际开发中arrayList 使用较多，实际场景都是添加到尾部和linkedList区别不大，遍历也是使用array 支持随机查询

筛选集合中只出现一次的参数

 //筛选集合中只存在一条词条模型ER关系id（筛选ER模型id不重复）
        List<DmmEntryRelation> notRepeating = modelErIdList.stream()
                .filter(t1 -> modelErIdList.stream().filter(t2 -> t1.getModelRelationId().equals(t2.getModelRelationId())).count() <= 1)
                .collect(Collectors.toList());

筛选集合中出现大于一次的参数

        List<DmmEntryRelation> notRepeating = modelErIdList.stream()
                .filter(t1 -> modelErIdList.stream().filter(t2 -> t1.getModelRelationId().equals(t2.getModelRelationId())).count() >= 2)
                .collect(Collectors.toList());