java----js常用的api

java对集合内的数据进行排序

        Set<MbcAddBO> apples = new TreeSet<>((o1, o2) -> o1.getFz()-o2.getFz()<0?1:-1);//升序

Collection集合体系的特点:

1. Set系列集合： 添加的元素，是无序，不重复，无索引的。
   – HashSet：添加的元素，是无序，不重复，无索引的。
   – LinkedHashSet：添加的元素，是有序，不重复，无索引的。 List系列集合：添加的元素，是有序，可重复，有索引的。
   – LinkedList： 添加的元素，是有序，可重复，有索引的。
   – ArrayList： 添加的元素，是有序，可重复，有索引的。
   – Vector 是线程安全的，速度慢，工作中很少使用。

1、List集合继承了Collection集合的全部功能，“同时因为List系列集合有索引”，
2、因为List集合多了索引，所以多了很多按照索引操作元素的功能: 3、ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！

• public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
• public E get(int index):返回集合中指定位置的元素。
• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值。
  LinkedList也是List的实现类：底层是基于双链表的，增删比较快，查询慢！！
  LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的

所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：

• public void addFirst(E e):将指定元素插入此列表的开头。
• public void addLast(E e):将指定元素添加到此列表的结尾。
• public E getFirst():返回此列表的第一个元素。
• public E getLast():返回此列表的最后一个元素。
• public E removeFirst():移除并返回此列表的第一个元素。
• public E removeLast():移除并返回此列表的最后一个元素。
• public E pop():从此列表所表示的堆栈处弹出一个元素。
• public void push(E e):将元素推入此列表所表示的堆栈。

小结：
LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
所以提供了很多操作首尾元素的特殊API可的实以做栈和队列现。

如果查询多而增删少用ArrayList集合。(用的最多的)
如果查询少而增删首尾较多用LinkedList集合。

js排序

1.方式1

export async function sort(productionPlanning) {
    let arr = productionPlanning.data
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - 1 - i; j++) {
            if (parseInt(arr[j].data.textField_bpkxwdd) > parseInt(arr[j + 1].data.textField_bpkxwdd)) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

js数组对象排序

this.inArry.sort((a, b) => {
    return b.value - a.value
})

java对象集合排序–增加简写

public class PMovieDO2 implements Comparable<PMovieDO2>{
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "id")
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
private Integer fz;
private String movid;

@Override
public int compareTo(PMovieDO2 o) {
// return this.fz-o.fz>=0?1:-1;
return o.fz-this.fz>=0?1:-1;
}
}

//数据不能超过10万

Collections.sort(linkedList);

不重复 无索引 可排序

Set<String> sets1 = new TreeSet<>(); // 不重复 无索引 可排序
sets1.add("Java");
sets1.add("Java");
sets1.add("angela");
sets1.add("黑马");
sets1.add("Java");
sets1.add("About");
sets1.add("Python");
sets1.add("UI");
sets1.add("UI");
System.out.println(sets1);

List集合排序–集合自带比较器对象进行规则定制

Set<Apple> apples = new TreeSet<>(( o1, o2) -> Double.compare(o2.getPrice() , o1.getPrice()) );

        Set<MbcAddBO> apples = new TreeSet<>((o1, o2) -> o1.getFz()-o2.getFz()<0?1:-1);//升序

执行计算机命令

Runtime runtime = Runtime.getRuntime();
System.out.println("runtime = " + runtime);
Process ipconfig = runtime.exec("ipconfig");

System.out.println("ipconfig = " + ipconfig);
InputStream inputStream = ipconfig.getInputStream();
byte[] arr = new byte[1024 * 1024 * 1000];
int b=inputStream.read(arr);
// System.out.println(new String(arr,0,b,"gbk"));
String gbk = new String(arr, 0, b, "gbk");
System.out.println("gbk = " + gbk);
inputStream.close();

注解实现sql语句查询

@Select({"<script>" +
"SELECT * FROM `p_movie` where id in " +
"<foreach item='goodsId' index='index' collection='list' open='(' separator=',' close=')'>" +
"#{goodsId}",
"</foreach>",
"</script>"})
List<PMovieDO> getGoodsList(List<String> goodsIds);

js字符串替换

str.replace(",",":")

每一个数组里面的元素拼接

arrNew.join("\r\n")

js截取指定开头和结尾,但不包括

/(?<=指定开头).*?(?=指定结尾)/
let reg=/(?<=\/\/).*?(?=:)/
var res = url.match(reg) ;

截取指定开头结尾(包头包围)，以及中间部分的内容

let matchReg = /指定开头.*?指定结尾/g
字符串.match(matchReg)

密码不自动添加

auto-complete="new-password"

el-dialog弹窗点击其他位置不会消失

:close-on-click-modal="false"

java的小数字截断

NumberUtil.round(1.22,1)
NumberUtil.roundStr(1.222,2)

limt查询LambdaQueryWrapper

.last("limit 7")

去重,时间区间,or换算成in的多条件查询

LambdaQueryWrapper<SaleplanDO> Query = new LambdaQueryWrapper<SaleplanDO>();
Query.select(SaleplanDO::getGoodsName).groupBy(SaleplanDO::getGoodsName);
Query.in(SaleplanDO::getStatus,"已出库","已通过");
Query.ge(SaleplanDO::getApprovetime,stime);
Query.le(SaleplanDO::getApprovetime,etime);

List<SaleplanDO> buyplanDOS = saleplanMapper.selectList(Query);

分组查询 new LambdaQueryWrapper

().select(DefectCodeDO::getDefectZrdw).groupBy(DefectCodeDO::getDefectZrdw)

SUM函数

select ifnull(sum(num),0)

SUM函数,会忽略NULL值，对非NULL值求和。
但需要注意的是，如果没查到数据，或字段全为NULL，则SUM函数返回NULL。为避免出现空指针，一般我们希望的是返回0

判断是否为null

StringUtils.isNotBlank("null");//当Str为空白或者null时，isNotBlank返回false,当Str的length>0时，isNotBlank返回true

查询取别名

QueryWrapper QueryWrapper = new QueryWrapper<>();
QueryWrapper.select(“sum(mould_num) as mould_num”).lambda().eq(SEndoftableDo::getCarType,“VW371”);

集合转换成数组–打印数组

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("京");
String[] array = linkedList.toArray(new String[linkedList.size()]);
System.out.println(Arrays.toString(array));
int[][]array={{1,2,3},{4,5,6}};
System.out.println(Arrays.toString(array));//打印的是地址
System.out.println(Arrays.deepToString(array));

String s = NumberUtil.roundStr((double) zxs / num * 100, 1);//小数切断

Js字符串转换json/对象转字符串json

var doublearr = JSON.stringify(result);　　//对象转换json格式字符串

var obj = JSON.parse(doublearr);　　//json格式的字符串转换成对象

Student student = JSON.parseObject(s, Student.class);//字符串转换对象
return JSON.parse(s);//json格式字符串返回前端
String toJSONString = JSON.toJSONString(linkedList1);
JSONArray jsonArray = JSONObject.parseObject(mid).getJSONArray("results");
Object image1 = JSONObject.parseObject(s1).get("backdrop_path");
String name = JSONObject.parseObject(mid).getJSONObject("belongs_to_collection").get("name").toString();
JSONArray objects = JSONObject.parseArray(data);

注解实体类返回前端的时间数据格式化.yml

jackson:
date-format: yyyy-MM-dd HH:mm:ss.SSS

==========================================

加密和解密

String encode = URLEncoder.encode(a , "UTF-8");//加密和解密
String decode = URLDecoder.decode(a, "UTF-8");//解密

分页

for (Integer i = 1; i <= (pages-pages%5)/5;i++) {
dataPage1.add(i);
}
for (Integer i = (pages-pages%5)/5+1; i <= (pages-pages%5)/52+1;i++) {
dataPage2.add(i);
}
for (Integer i = (pages-pages%5)/52+2; i <= (pages-pages%5)/53+1;i++) {
dataPage3.add(i);
}
for (Integer i = (pages-pages%5)/53+2; i <= (pages-pages%5)/54+1;i++) {
dataPage4.add(i);
}
for (Integer i = (pages-pages%5)/54+2; i <= pages;i++) {
dataPage5.add(i);
}
int flag = (int) Math.ceil((double) totalCount / 100);
for (int i = 0; i < flag; i++) {
if (network.equals(“内网”)) {
map.put(“currentPage”, i + 1);
ResponseEntity returedata2 = YdReturnData2.returedata(urlStr, token, map, “proyx”);
JSONArray data = JSONObject.parseObject(returedata2.getBody()).getJSONArray(“data”);
dataList.add(data);
} else {
map.put(“currentPage”, i + 1);
ResponseEntity returedata2 = YdReturnData2.returedata(urlStr, token, map);
JSONArray data = JSONObject.parseObject(returedata2.getBody()).getJSONArray(“data”);
dataList.add(data);
}
}
手写分页
LinkedList linkedList = new LinkedList<>();
for (int i = 0; i < 157; i++) {
linkedList.add(i);
}
int page=10;
int size1 = linkedList.size();
int cd = (int) Math.ceil((double) size1 / page);
System.out.println("cd = " + cd);
for (int i = 0; i < cd; i++) {
List integers=null;
if (i < cd-1) {
integers= linkedList.subList(10 * i, (i + 1) * page);
} else {
integers= linkedList.subList( i * page, size1);
}
System.out.println("integers = " + integers);
}
定时器案例
mounted() {
this.se()
},
beforeDestroy() {
clearInterval(this.tiem);
},

methods: {
ss() {
this.num=this.num+1;
console.log(“this.num”,this.num );
},
se() {
this.tiem=setInterval(this.ss, 2000)
},
},
//js分页和数组
let currentPage=this.currentPage
let pageSize=this.pageSize
let menuDOS=this.tableData
let ks = (currentPage - 1) * pageSize;
let js = currentPage * pageSize;
if (js > menuDOS.length()) {
js = menuDOS.length();
}
return menuDOS.slice(ks, js);
echarts的鼠标事
var chart = this.$echarts.init(document.getElementById(“main1”));
var targetvalue = val.targetdata;
// 对图表对象进行鼠标事件监听
this.chartInstance.on(‘mouseover’,()=>{
clearInterval(this.timeId)
})
this.chartInstance.on(‘mouseout’,()=>{
this.startInterval()
})

表格第一列聚合

objectSpanMethod({rowIndex, columnIndex}) {
let arry=this.allData.tableData;
if (columnIndex === 0) {
let newArr = [];
arry.forEach(() => {
newArr.push(0);
});
for (let i = 0; i < arry.length; i++) {
for (let j = 0; j < newArr.length; j++) {
if (arry[i].line == arry[j].line) {
newArr[j] = newArr[j] + 1;
}
}
}

var aIndex = 0;
for (let j = 0; j < newArr.length; j++) {
aIndex = aIndex + newArr[j];
if (j === newArr.length - 1) {
return [0, 0];
}
if (rowIndex === 0) {
return [newArr[0], 1];
}
if (rowIndex === aIndex) {
return [newArr[j + 1], 1];
}
}
}
},

js定时器–需要声明一个全局变量去接
allData() {
this.timer = setInterval(() => {
// this.getBarList();
// this.getStockList();
this.getStatus();//要执行定时的业务
}, 5000);
},
离开的时候需要销毁–
beforeDestroy() {
clearInterval(this.timer);
this.timer = null;
},
特征:
setInterval–重复执行,第一次执行会延时
setTimeout–延时执行,只执行一次
setTimeout–结合递归函数,能够模拟setInterval的重复执行
clearTimeout–清楚定时器创建的任务
js延时执行
async se() {
let timer=setTimeout(this.se2(),2000)
clearTimeout(timer)
},
async se2() {
console.log(“这里是打印123123”, );
},
js睡几秒
export function onBlur() {
setTimeout(() => { tt.call(this) }, 50);

}

@TableId(value = “id”, type = IdType.AUTO)
private Integer id;
private Integer fz;
private String movid;

@Override
public int compareTo(PMovieDO2 o) {
// return this.fz-o.fz>=0?1:-1;
return o.fz-this.fz>=0?1:-1;
}
}
//数据不能超过10万
Collections.sort(linkedList);

Set sets1 = new TreeSet<>(); // 不重复 无索引 可排序
sets1.add(“Java”);
sets1.add(“Java”);
sets1.add(“angela”);
sets1.add(“黑马”);
sets1.add(“Java”);
sets1.add(“About”);
sets1.add(“Python”);
sets1.add(“UI”);
sets1.add(“UI”);
System.out.println(sets1);
==================简写

// 方式二：集合自带比较器对象进行规则定制
//
// Set apples = new TreeSet<>(new Comparator() {
// @Override
// public int compare(Apple o1, Apple o2) {
// // return o1.getWeight() - o2.getWeight(); // 升序
// // return o2.getWeight() - o1.getWeight(); // 降序
// // 注意：浮点型建议直接使用Double.compare进行比较
// // return Double.compare(o1.getPrice() , o2.getPrice()); // 升序
// return Double.compare(o2.getPrice() , o1.getPrice()); // 降序
// }
// });

Set apples = new TreeSet<>(( o1, o2) -> Double.compare(o2.getPrice() , o1.getPrice()) );
实体类链式编程 @Accessors(chain=true)
执行计算机命令
Runtime runtime = Runtime.getRuntime();
System.out.println("runtime = " + runtime);
Process ipconfig = runtime.exec(“ipconfig”);

System.out.println("ipconfig = " + ipconfig);
InputStream inputStream = ipconfig.getInputStream();
byte[] arr = new byte[1024 * 1024 * 1000];
int b=inputStream.read(arr);
// System.out.println(new String(arr,0,b,“gbk”));
String gbk = new String(arr, 0, b, “gbk”);
System.out.println("gbk = " + gbk);
inputStream.close();

批量查询
@Select({“”})
List getGoodsList(List goodsIds);

js字符串替换str.replace(“,”,“:”)

每一个数组里面的元素拼接 　　arrNew.join(“\r\n”)

js截取指定开头和结尾,但不包括

/(?<=指定开头).?(?=指定结尾)/
let reg=/(?<=//).?(?=:)/
var res = url.match(reg) ;
一、 截取指定开头结尾(包头包围)，以及中间部分的内容
let matchReg = /指定开头.*?指定结尾/g
字符串.match(matchReg)

auto-complete=“new-password”–密码不自动添加

:close-on-click-modal=“false”–el-dialog弹窗点击其他位置不会消失
java的小数字截断
NumberUtil.round(1.22,1)
NumberUtil.roundStr(1.222,2)
limt查询LambdaQueryWrapper----.last(“limit 7”)

去重,时间区间,or换算成in的多条件查询
LambdaQueryWrapper Query = new LambdaQueryWrapper();
Query.select(SaleplanDO::getGoodsName).groupBy(SaleplanDO::getGoodsName);
Query.in(SaleplanDO::getStatus,“已出库”,“已通过”);
Query.ge(SaleplanDO::getApprovetime,stime);
Query.le(SaleplanDO::getApprovetime,etime);

List buyplanDOS = saleplanMapper.selectList(Query);
分组查询 new LambdaQueryWrapper().select(DefectCodeDO::getDefectZrdw).groupBy(DefectCodeDO::getDefectZrdw)
select ifnull(sum(num),0)–SUM函数，会忽略NULL值，对非NULL值求和。 但需要注意的是，如果没查到数据，或字段全为NULL，则SUM函数返回NULL。为避免出现空指针，一般我们希望的是返回0
StringUtils.isNotBlank(“null”);//当Str为空白或者null时，isNotBlank返回false,当Str的length>0时，isNotBlank返回true

QueryWrapper QueryWrapper = new QueryWrapper<>();
QueryWrapper.select(“sum(mould_num) as mould_num”).lambda().eq(SEndoftableDo::getCarType,“VW371”);使用聚合函数
集合转换成数组–打印数组

LinkedList linkedList = new LinkedList<>();
linkedList.add(“京”);
String[] array = linkedList.toArray(new String[linkedList.size()]);
System.out.println(Arrays.toString(array));
int[][]array={{1,2,3},{4,5,6}};
System.out.println(Arrays.toString(array));//打印的是地址
System.out.println(Arrays.deepToString(array));
String s = NumberUtil.roundStr((double) zxs / num * 100, 1);//小数切断

字符串转换json/对象转字符串json—Js
var doublearr = JSON.stringify(result);　　//对象转换json格式字符串
var obj = JSON.parse(doublearr);　　//json格式的字符串转换成对象
Student student = JSON.parseObject(s, Student.class);//字符串转换对象
return JSON.parse(s);//json格式字符串返回前端
String toJSONString = JSON.toJSONString(linkedList1);
JSONArray jsonArray = JSONObject.parseObject(mid).getJSONArray(“results”);
Object image1 = JSONObject.parseObject(s1).get(“backdrop_path”);
String name = JSONObject.parseObject(mid).getJSONObject(“belongs_to_collection”).get(“name”).toString();
JSONArray objects = JSONObject.parseArray(data);

返回前端的时间数据格式化
jackson:
date-format: yyyy-MM-dd HH:mm:ss.SSS

ArrayList arrayList = new ArrayList<>();//有序、可重复、有索引

et r3PartsNumber = new LinkedHashSet<>();//有序、不重复、有索引

List linkedList = new LinkedList<>();//有序，可重复，有索引

LinkedHashMap<String, Object> map = new LinkedHashMap();

LambdaQueryWrapper lqw = Wrappers.lambdaQuery();

Set linkedList = new LinkedHashSet<>();绝对不重复

==========================================

String encode = URLEncoder.encode(a , “UTF-8”);//加密和解密
String decode = URLDecoder.decode(a, “UTF-8”);//解密
map的for循环
map4.forEach((k, o) -> {})
分页
for (Integer i = 1; i <= (pages-pages%5)/5;i++) {
dataPage1.add(i);
}
for (Integer i = (pages-pages%5)/5+1; i <= (pages-pages%5)/52+1;i++) {
dataPage2.add(i);
}
for (Integer i = (pages-pages%5)/52+2; i <= (pages-pages%5)/53+1;i++) {
dataPage3.add(i);
}
for (Integer i = (pages-pages%5)/53+2; i <= (pages-pages%5)/54+1;i++) {
dataPage4.add(i);
}
for (Integer i = (pages-pages%5)/54+2; i <= pages;i++) {
dataPage5.add(i);
}
int flag = (int) Math.ceil((double) totalCount / 100);
for (int i = 0; i < flag; i++) {
if (network.equals(“内网”)) {
map.put(“currentPage”, i + 1);
ResponseEntity returedata2 = YdReturnData2.returedata(urlStr, token, map, “proyx”);
JSONArray data = JSONObject.parseObject(returedata2.getBody()).getJSONArray(“data”);
dataList.add(data);
} else {
map.put(“currentPage”, i + 1);
ResponseEntity returedata2 = YdReturnData2.returedata(urlStr, token, map);
JSONArray data = JSONObject.parseObject(returedata2.getBody()).getJSONArray(“data”);
dataList.add(data);
}
}
手写分页
LinkedList linkedList = new LinkedList<>();
for (int i = 0; i < 157; i++) {
linkedList.add(i);
}
int page=10;
int size1 = linkedList.size();
int cd = (int) Math.ceil((double) size1 / page);
System.out.println("cd = " + cd);
for (int i = 0; i < cd; i++) {
List integers=null;
if (i < cd-1) {
integers= linkedList.subList(10 * i, (i + 1) * page);
} else {
integers= linkedList.subList( i * page, size1);
}
System.out.println("integers = " + integers);
}
定时器案例
mounted() {
this.se()
},
beforeDestroy() {
clearInterval(this.tiem);
},

methods: {
ss() {
this.num=this.num+1;
console.log(“this.num”,this.num );
},
se() {
this.tiem=setInterval(this.ss, 2000)
},
},
//js分页和数组
let currentPage=this.currentPage
let pageSize=this.pageSize
let menuDOS=this.tableData
let ks = (currentPage - 1) * pageSize;
let js = currentPage * pageSize;
if (js > menuDOS.length()) {
js = menuDOS.length();
}
return menuDOS.slice(ks, js);
echarts的鼠标事
var chart = this.$echarts.init(document.getElementById(“main1”));
var targetvalue = val.targetdata;
// 对图表对象进行鼠标事件监听
this.chartInstance.on(‘mouseover’,()=>{
clearInterval(this.timeId)
})
this.chartInstance.on(‘mouseout’,()=>{
this.startInterval()
})

表格第一列聚合

objectSpanMethod({rowIndex, columnIndex}) {
let arry=this.allData.tableData;
if (columnIndex === 0) {
let newArr = [];
arry.forEach(() => {
newArr.push(0);
});
for (let i = 0; i < arry.length; i++) {
for (let j = 0; j < newArr.length; j++) {
if (arry[i].line == arry[j].line) {
newArr[j] = newArr[j] + 1;
}
}
}

var aIndex = 0;
for (let j = 0; j < newArr.length; j++) {
aIndex = aIndex + newArr[j];
if (j === newArr.length - 1) {
return [0, 0];
}
if (rowIndex === 0) {
return [newArr[0], 1];
}
if (rowIndex === aIndex) {
return [newArr[j + 1], 1];
}
}
}
},

js定时器–需要声明一个全局变量去接
allData() {
this.timer = setInterval(() => {
// this.getBarList();
// this.getStockList();
this.getStatus();//要执行定时的业务
}, 5000);
},
离开的时候需要销毁–
beforeDestroy() {
clearInterval(this.timer);
this.timer = null;
},
特征:
setInterval–重复执行,第一次执行会延时
setTimeout–延时执行,只执行一次
setTimeout–结合递归函数,能够模拟setInterval的重复执行
clearTimeout–清楚定时器创建的任务
js延时执行
async se() {
let timer=setTimeout(this.se2(),2000)
clearTimeout(timer)
},
async se2() {
console.log(“这里是打印123123”, );
},
js睡几秒
export function onBlur() {
setTimeout(() => { tt.call(this) }, 50);

}

实体类常用注解

实体类链式编程

@Accessors(chain=true)

重新toString

@Data

有参无参构造方法

@AllArgsConstructor
@NoArgsConstructor

映射数据库字段

@TableName("t_archive")

映射数据库中错误字段

@TableField("max")

该字段不用映射到数据库字段进行查询

@TableField(exist = false)

该字段不返回给前端

@JsonIgnore

该字段大写返回给前端

@JsonProperty(value = "Title")

版本号

@Version

检查不为null的最佳案例

优化前

    public static String getIp(){
        Object ip = getMap().get("ip");
        return ip==null?null:ip.toString();
    }

优化后

return  Optional.ofNullable(getMap().get("ip")).map(Object::toString).orElse(null)

优化前

            DropConditionTableVO dropConditionTableVO = new DropConditionTableVO();
            List<DropConditionTableVO2> questionnaire = dropConditionTableVO.getQuestionnaire();

            if (questionnaire == null) {
                questionnaire = new ArrayList<>();
            }

优化后

    Optional.ofNullable(dropConditionTableVO).map(DropConditionTableVO::getQuestionnaire).orElseGet(ArrayList::new);

时间函数

获取当前时间: DateUtil.today()

String today=DateUtil.today()

String today = “2024-02-01”;

时间偏移

往前30天

DateTime parseDateUtil.offsetDay(DateUtil.parse(DateUtil.today()), -30)

String  today =DateUtil.formatDate(DateUtil.offsetDay(DateUtil.parse(DateUtil.today()), -45));

字符换时间格式化

DateTime parse = DateUtil.parse(DateUtil.today());

String  today =DateUtil.formatDate(parse)

list转换map

优化前

        Map<String, BotTableDO> linkedHashMap = new LinkedHashMap<>();

        for (BotTableDO botTableDO : botTableDOS) {
            String id = botTableDO.getId();
            linkedHashMap.put(id, botTableDO);
        }

优化后

        Map<String, BotTableDO> linkedHashMap = botTableDOS.stream()
                .collect(Collectors.toMap(BotTableDO::getId, botTableDO -> botTableDO, (existing, replacement) -> existing, LinkedHashMap::new));

list转换分组map

优化前

        Map<String, List<TemplateDeductionEntity2>> hashMap = new HashMap<>();
        for (TemplateDeductionEntity2 templateDeductionEntity2 : templateDeductionEntity2s) {
            String week = templateDeductionEntity2.getWeek()+"";
            List<TemplateDeductionEntity2> templateDeductionEntity2s1 = hashMap.get(week);
            if (templateDeductionEntity2s1==null){
                templateDeductionEntity2s1=new ArrayList<>();
            }
            templateDeductionEntity2s1.add(templateDeductionEntity2);
        }

优化后

        Map<String, List<TemplateDeductionEntity2>> hashMap = templateDeductionEntity2s.stream()
            .collect(Collectors.groupingBy(
                templateDeductionEntity2 -> templateDeductionEntity2.getWeek() + "",
                HashMap::new,
                Collectors.toList()
            ));

map.computeIfAbsent添加list

postIdMap.computeIfAbsent(dingDaykey.getPostId(), k -> new LinkedList<>()).add(dingDaykey);

优化前

DayEntity dayEntity = lkeyMap.get(line);
if (dayEntity == null) {
    dayEntity = new DayEntity();
}
dayEntity.setName(line);

优化后

DayEntity dayEntity = lkeyMap.computeIfAbsent(line, DayEntity::new);

优化前

            List<DataListMxfEntity> data = dayEntity.getData();
            if (data == null) {
                data = new ArrayList<>();
            }

优化后

List<DataListMxfEntity> data = Optional.ofNullable(dayEntity.getData()).orElseGet(ArrayList::new);

优化前

            List<AgvSg03PsPlcItemHistoryDO> agvSg03PsPlcItemHistoryDOS1 = batteryIdMapList.get(batteryId);
            if (agvSg03PsPlcItemHistoryDOS1 == null) {
                agvSg03PsPlcItemHistoryDOS1 = new ArrayList<>();
            }

优化后

            List<AgvSg03PsPlcItemHistoryDO> agvSg03PsPlcItemHistoryDOS1 = Optional.ofNullable(batteryIdMapList.get(batteryId))
                    .orElseGet(ArrayList::new);

相对路径的api

        String fileName = "1.json";
        String currentFilePath = new Object(){}.getClass().getEnclosingClass().getResource("").getPath()+fileName;
        String substring = currentFilePath.replaceAll("target/test-classes", "src/test/java").substring(1);
        String jsonPath = substring;
        System.out.println("jsonPath = " + jsonPath);

控制台输出:
jsonPath = D:/desktop/xiangmu/doc_translation/src/test/java/com/example/dxw/1.json