评审代码时,这样写就不会被怼了

在JDK版本普遍升级到8之后,最近参与了几次代码评审,好多人对JDK8中的用法不是特别熟熟悉,用的不对或者干脆用错的常有,代码评审时经常被说到,这里整理一波实用的技巧,希望大家举一反三,有所收获。
废话不多说,直接干货,觉得口渴文章底部有水(文字总结)

判空操作
 //优化之前  
 if (obj != null){
 }
 //优化之后
 if (Optional.ofNullable(obj).isPresent()){
 }
判空异常操作
 //优化之前  
 if (obj == null){
    throw new .....
 }
 //优化之后
Optional.ofNullable(obj).isPresent().orElseThrow(() ->new RuntimeException(""));
返回非空值
 //优化之前
 if list == null{
    return new ArrayList();
 }
 return list;
 //优化之后
 return Optional.ofNullable(list).orElse(new ArrayList<>()).get()
求最大值最小值
Integer max = Stream.of(1,2,3,4,5).max(Integer::compareTo).get();
Integer min = Stream.of(1,2,3,4,5).min(Integer::compareTo).get();
去重操作
//优化前
List<Integer> list = new ArrayList();
list.add(1);
list.add(2);
list.add(1);
Set<Integer> set = new HashSet(list);
//优化后
List<Integer> temp =list.distinct().collect(Collectors.toList());
集合判空遍历操作
//优化前
if (list == null){
    return
}
for (String s : list){
}

//优化后
Optional.ofNullable(list).orElse(new ArrayList<>()).stream().forEach()
匿名内部类
//优化前
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Java8 ");
    }
}).start();
//优化后
new Thread(() -> System.out.println("Java8!"));
规约计算
//基于数据流的方式,将流装载成相应的 SummaryStatistics进行归约计算,可以实现更多的操作;
IntSummaryStatistics stats = list.stream().mapToInt(i -> i). summaryStatistics();
int max = stats.getMax();        //获取最大值
int min = stats.getMin();        //获取最小值
double sum =  stats.getSum();    //获取总值
double avg = stats.getAverage();  //获取平均值
long count = stats.getCount();     //获取总数量
排序
//升序
List<Integer> temp1 = Stream.of(2,1,3,5,0,6).sorted().collect(Collectors.toList());
//自己制定排序方式
List<Integer> temp2 = Stream.of(2,1,3,5,0,6)
.sorted((x,y) -> Integer.compare(x,y))        
.collect(Collectors.toList());
求和
//优化前
List<Integer> list  = new ArrayList();
Integer sum = 0;
for (Integer i : list){
   sum = sum + i;
}
//优化后
//方式一
sum = list.stream().mapToInt(Integer::intValue).sum();
//还有mapToDouble,mapToLong
//方式二
sum = list.stream().reduce((x,y) -> x+y);
过滤
//优化之前
List<Integer> list  = new ArrayList();
List<Integer> newList = new ArrayList();
for (Integer i : list){
    if (i % 2 ==0){
        newList.add(i);
    }
}
//优化之后
newList = list.stream().filter(i -> i % 2 ==0).collect(Collectors.toList());
分组归类
//优化之前
List<Student> list= Arrays.asList(
        new Student(1,"one","zhao"),
        new Student(2,"one","qian"),
        new Student(3,"two","sun")
);
//1.1根据某个属性分组计数
Map<String,Long> map = new HashMap();
for (Student s : list){
    if(map.containsKey(s.getGroupId())){
        Long l = map.get(s.getGroupId());
        map.put(s.getGroupId(),l+1);
    }else{
        map.put(s.getGroupId(),1L);
    }
}
//优化之后
map=list.stream().collect(Collectors.groupingBy(Student::getGroupId,
Collectors.counting()));
定义函数式方法
//functionTest入参接受一个函数,这个函数入参是Integer,出参是String
public void functionTest(Function<Integer,String> apply, List<Integer> nums){
    nums.forEach(n ->{
        String result = apply.apply(n);
        System.out.println(result);
    });
}
functionTest(n ->{return String.valueOf(n);},Lists.newArrayList(1, 2, 3, 4));
并行流计算
//优化之前
List<String> list = new ArrayList();
for(String no : list){
    //下发
    down(no)
}
//优化之后,parallel是多个线程并发的,这个底层是fork-join,线程数和cpu核数相等
//这种写法应该防止因parallel的线程数耗尽,导致后面的请求的排队,从而超时,甚至雪崩,压跨服务器
list.stream().parallel().forEach(no -> down(no));
List转换Map,key冲突处理

List<String> list12 = new ArrayList();
list12.stream().collect(Collectors.toMap(
        s -> {return s;}, //map的key
        s -> {return 1;}, //map的value
        (Integer src,Integer des) ->{ //当key冲突时,value相加
            return src+des;
        }
));
读取文件
final Path path = new File( "A:\\1.txt" ).toPath();
//必须放入try with resource语法,这个流是需要的关闭的,或者try cache finally手动关闭流
try(Stream< String > lines = Files.lines(path)){
    lines.onClose(()->{ System.out.println("down");}).forEach( System.out::println);
}catch (Exception e){
}
//如果出现下面的异常,看看文件编码,指定成utf-8
//当输入字节序列对于给定 charset 来说是不合法的,或者输入字符序列不是合法的 16 位 Unicode 序列时,抛出此经过检查的异常
java.nio.charset.MalformedInputException: Input length = 1
截取流的前N个元素

List<String> list = Arrays.asList("hello","I","love","you");
List<String> temp = list.stream()
                          .limit(3)
                          .collect(Collectors.toList());
跳过流的前N个元素
List<String> list = Arrays.asList("hello","I","love","you");
List<String> temp = list.stream()
                          .skip(2)
                          .collect(Collectors.toList());
匹配符合条件的第一个元素
List<String> list = Arrays.asList("hello","hello","hello","hello");
//返回配到的元素
String str = list.stream().filter( s -> {return ("hello").equals(s);}).findFirst();
匹配任何一个则返回
List<String> list = Arrays.asList("hello","i","love","you");
//匹配到love时就返回true,否则返回返回false
boolean falg = list.stream().anyMatch(s -> s.equals("love"));
匹配所有
List<String> list = Arrays.asList("hello","hello","hello","hello");
//只有list中所有的字符串都为hello才返回true,否则返回false
boolean falg = list.stream().allMatch(s -> s.equals("hello"));
总结一下Stream流的特点

总的来说,Stream流操作是对数据源进行一系列处理最终得到一个目标结果,数据流可以是有限的,也可以是无限的,这个处理过程整体分为两步
中间操作
这个操作返回的还是一个流,对数据经过某种操作后,再通过流进行下一个操作,就比如流水线上的加工程序,这个操作对数据的处理分别为无状态处理和有状态处理,所谓无状态就是对每一个数据都是单独处理,数据没有依赖关系,有状态操作处理时数据之间会有依赖关系,比如max()操作,数据之间会进行比较。
终端操作
流只能有一个终端操作,这个操作完成后,数据就已经是死数据了,得到了结果,流已经被使用完了,相当于流水线上最后一步加工完成后已经成为一个产品了,这个操作归为短路和非短路两类操作,短路操作指的流中的数据会在一个条件下终止,比如findFirst(),在所有数据中匹配到第一个符合条件的数据就终止,而非短路操作时所有数据都会遍历,比如sum(),所有数据累加成为最后结果

评审代码时,这样写就不会被怼了,干货

Stream的一些特性

  1. 无存储
  2. 函数式编程,能够减少大量代码
  3. 延迟执行,也叫做惰性执行
  4. 可消费(只会被消费一次)
  5. 可读性好(但刚刚入门可能难以理解)

评审代码时,这样写就不会被怼了,干货

本作品采用《CC 协议》,转载必须注明作者和本文链接

那小子阿伟

讨论数量: 5
Violet_Ice紫冰

代码评审没有一个严格规定。各家公司风格都不太一样。在我们这优化后反而会被怼:“你的代码毫无可读性”,“你写的是给人看的吗”。。。

1周前 评论

@Violet_Ice紫冰 您好,感谢您的意见,有些想法想给您分享一下

  1. 贵公司的代码评审或者说风格没有问题,但假如有一天你们换了领导,强推Java8技术呢?
  2. 假如你跳槽了,跳槽的公司都是使用Java8的stream写法,怎么办?
1周前 评论

你这个考虑性能了么?stream 的性能要弱一些,不信,自己换个大数组试试。你这样写考虑代码可读性了么?

1周前 评论

判断 null 用 objects 类不行么?

1周前 评论

@a_wei 强推 java 8 怎么?Java8 就必须得用这些 stream 写法?我们也一直用的 Java 8 ,也没见必须用 stream ,如果一家公司都是stream, 那代码可读性怎么保障? 业务逻辑和性能怎么保障?

1周前 评论

请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!