日常开发中代码技巧（个人使用）

news/2024/11/24 9:46:26/

日常开发中代码技巧

String，StringBuffer判断非空

  • String判断非空

    参考：https://blog.csdn.net/Echo_width/article/details/79653704

    首先，区分空串和null串

    • 1 空串""是长度为0的字符串，它有自己的串长度（0）和内容（空），判断一个字符串为空的方法：

      //
if (str.length() == 0);
//变式
if (str.equals(""));

    • 2、 null串表示目前没有任何对象与该变量关联，检查一个字符串是否为null的方法：

       if (str == null);

    • 3、检查一个字符串既不是null串也不是空串，多用以下方法判断：

      if (str != null && str.length() != 0);

      注意：要先检查str不为null，否则在一个null值上调length()方法会出现错误。

    • 4、使用StringUtils工具类，判断不为null也不是空，如下：

      if (StringUtils.isNotBlank(str))

  • StringBuffer判断非空

    很简单，一种是利用StringBuffer的length()判断，另一种事转换为String判断

    //1.
if(stringBuffer.length() > 0){System.out.println("非空")
}
//2.

List转数组和数组转List

List转换为数组

很简单 一句话就解决了 主要有两种方法 这两种方法本质上是一样的 只不过是写法不同而已

  1. 使用Stream

    String[] ss = list.stream().toArray(String[]::new);

  2. 使用List中的toArray()方法

    String[] sss = list.toArray(new String[listStrings.size()]);

举个实例：

 public void listTransArrayTest() {//先初始化集合List<Seckill> seckillList = new ArrayList<>(15);Date time = new Date(System.currentTimeMillis());long seckillId = 1001l;System.out.println("=========集合转换为数组===========");for (int i = 0; i <= 10; i++) {Seckill seckill = new Seckill(seckillId, "秒杀" + i, i, time, time, time);seckillList.add(seckill);seckillId++;}//转换方式1
//        Seckill[] result = seckillList.toArray(new Seckill[seckillList.size()]);//转换方式2 使用jdk1.8的stream流Seckill[] result = seckillList.stream().toArray(Seckill[]::new);System.out.println("转换成功 开始显示转换后的数组");for (Seckill seckill : result) {System.out.println(seckill);}

数组转换为List

这里有一个坑 等下再详细说

可能很多人都会直接想到下面这种方法

        String[] arrays = new String[]{"a", "b", "c"};List<String> listStrings = Arrays.asList(arrays);

但是这里有两个坑

  • 一是asList转换的是基本类型的数组的话，如int[] 转换失败 转换后的集合只有一个元素；

  • 二是asList转换后的集合不能add和remove的 因为asList转换后的集合类型并不是java.util.ArrayList，而是Arrays的一个内部类，这个内部类并没有add方法。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
    在这里插入图片描述

    这个内部类的方法及属性如下。可以看到并没有add(),remove()。而set(int index,E element)修改方法但是有

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
    在这里插入图片描述

如果你想转换后的list可以add或者remove，那就使用下面的方法：

/*方法一*/
ArrayList<Integer> copyArrays=new ArrayList<>(Arrays.asList(integerArray));/*方法二*/
List<Integer> integerList = new ArrayList<>();
Collections.addAll(integerList, integerArray);

参考博客：https://blog.csdn.net/weixin_41835612/article/details/83611082

位运算的实用技巧

1. 求奇数偶数

(n&1) == 0 这个表示偶数

2. 交换两个数

a ^= b;
b ^= a;
a ^= b;

参考博客：https://blog.yangx.site/2016/07/06/bit-operation-skills/ 或者到印象笔记那找

位进制转换

  1. 16进制转10进制

    Integer.parseInt("0xAA".substring(2));

  2. 10进制 转16进制

    Integer.toHexString(56);

mybatis的时间类型数据转换问题

字符串常见操作

按照某些字符进行分割截取

比如按照空格进行分割，StringUtils中封装了很多截取操作

mysql相关操作

主要是将平时遇到的有用的sql语句记录下来

比较两个select结果集中不一样的数据

比如我现在有两个

使用instr和concat完成模糊查询

使用INSTR和concat可以完成模糊查询，主要的作用是用于查询那种字段中有特殊字符分隔开值的，比如username中多个名字之间用，分割开。当然使用like也可以，只不过这也是一种方式。

下面是这两个函数的定义

INSTR

INSTR()函数返回字符串中子字符串第一次出现的位置。如果在str中找不到子字符串，则INSTR()函数返回零(0)。

下面说明了INSTR函数的语法。

INSTR(str,substr);

INSTR函数接受两个参数：

  • str是要搜索的字符串。
  • substr是要搜索的子字符串。

INSTR()函数不区分大小写。这意味着如果通过小写，大写，标题大小写等，结果总是一样的。

CONCAT：

连接字符串的函数

使用方式

  and  INSTR(CONCAT(',',#{reqid},','),CONCAT(",",t1.linkreqid,","))

springboot下的文件下载功能

https://blog.csdn.net/qq_15329947/article/details/100894906#commentBox

这是原文：https://www.callicoder.com/spring-boot-file-upload-download-rest-api-example/（原文中除了下载功能还有上传功能）

List.sort(Compareable compa)

背景：

有时候有一些比较复杂的排序方法我们不好用stream流的方式 只好用

流

数据库操作

将查询结果的某一列作为条件

当你使用下面的语句时会报错

delete FROM sys_xm_role where xmroleid in (select a.xmroleid from (select xmroleid,usernamefrom sys_xm_role group by projid,roleid HAVING COUNT(projid) >1 and COUNT(roleid)  > 1)a				
)

报错信息:You can’t specify target table ‘sys_xm_role’ for update in FROM clause

在这里插入图片描述

正确的做法是：

delete FROM sys_xm_role where xmroleid in (select a.xmroleid from (select xmroleidfrom sys_xm_role group by projid,roleid HAVING COUNT(projid) >1 and COUNT(roleid)  > 1)a)

集合的相关操作

参考：https://blog.csdn.net/qq_41902662/article/details/113843735

集合倒序输出

最简单的是这个

Collections.reverse(vsImVos);

这个排序的依据是集合里对象本身

这个应该是需要对象实现compare接口，或者要么就实现.equal方法

HashMap的遍历

很多种方式 但是还是Entry.entry最快速并且安全

java 8 stream：去重,排序,筛选,分组,聚合计算

流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算

  • 测试对象和数据
/*** @Description   :  stream流测试对象*/
//允许链式set
@Accessors(chain = true)
@Data
public class StreamDto {private String name;private String addr;private Integer age;private Date birthDay;private BigDecimal money;public StreamDto(String name, String addr, Integer age, Date birthDay, BigDecimal money) {this.name = name;this.addr = addr;this.age = age;this.birthDay = birthDay;this.money = money;}public StreamDto() {}
}StreamDto d1 = new StreamDto();d1.setName("a").setAddr("北京").setAge(20).setBirthDay(DateUtil.parse("2020-10-12")).setMoney(new BigDecimal(3));StreamDto d2 = new StreamDto();d2.setName("a").setAddr("南京").setAge(12).setBirthDay(DateUtil.parse("2020-10-13")).setMoney(new BigDecimal(1));StreamDto d3 = new StreamDto();d3.setName("b").setAddr("北京").setAge(23).setBirthDay(DateUtil.parse("2020-10-11")).setMoney(new BigDecimal(2));List<StreamDto> list = CollUtil.toList(d1,d2,d3);System.out.println("原始List=="+list.toString());

List排序

  • 不用stream 排序

      //age升序list.sort(Comparator.comparing(StreamDto::getAge));//age降序list.sort(Comparator.comparing(StreamDto::getAge).reversed());//正序排序，并将null放在最后(搭配reversed()就变成倒序):小->大->nulllist.sort(Comparator.comparing(StreamDto::getBirthday, Comparator.nullsLast(Date::compareTo)));//先正序排序，并将null放在最前，搭配reversed()翻转就变成倒序：大->小->nulllist.sort(Comparator.comparing(StreamDto::getBirthday, Comparator.nullsFirst(Date::compareTo)).reversed());//先后排序list.sort(Comparator.comparing(StreamDto::getAge).reversed().thenComparing(Comparator.comparing(StreamDto::getName).reversed()).thenComparing(Comparator.comparing(StreamDto::getAddr).reversed()));

  • 使用stream

        //age升序List<StreamDto> l1 = list.stream().sorted(Comparator.comparing(StreamDto::getAge)).collect(Collectors.toList());//age降序l1 = list.stream().sorted(Comparator.comparing(StreamDto::getAge).reversed()).collect(Collectors.toList());//正序排序，并将null放在最后(搭配reversed()就变成倒序):小->大->nulll2 = list.stream().sorted(Comparator.comparing(StreamDto::getBirthday, Comparator.nullsLast(Date::compareTo))).collect(Collectors.toList());//先正序排序，并将null放在最前，搭配reversed()翻转就变成倒序：大->小->nulll3 = list.stream().sorted(Comparator.comparing(StreamDto::getBirthday, Comparator.nullsFirst(Date::compareTo)).reversed()).collect(Collectors.toList());

List 聚合计算

//包含了: 计数,最大,最小,求和,平均数, 每种方式都有单独的方式实现
DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(StreamDto::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",min=:" + statistics.getMin() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
//count:3,max:23.0,min=:12.0,sum:55.0,average:18.333333333333332//计数:
long count = list.stream().count();//3//最大/最小,两种方式:
//sorted: 先按年龄降序排列后取第一个,同理最小则升序取第一
Integer max = list.stream().sorted(Comparator.comparing(StreamDto::getAge).reversed()).map(StreamDto::getAge).findFirst().get();
System.out.println("max = " + max);
//min/max
Integer min = list.stream().min(Comparator.comparing(StreamDto::getAge)).get().getAge();
System.out.println("min = " + min);//求和
Integer sum1 = list.stream().collect(Collectors.summingInt(StreamDto::getAge));
Integer sum2 = list.stream().map(StreamDto::getAge).reduce(Integer::sum).get();//平均数
Double collect2 = list.stream().collect(Collectors.averagingInt(StreamDto::getAge));
double asDouble = list.stream().mapToLong(StreamDto::getAge).average().getAsDouble();
double asDouble1 = list.stream().mapToInt(StreamDto::getAge).average().getAsDouble();
//...

List条件筛选

    List<StreamDto> l1 = null;//条件筛选l1 = list.stream().filter(b -> b.getAge() > 15).collect(Collectors.toList());//多条件l1 = list.stream().filter(b -> DateUtil.compare(new Date(),b.getBirthDay()) > 0&& b.getAge() < 15 ).collect(Collectors.toList());l1 = list.stream().filter(b -> b.getMoney().compareTo(new BigDecimal(2)) > -1).collect(Collectors.toList());

List 分组

    //name分组Map<String,List<StreamDto>> map = list.stream().collect(Collectors.groupingBy(StreamDto::getName));//二级分组Map<String,Map<Integer,List<StreamDto>>> map1 = list.stream().collect(Collectors.groupingBy(StreamDto::getName,Collectors.groupingBy(StreamDto::getAge)));//二级分组,统计数量Map<String,Map<Integer,Long>> map2 = list.stream().collect(Collectors.groupingBy(StreamDto::getName,Collectors.groupingBy(StreamDto::getAge,Collectors.counting())));//多条件分组map = list.stream().collect(Collectors.groupingBy(b -> b.getName() + "-" + b.getAge()));//分组后又对集合进行处理,方式1Map<String,List<String>> map3 = list.stream().collect(Collectors.groupingBy(StreamDto::getName,Collectors.groupingBy(StreamDto::getAge,Collectors.mapping(StreamDto::getAddr, Collectors.toList()))));//方式2，只是拓展，不推荐map3 = list.stream().collect(Collectors.groupingBy(StreamDto::getName)).entrySet().stream().collect(Collectors.toMap(b -> b.getKey(), b -> CollUtil.map(b.getValue(), StreamDto::getAddr, true)));// 按照某列出现的次数分组

List去重

    //根据Addr去重List<StreamDto> list1 = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(StreamDto::getAddr))), ArrayList::new));//简单去重list1 = list.stream().distinct().collect(Collectors.toList());

List 转map

   Map<String, Date> m = list.stream().collect(Collectors.toMap(b -> b.getName(), b -> b.getBirthDay()));Map<String, StreamDto> collect3 = list.stream().collect(Collectors.toMap(b -> b.getName(), b -> b));

返回自封装的List实现类

//封装的List实现,用于链式添加:addObj()和addObjs()
ArrayListProxy<String> allPlatNames = new ArrayListProxy<>();
allPlatNames.addObjs(bidSecPlats).addObjs(projPlats);
//去重,这里要返回ArrayListProxy必须自己实现,collect(Collectors.toList())只能返回List,allPlatNames接收不了
allPlatNames = allPlatNames.stream().distinct().collect(ArrayListProxy::new, (r, x) -> {r.addObj(x);}, List::addAll);

集合合并返回新集合

List<String> list1 = CollUtil.toList("1");
List<String> list2 = CollUtil.toList("2");
List<List<String>> all = CollUtil.toList(list1, list2);/**
*	第一种方式
*/
ArrayList<String> collect = all.stream().collect(ArrayList::new, (list, value) -> list.addAll(value), List::addAll);
//或者
//串行流：第一个元素时会通过ArrayList::new获得一个初始化容器a，容器a执行ArrayList::addAll方法操作流中的每一个元素，最后返回容器a，最后容器a就只有一个，所以不会用到List::addAll
ArrayList<String> collect = all.stream().collect(ArrayList::new, ArrayList::addAll, List::addAll);
//并行流：将all中的元素分片处理，每片中第一个元素时会通过ArrayList::new获得一个初始化容器a，
//容器a执行ArrayList::addAll方法操作流中的每一个元素，每片最后会返回容器a，最后多个容器a通过List::addAll方法合并后输出
ArrayList<String> collect = all.parallelStream().collect(ArrayList::new, ArrayList::addAll, List::addAll);/**
*	第二种方式
* 	reduce
*/
//new ArrayList<>() 作为初始值加入计算
List<String> reduce = all.stream().reduce(CollUtil.toList("3"), (b, c) -> {b.addAll(c);return b;});//返回["3","1","2"]
//不添加初始值计算
Optional<List<String>> reduce = all.stream().reduce((b, c) -> {b.addAll(c);return b;});//返回["1","2"]

Map转换

//假设有数据
Map<String, List<StreamDto>> map = new HashMap<>();
//取出key和集合中第一个对象的时间参数
Map<String, Date> m = map.entrySet().stream().collect(Collectors.toMap(b -> b.getKey(), b -> b.getValue().get(0).getBirthDay()));

Map排序

//前5名
Map<String, Long> top5Names = new LinkedHashMap<>();
//假设有数据
List<String> mainQ = new ArrayList<>();
//分组后统计数量
Map<String, Long> countMap = mainQ.stream().collect(Collectors.groupingBy(b -> b, Collectors.counting()));
//value排序,然后取出前5名
countMap.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).forEachOrdered(b -> {if (top5Names.size() < 6) {top5Names.put(b.getKey(), b.getValue());}
});
//取出全部
Map<String, Long> allMap = countMap.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> newValue, 		      					LinkedHashMap::new));
//key排序
countMap.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByKey().reversed());

Map过滤

//假设有数据
List<String> mainQ = new ArrayList<>();
Map<String, Long> countMap = mainQ.stream().collect(Collectors.groupingBy(b -> b, Collectors.counting()));
//map过滤
countMap.entrySet().stream().filter(b -> b.getKey() != "").collect(HashMap::new, (m, e) -> m.put(e.getKey(), e.getValue()), HashMap::putAll);

Map合并

/*** @Description: 合并两个map,如果key相同,那么选取时间靠后的value */
public static Map<String, Date> concatMap(Map<String, Date> map1, Map<String, Date> map2) {Map<String, Date> result = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (value1, value2) -> {if (DateUtil.compare(value1, value2) >= 0) {return value1;} else {return value2;}}));return result;
}

Map遍历

/*** 遍历Map的方式*/
Map<String,List<ResOrgUserDto>> map =new HashMap<>();
//1.通过Map.keySet遍历key和value
for (String key : map.keySet()) {System.out.println(map.get(key));
}
//Java8
map.keySet().forEach(k -> {System.out.println(map.get(k));
});//2.通过Map.entrySet使用Iterator遍历key和value
while (map.entrySet().iterator().hasNext()){Map.Entry<String,List<ResOrgUserDto>> entry = map.entrySet().iterator().next();System.out.println(entry.getValue());
}
//Java8
map.entrySet().iterator().forEachRemaining(m -> System.out.println(m.getValue()));//3.通过Map.entrySet遍历key和value，在大容量时推荐使用
for (Map.Entry<String, List<ResOrgUserDto>> entry : map.entrySet()) {System.out.println(entry.getValue());
}
//Java8
map.entrySet().forEach(entry -> {System.out.println(entry.getValue());
});//4.通过Map.values()遍历所有的value，但不能遍历key
for (List<ResOrgUserDto> values : map.values()) {System.out.println(values);
}
//Java8
map.values().forEach(v -> {System.out.println(v);
});//5.通过k,v遍历，Java8独有的
map.forEach((k,v) -> {System.out.println(v);
});

List,Map综合

//前5名名称
List<String> names = top5Names.entrySet().stream().map(b -> b.getKey()).collect(Collectors.toList());
//获取各表前五名平台的最后数据接收时间
Map<String, Date> bidSecLasts = bidSecQ.stream().filter(b -> names.contains(b.getTradeplat()))//筛选出前5的数据.sorted(Comparator.comparing(BusBidsection::getSubmittimestamp).reversed())//先排序.collect(Collectors.groupingBy(BusBidsection::getTradeplat))//在分组//最后取出key和最后数据接收时间.entrySet().stream().collect(Collectors.toMap(b -> b.getKey(), b -> b.getValue().get(0).getSubmittimestamp()));

http://www.ppmy.cn/news/68512.html

相关文章

协众信息ui设计岗位招聘要求有哪些？

协众信息ui设计岗位招聘要求有哪些？

UI设计师的工作是接到使用者轮廓、线框草稿后&#xff0c;创造出好看、好用的画面&#xff0c;视情况会搭配VisualDesigner&#xff08;视觉设计师&#xff09;&#xff0c;不过偶尔还是需要自己做图&#xff0c;包含插图、icon绘制等&#xff1b;透过设计过的画面&#xff0c;…
阅读更多...
怎样设置CRM目标？有什么作用？

怎样设置CRM目标？有什么作用？

实施CRM系统可以帮助企业提高客户保留率&#xff0c;增加收入&#xff0c;并推动业绩增长。然而&#xff0c;在实施CRM系统之前&#xff0c;必须设定明确的目标&#xff0c;与企业的整体战略保持一致。在这篇文章中&#xff0c;我们来讨论实施CRM目标是什么&#xff0c;如何设定…
阅读更多...
ChatGPT 国内版免费

ChatGPT 国内版免费

ChatGPT 是最新的聊天机器人技术&#xff0c;它可以让你更快地完成各种任务。如果你想要一个在国内的免费版本&#xff0c;你来对地方了&#xff01;在这篇文章中&#xff0c;我们将会分享与你 ChatGPT的最新信息&#xff0c;以及在国内使用 ChatGPT 的方法。如果你想要了解更多…
阅读更多...
使用apisix代理静态文件

使用apisix代理静态文件

前言 最近公司考虑用apisix作为公司网关并且部署到k8s上&#xff0c;我这边收到一个小任务&#xff1a;使用apisix代理静态文件 通过apisix官网了解到它构建于 NGINX ngx_lua 的技术基础之上&#xff0c;所以按理应该和nginx代理静态资源是一样的。因为是通过docker容器部署…
阅读更多...
【Linux】10. 进程地址空间

【Linux】10. 进程地址空间

1. 虚拟地址的引出 2. 感性理解 3. 区域划分 在理解虚拟地址空间之前首先了解区域划分是什么 在小学期间的三八线&#xff0c;让桌子分割成两个区域&#xff0c;类比到地址空间也是这样划分的。 操作系统需要对进程管理&#xff0c;进程存在不同的区域映射不同的虚拟地址 这…
阅读更多...
2023-05-12 LeetCode每日一题（翻转子数组得到的最大的数组值）

2023-05-12 LeetCode每日一题（翻转子数组得到的最大的数组值）

2023-05-12每日一题 一、题目编号 1330. 翻转子数组得到最大的数组值二、题目链接 点击跳转到题目位置 三、题目描述 给你一个整数数组 nums 。「数组值」定义为所有满足 0 < i < nums.length-1 的 |nums[i]-nums[i1]| 的和。 你可以选择给定数组的任意子数组&…
阅读更多...
银行太多怎么选？

银行太多怎么选？

无论在银行春招还是秋招中&#xff0c;不少同学都采用“海投”策略&#xff0c;以求有更多的笔试面试机会&#xff1b;还有同学有一颗想行动的心&#xff0c;但是却被“选择困难症”绊住脚步&#xff0c;不确定投哪个地区的银行、不确定哪家银行哪个岗位更适合自己、该选大城市…
阅读更多...
postman处理各种请求数据

postman处理各种请求数据

1、后台request接收postman参数 2、后台单个参数接收postman 3、后台RequestParam参数接收postman 注意事项&#xff1a;情况一&#xff1a;全部都是单个字符串的 情况二&#xff1a;有可能是一个json对象序列化成字符串过来的&#xff0c;那么需要在form-data中设置 …
阅读更多...
最新文章

Copyright @ 2022~2023