java8 Optional类与接口默认方法

Optional

Optional<T> (java.util.Optional)类是一个容器类,代表一个值存在或不存在,原来用null表示一个值不存在,现在Optional可以更好的表达这个概念.并且可以避免空指针异常.

Optional.of(T t):创建一个实例

Optional.empty():创建一个空的Optional实例

Optional.ofNullable(T t):若t不为null,创建Optional实例,否则创建空例

isPresent():判断是否包含值

orElse(T t):如果调用对象包含值,返回该值,否则返回t

orElseGet(Supplier s):如果调用对象包含值,否则返回s获取的值

map(Function f):如果有值进对其处理,并返回处理后的Optional,否则返回Optional.empty()

flatMap(Function mapper):与map类似,要求返回值必须是Optional

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

class User {
    private String name="小王";

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

    public String getName() {
        return name;
    }

    private int score=90;

    private int age=1;

    public User() {

    }

    public User(int score, int age,  String name) {
        super();
        this.score = score;
        this.age = age;
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getAge() {
        return age;
    }

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


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", age=" + age +
                '}';
    }

    static List<User> list = Arrays.asList(
            new User(1, 2, "张三"),
            new User(2, 4,  "李四"),
            new User(3, 6, "王五"),
            new User(3, 90,  "赵六"),
            new User(3, 90,  "小黑")
    );

    public static void main(String[] args) {
        //如果传入null会报空指针异常
        Optional<User> user = Optional.of(new User());
        User user1 = user.get();
        System.out.println(user1);//User{name='小王', score=90, age=1}

        Optional<User>op=Optional.empty();
//        System.out.println(op.get());如果设置为空的话,get的时候会报错

        //如果为null调用of,否则调用of
        Optional<User>op2=Optional.ofNullable(null);

        if (op2.isPresent()){
            System.out.println(op2.get());//如果有值就取值并打印,这里不会执行
        }

        //如果op2中没有值,就创建一个传入的新值,赋值给op3
        User op3 = op2.orElse(new User(1, 2, "新"));
        System.out.println(op3);//User{name='新', score=1, age=2}
        //函数式接口,可以用lambda表达式实现自己想要的功能
        op2.orElseGet(()->new User());


        Optional<User> op4=Optional.ofNullable(new User(1, 2, "新2"));
        Optional<String> s = op4.map((e) -> e.getName());
        System.out.println(s.get());//新2

        Optional<String> s1 = op4.flatMap((e) -> Optional.of(e.getName()));
        System.out.println(s1.get());//新2
    }
}