如何优雅的编写java代码(Stream/Optional/lambda/lombok), 这些技巧你都知道吗

最新推荐文章于 2024-05-07 18:25:51 发布

IT加载中

最新推荐文章于 2024-05-07 18:25:51 发布

阅读量1.1k

点赞数

分类专栏：学习记录 java 文章标签：优雅编码 Stream Optional lambda lombok

本文链接：https://blog.csdn.net/JinglongSource/article/details/99469414

版权

java 同时被 2 个专栏收录

26 篇文章 1 订阅

订阅专栏

学习记录

14 篇文章 2 订阅

订阅专栏

对于java, 很多开发者都说代码是成吨成吨写的; 其实, 我们也可以比较优雅的编写出高效且简约的代码的, 在这里主要介绍几个API的使用以及语法的简单入门。这些API都是基于Java8的。

java.util.stream.Stream
- Consumer
- Supplier
- Predicate
- Function
lambda表达式
java.util.Optional
lombok

1.0 简单介绍一下

Stream： Java 8引入了全新的Stream API。这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。
在此最好了解一下Consumer、Supplier、Predicate、Function这几个接口的用法。

Lambda： Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Optional： Java 8引入了Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。Optional 类的引入很好的解决空指针异常。

lombok： Lombok可以减少很多重复代码的书写。比如说getter / setter / toString等方法的编写。

2.0 直接上代码（以下是综合使用的简单代码）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author houyu
 * @createTime 2019/5/23 18:14
 */
@RestController
public class MainTest {

    public static void main(String[] args) throws Exception {
        // 准备数据
        List<Student> studentList = initData();
        /** 需求*/
        // 1.0 获取所有姓张的同学集合(过滤)
        List<Student> list1 = studentList.stream().filter(v -> v.getName().startsWith("张")).collect(Collectors.toList());
        System.out.println("获取所有姓张的同学集合list1 = " + list1);
        System.out.println("===========================================================================");
        // 2.0 移除重复元素,
        List<Student> list2 = studentList.stream().distinct().collect(Collectors.toList());// 需要重写hashCode 和 equals方法
        System.out.println("移除重复元素,list2 = " + list2);
        System.out.println("===========================================================================");
        // 3.0 移除null的元素
        List<Student> list3 = studentList.stream().filter(Objects::nonNull).collect(Collectors.toList());
        System.out.println("移除重复元素,list3 = " + list3);
        System.out.println("===========================================================================");
        // 4.0 获取所有学生的姓名组成一个集合
        //List<String> list4 = studentList.stream().map(v -> v.getName()).collect(Collectors.toList());
        List<String> list4 = studentList.stream().map(Student::getName).collect(Collectors.toList());
        System.out.println("获取所有学生的姓名组成一个集合list4 = " + list4);
        System.out.println("===========================================================================");
        // 5.0 根据学生的年龄排序
        //List<Student> list5 = studentList.stream().sorted((v1, v2) -> v1.getAge() - v2.getAge()).collect(Collectors.toList());
        List<Student> list5 = studentList.stream().sorted(Comparator.comparingInt(Student::getAge)).collect(Collectors.toList());
        System.out.println("根据学生的年龄排序list5 = " + list5);
        System.out.println("===========================================================================");
        // 6.0 统计学生的年龄
        int ageSum = studentList.stream().filter(Objects::nonNull).map(Student::getAge).reduce(0, (sum, index) -> sum += index).intValue();
        System.out.println("统计学生的年龄ageSum = " + ageSum);
        System.out.println("===========================================================================");
        // 7.0 转为Map, {name, age}
        Map<String, Integer> map = studentList.stream().distinct().collect(Collectors.toMap(Student::getName, Student::getAge));
        System.out.println("转为Map, {name, age}map = " + map);
        System.out.println("===========================================================================");
        // 8.0 打印集合每一个元素
        studentList.stream().forEach(System.out::println);
        System.out.println("===========================================================================");
        // 9.0 组装name字符串如: 张三,李四,王五...
        String nameStrs = studentList.stream().map(Student::getName).collect(Collectors.joining(","));
        System.out.println("nameStrs = " + nameStrs);
        System.out.println("===========================================================================");
        // 10 扁平化
        List<String[]> list9 = studentList.stream().map(v -> v.getName().split("")).collect(Collectors.toList());
        System.out.println("list9 = " + list9);
        List<String> list10 = studentList.stream().map(v -> v.getName().split("")).flatMap(v -> Arrays.asList(v).stream())
                .collect(Collectors.toList());
        System.out.println("扁平化list10 = " + list10);
        System.out.println("===========================================================================");
        // 11 集合:自定义类型
        HashSet<String> list11 = studentList.stream().map(Student::getName).collect(Collectors.toCollection(HashSet::new));
        System.out.println("集合:自定义类型list11 = " + list11);
        System.out.println("===========================================================================");
        // 12 集合:自定义
        List<String> list12 = studentList.stream().map(Student::getName)
                .collect(Collectors.reducing(new ArrayList<>(), v -> Arrays.asList(v), (list, v) -> {
                    list.addAll(v);
                    return list;
                }));
        System.out.println("集合:自定义类型list12 = " + list12);
        System.out.println("===========================================================================");
        // 13 使用Optional进行判null以及链式调用
        // 需求13, 获取集合中第一个同学的姓的汉字
        // 普通写法如下:
        if(studentList != null && studentList.size() > 0) {
            Student student = studentList.get(0);
            if(student != null) {
                String name = student.getName();
                if(name != null && name.length() > 0) {
                    char c = name.charAt(0);
                    System.out.println("普通写法如下:获取集合中第一个同学的姓的汉字 = " + c);
                }
            }
        }
        System.out.println("===========================================================================");
        // 使用Optional优雅实现
        Character character = Optional.ofNullable(studentList).map(v -> v.get(0)).map(Student::getName).filter(v -> v.length() > 0)
                .map(v -> v.charAt(0)).orElse(null);
        System.out.println("使用Optional优雅实现:获取集合中第一个同学的姓的汉字 = " + character);
        // 14 如果不为空则遍历打印集合中的每一个元素
        Optional.ofNullable(studentList).ifPresent(v -> v.forEach(System.out::println));
        System.out.println("===========================================================================");
        // 使用lambda简化代码, 其实上面也有很多使用了lambda
        new Thread(() -> System.out.println("我是线程1")){}.start();
        System.out.println("===========================================================================");
        // 不适用lambda的形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是线程2");
            }
        }){}.start();
    }

    public static List<Student> initData() {
        return new ArrayList<>(Arrays.asList(new Student("张三", 13),    //
                                             new Student("李四", 14),    //
                                             new Student("王五", 15),    //
                                             new Student("张六", 16),    //
                                             new Student("李七", 17),    //
                                             new Student("王八", 18),    //
                                             new Student("李七", 17),    // 重复
                                             new Student("王八", 18)     // 重复
                                             // , null
                                            , Student.builder().name("赵九").age(19).build() // 使用builder创建实例, 这个实现是内部类的方式,如果需要默认值请在属性添加注解@Builder.Default,否则不生效,导致莫名BUG的哦

        ));
    }

}

@Data// 这里是Getter Setter toString EqualsAndHashCode
@NoArgsConstructor// 无参构造
@AllArgsConstructor// 全参构造
@Builder// builder构造
class Student {

    @Builder.Default // 如果使用builder构造的话, 需要默认值请使用@Builder.Default否则默认值无效
    private String name = "默认名字";
    private Integer age;
}

3.0 lombok反编译之后的源码如下

这样子更加有效的理解其内部实现

class Student {
    private String name;
    private Integer age;

    private static String $default$name() {
        return "默认名字";
    }

    public static Student.StudentBuilder builder() {
        return new Student.StudentBuilder();
    }

    public String getName() {
        return this.name;
    }

    public Integer getAge() {
        return this.age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof Student)) {
            return false;
        } else {
            Student other = (Student)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$name = this.getName();
                Object other$name = other.getName();
                if (this$name == null) {
                    if (other$name != null) {
                        return false;
                    }
                } else if (!this$name.equals(other$name)) {
                    return false;
                }

                Object this$age = this.getAge();
                Object other$age = other.getAge();
                if (this$age == null) {
                    if (other$age != null) {
                        return false;
                    }
                } else if (!this$age.equals(other$age)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(Object other) {
        return other instanceof Student;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $name = this.getName();
        int result = result * 59 + ($name == null ? 43 : $name.hashCode());
        Object $age = this.getAge();
        result = result * 59 + ($age == null ? 43 : $age.hashCode());
        return result;
    }

    public String toString() {
        return "Student(name=" + this.getName() + ", age=" + this.getAge() + ")";
    }

    public Student() {
        this.name = $default$name();
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public static class StudentBuilder {
        private boolean name$set;
        private String name;
        private Integer age;

        StudentBuilder() {
        }

        public Student.StudentBuilder name(String name) {
            this.name = name;
            this.name$set = true;
            return this;
        }

        public Student.StudentBuilder age(Integer age) {
            this.age = age;
            return this;
        }

        public Student build() {
            String name = this.name;
            if (!this.name$set) {
                name = Student.$default$name();
            }

            return new Student(name, this.age);
        }

        public String toString() {
            return "Student.StudentBuilder(name=" + this.name + ", age=" + this.age + ")";
        }
    }
}

IT加载中

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
如何优雅的编写java代码(Stream/Optional/lambda/lombok), 这些技巧你都知道吗

对于java, 很多开发者都说代码是成吨成吨写的; 其实, 我们也可以比较优雅的编写出高效且简约的代码的, 在这里主要介绍几个API的使用以及语法的简单入门。这些API都是基于Java8的。java.util.stream.StreamConsumerSupplierPredicateFunctionlambda表达式java.util.Optionallombok...
复制链接

扫一扫

专栏目录