日常开发中代码技巧（个人使用）-Toy模板网

这篇具有很好参考价值的文章主要介绍了日常开发中代码技巧（个人使用）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

日常开发中代码技巧

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转换为数组

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

使用Stream

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

使用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/ 或者到印象笔记那找

位进制转换

16进制转10进制
```
Integer.parseInt("0xAA".substring(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,username
				from 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 xmroleid
			from 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()就变成倒序):小->大->null
  list.sort(Comparator.comparing(StreamDto::getBirthday, 
                               Comparator.nullsLast(Date::compareTo)));
  //先正序排序，并将null放在最前，搭配reversed()翻转就变成倒序：大->小->null
  list.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文章来源地址https://www.toymoban.com/news/detail-446981.html

    //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()就变成倒序):小->大->null
    l2 = list.stream().sorted(Comparator.comparing(StreamDto::getBirthday, 
                               Comparator.nullsLast(Date::compareTo))).collect(Collectors.toList());
    //先正序排序，并将null放在最前，搭配reversed()翻转就变成倒序：大->小->null
    l3 = 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()));
    //分组后又对集合进行处理,方式1
    Map<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()));

到了这里，关于日常开发中代码技巧（个人使用）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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