标签：Author age Authors 特性 add authors new JAVA8

JAVA8新特性

Lambda表达式

只有函数式接口才能使用Lambda表达式

Lambda表达式是JDK8中的一个语法糖，它可以对某些匿名内部类的写法进行简化，它是函数式编程思想的一个重要体现，让我们不用关注是什么对象，而是更关注我们对数据进行了什么操作。

核心原则

可推导可省略

基本格式

(参数列表)-> {方法体(函数式接口方法的方法体)}

示例

1、

// 返回数组中能被2整除的数字 
printNum(x-> x % 2 == 0 );
 
 public static void printNum(IntPredicate predicate) {
    int[] arr = {1,2,3,4,5,6,7,8,9,10};
    for (int i : arr) {
        // predocate.test() 方法返回值为boolean类型
         if (predicate.test(i)) {
             System.out.println(i);
         }
    }
}

结果：

2、

    final Integer integer = typeConver(s -> {
        s += "78";
        return Integer.parseInt(s);
    });
    System.out.println(integer);
}

public static <R> R typeConver (Function <String, R > function){
    String str = "12345";
    R result = function.apply(str);
    return result;
}

结果：

Lambda核心是通过实现函数式接口的方法来完成相应业务

Lambda表达式的省略原则

没有参数，没有返回值的抽象方法

() -> {方法体语句}
如果方法体语句只有一句，此时可以省略大括号
() -> 方法体语句

有一个参数，没有返回值的抽象方法

(x)->{方法体语句}
如果只有一个参数，参数的小括号也可以省略不写
x -> {方法体语句}

有多个参数，没有返回值的抽象方法

(a,b)->{方法体语句}

有多个参数，有多条方法体语句，有返回值的抽象方法

(x,y)->{double pow = Math.pow(x,y);  return pow;};
如果语句只有一条，大括号可以省略，如果单语句是return语句，则return关键字也可以去掉，该格式会自动返回内容  写return关键字必须写大括号
(x,y)->Math.pow(x,y);

Stream流

JAVA8的Stream流使用的是函数式编程模式，如同他的而名字一样，它可以被用来对集合或者数据及逆行链状流式的操作。可以更方便的让我们对集合或者数组进行操作。

集合获取流对象的方式:

list、set：
	list/set.stream();
map：
	 hm.keyset().stream();
	 hm.values().stream();
	 hm.entryset().stream();
数组:
	Stream.of(arr);

中间操作

filter过滤操作

可以对流中的元素进行条件筛选，过滤条件为 true 的才会保存在流中

示例：

@Test
public void testStream() {
    List<Integer> list  = new ArrayList<>();
    for (int i = 1; i < 11; i++) {
        // 添加1-10
        list.add(i);
    }
    list.stream().filter(x -> x%2==0).forEach(System.out::println);
}

结果：

map

可以对流中的元素进行计算或转换

类型转换

// 定义一个 作者类
class Author {
    private String name;
    private Integer age;

    public Author() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

/*-------------------------------------------*/
List<Author> authors = new ArrayList<>();
authors.add(new Author("迪迦",10));
authors.add(new Author("戴拿",11));
authors.add(new Author("盖亚",12));
// 类型转换，匿名内部类方式实现
authors.stream()
    // 类型转换: 输入Author类型的参数，输出String类型的参数
    .map(new Function<Author, String>() {

    @Override
    public String apply(Author author) {
        return author.getName();
    }
}).forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});
}
// 类型转换，Lambda表达式实现
authors.stream().map(author -> author.getName()).forEach(s -> System.out.println(s));

结果：

迪迦
戴拿
盖亚

计算

List<Author> authors = new ArrayList<>();
authors.add(new Author("迪迦",10));
authors.add(new Author("戴拿",11));
authors.add(new Author("盖亚",12));
authors.stream().map(author -> author.getAge()).map(age -> age + 10).forEach(age -> System.out.println(age));

结果：

20
21
22

distinct 去重

可以去除流中的重复元素。

distinct方法是以来Object的equals方法来判断是否是相同的对象，所以集合中的对象需要重写equals方法

示例：

打印所有作家的名字，并且要求其中不能有重复元素


class Author {
    private String name;
    private Integer age;
	// 使用distinct操作必须重写equals和hashcode方法
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Author author = (Author) o;
        return Objects.equals(name, author.name) && Objects.equals(age, author.age);
    }
	// 显示对象数据必须重写toString方法
    @Override
    public String toString() {
        return "Author{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public Author() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

List<Author> authors = new ArrayList<>();
authors.add(new Author("迪迦",10));
authors.add(new Author("戴拿",11));
authors.add(new Author("迪迦",10));
// 去重
authors.stream().distinct().forEach(author -> System.out.println(author.getName()));

结果：

迪迦
戴拿

sorted 排序

可以都流当中的元素进行排序

示例：

对流中的元素进行降序排序，并且要求不能有重复的元素

调用空参的 sorted 方法

注意：调用空参的排序方法，对象要实现Comparable接口，并重写compareTo()方法自定义排序规则

// 实现Comparable接口
class Author implements Comparable<Author>{
    private String name;
    private Integer age;
	// 重写compareTo()方法自定义排序规则
    @Override
    public int compareTo(Author o) {
        return this.getAge() - o.getAge();
    }
}


List<Author> authors = new ArrayList<>();
authors.add(new Author("迪迦",12));
authors.add(new Author("戴拿",11));
authors.add(new Author("盖亚",10));
authors.add(new Author("阿古茹",19));
authors.add(new Author("迪迦",12));
authors.stream().distinct().sorted().forEach(author -> System.out.println(author));

结果：

Author{name='盖亚', age=10}
Author{name='戴拿', age=11}
Author{name='迪迦', age=12}
Author{name='阿古茹', age=19}

2.调用有参的 sorted 方法

List<Author> authors = new ArrayList<>();
authors.add(new Author("迪迦",12));
authors.add(new Author("戴拿",11));
authors.add(new Author("盖亚",10));
authors.add(new Author("阿古茹",19));
authors.add(new Author("迪迦",12));
// 匿名内部类方式
authors.stream().distinct().sorted(new Comparator<Author>() {
    @Override
    public int compare(Author o1, Author o2) {
        return o1.getAge()- o2.getAge();
    }
}).forEach(author -> System.out.println(author));
// Lambda表达式方式
authors.stream().distinct()
    .sorted((o1, o2) -> o1.getAge()-o2.getAge())
    .forEach(author -> System.out.println(author));

结果:

Author{name='盖亚', age=10}
Author{name='戴拿', age=11}
Author{name='迪迦', age=12}
Author{name='阿古茹', age=19}

limit 截取

可以设置流的最大长度，超出的部分将被抛弃

示例：

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
l.stream().sorted((o1, o2) -> o1.getAge() - o2.getAge()).limit(2).forEach(authors -> System.out.println(authors));

结果:

Authors{name='迪迦', age=10}
Authors{name='戴拿', age=11}

skip 截取

跳过流中前size个元素，截取剩余元素

示例:

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
l.stream().sorted((o1, o2) -> o1.getAge() - o2.getAge()).skip(2).forEach(authors -> System.out.println(authors));

结果：

Authors{name='赛罗', age=13}
Authors{name='艾斯', age=16}

flatMap

把一个对象转换成多个对象作为流中的元素

示例：

List<Book> l1 = new ArrayList<>();
l1.add(new Book("西游记","孙悟空三打白骨精"));
l1.add(new Book("红楼梦","黛玉葬花"));
List<Book> l2= new ArrayList<>();
l2.add(new Book("鲁滨逊漂流记","海上流浪汉"));
l2.add(new Book("红楼梦","黛玉葬花"));
List<Book> l3 = new ArrayList<>();
l3.add(new Book("三国演义","司马懿统一"));
l3.add(new Book("红楼梦","黛玉葬花"));
List<Book> l4= new ArrayList<>();
l4.add(new Book("西游记","孙悟空三打白骨精"));
l4.add(new Book("水浒传","鲁智深倒拔垂杨柳"));
List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10,l1));
l.add(new Authors("戴拿",11,l2));
l.add(new Authors("赛罗",13,l3));
l.add(new Authors("艾斯",16,l4));
l.stream()
        .flatMap(authors -> authors.getBooks().stream())//从作家对象中中获取书的流对象
    .distinct() // 对书对象去重
  .forEach(books -> System.out.println(books.getName())); // 打印书的名字

// 作家信息
class Authors {
    private String name;
    private Integer age;
    private List<Book> books;

    public Authors() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Authors(String name, Integer age, List<Book> books) {
        this.name = name;
        this.age = age;
        this.books = books;
    }

    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Authors authors = (Authors) o;
        return Objects.equals(name, authors.name) && Objects.equals(age, authors.age) && Objects.equals(books, authors.books);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, books);
    }
}
// 进行去重操作必须重写hashcode方法和equals方法
class Book {
    private String name;
    private String content;

    @Override
    public String toString() {
        return "Books{" +
                "name='" + name + '\'' +
                ", content='" + content + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Book() {
    }

    public Book(String name, String content) {
        this.name = name;
        this.content = content;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Book book = (Book) o;
        return Objects.equals(name, book.name) && Objects.equals(content, book.content);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, content);
    }
}

结果：

西游记
红楼梦
鲁滨逊漂流记
三国演义
水浒传

终结操作

以当前方法作为流操作的终结方法，之后不能再进行流操作。

流操作时必须要有一个终结操作，这样中间操作才会生效。

forEach 遍历

对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么操作

示例:

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
l.stream().forEach(authors -> System.out.println(authors.getName()));

结果:

迪迦
戴拿
赛罗
艾斯

count 数量

获取当前流中元素的个数

count()方法不需要参数但是有一个返回值，需要被接收

示例：

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final long count = l.stream().filter(authors -> authors.getAge() > 10).count();
System.out.println(count);

结果：

max 最大值

获取流中的最大值

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final Optional<Authors> max = l.stream().max((o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(max.get());

结果:

Authors{name='艾斯', age=16, books=null}

min 最小值

获取流中的最小值

示例:

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final Optional<Authors> min = l.stream().min((o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(min.get());

结果：

Authors{name='艾斯', age=16, books=null}

collect

把当前流转换成一个集合

示例: toList\toSet

获取一个存放所有作者名字的集合

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

final List<String> collect = l.stream().map(authors -> authors.getName()).collect(Collectors.toList());
System.out.println(collect);

结果:

[迪迦, 戴拿, 赛罗, 艾斯]

示例2: toMap

获取一个Map集合，map的Key为姓名，value为年龄

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
// 匿名内部类方式实现
final Map<String, Integer> collect = l.stream().distinct().collect(Collectors.toMap(new Function<Authors, String>() {
    @Override
    public String apply(Authors authors) {
        return authors.getName();
    }
}, new Function<Authors, Integer>() {
    @Override
    public Integer apply(Authors authors) {
        return authors.getAge();
    }
}));
// Lambda表达式方式实现
final Map<String, Integer> collect = l.stream().distinct().collect(Collectors.toMap(authors -> authors.getName(), authors -> authors.getAge()));

System.out.println(collect);

结果:

{艾斯=16, 戴拿=11, 迪迦=10, 赛罗=13}

anyMatch

判断是否有任意符合条件的元素，结果为boolean类型

示例:

判断是否有年龄11岁以上的作家

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final boolean b = l.stream().anyMatch(authors -> authors.getAge() > 11);
System.out.println(b);

结果:

true

allMatch

判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。

示例:

是否年龄都为11岁以上的作家

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final boolean b = l.stream().allMatch(authors -> authors.getAge() > 11);
System.out.println(b);

结果:

false

noneMatch

判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false。

示例:

是否作家年龄都不大于30岁

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));
final boolean b = l.stream().noneMatch(authors -> authors.getAge() > 30);
System.out.println(b);

结果:

true

findAny

获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。

示例:

获取任意一个年龄大于10的作家，如果存在就输出他的名字

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

final Optional<Authors> any = l.stream().filter(authors -> authors.getAge() > 10).findAny();
any.ifPresent(authors -> System.out.println(authors.getName()));

结果:

戴拿、赛罗、艾斯中的任意一个

findFirst

获取流中的第一个元素

示例:

获取一个年龄最小的作家的名字

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

final Optional<Authors> first = l.stream().sorted((o1, o2) -> {
    return o1.getAge()-o2.getAge();
}).findFirst();
first.ifPresent(authors -> System.out.println(authors.getName()));

结果:

迪迦

reduce 归并

对流中的数据按照你制定的计算方式计算出一个结果

reduce内部的计算方式如下:

T result = identity; // 初始值
for (T element : this stream) // 遍历stream获取每个元素
	result = accumulator.apply(result,element);//计算方法
return result;

reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，他会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。

示例1:

T reduce(T identity, BinaryOperator<T> accumulator);

求出所有作者的年龄的和

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

// 匿名内部类形式
final Integer reduce = l.stream().map(authors -> authors.getAge()).reduce(0, new BinaryOperator<Integer>() {
    @Override
    public Integer apply(Integer result, Integer element) {

        return result + element;
    }
});
// Lambda表达式
final Integer reduce = l.stream().map(authors -> authors.getAge()).reduce(0, (result, element) -> result + element);

System.out.println(reduce);

结果:

示例2：

求所有作家中年龄的最大值

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

final Integer reduce = l.stream().map(authors -> authors.getAge()).reduce(Integer.MIN_VALUE, (result, element) -> result>element? result : element);
System.out.println(reduce);

结果:

示例3:

List<Authors> l = new ArrayList<>();
l.add(new Authors("迪迦",10));
l.add(new Authors("戴拿",11));
l.add(new Authors("赛罗",13));
l.add(new Authors("艾斯",16));

final Integer reduce = l.stream().map(author -> author.getAge()).reduce(Integer.MAX_VALUE, (result, element) -> result < element ? result : element);
System.out.println(reduce);

结果:

基本数据类型优化

我们之前用到的很多Stream的方法都是由于使用了泛型。所以涉及到的参数和返回值都是引用数据类型。

即使我们操作的是整数小数，但是实际用的都是他们的包装类。JDK5中引入的自动装箱和自动拆箱让我们在使用对应的包装类时就好像使用基本数据类型一样方便，但是我们应该清楚装箱和拆箱是要消耗时间的，虽然这个时间消耗很小，但是在大量的数据不断的重复装箱拆箱时，你就不能无视这个时间损耗了。

所以为了让我们能够对这部分时间消耗进行优化，Stream还提供了很多专门针对基本数据类型的方法。

例如: mapToInt、mapToLong、mapToDouble、flatMapToInt、flatMapToDouble等。

示例:

private static void test() {
	List<Author> author = getAuthors();
	authors.stream()
	.map(author -> author.getAge())  // Integer
	.map(age -> age + 10) // Integer -> int ->Integer
    .filter(age -> age>18)// Integer -> int ->Integer
    .map(age->age+2) // Integer -> int ->Integer
    .forEach(System.out::println);    
}

优化:

private static void test() {
	List<Author> author = getAuthors();
	authors.stream()
	.mapToInt(author -> author.getAge())  // int
	.map(age -> age + 10) // int
    .filter(age -> age>18)// int
    .map(age->age+2) // int
    .forEach(System.out::println);    
}

并行流

当流中有大量元素时，我们可以使用并行流去提高操作效率。其实并行流就是把任务分配给多个线程去完成。如果我们自己去用代码实现的话会非常复杂，并且要求你对并发编程有足够的理解和认识。而如果我们使用Stream的话，我们只需要修改一个方法的调用就可以使用并行流来帮我们实现，从而提高效率。

parallel方法课可以把串行流转换成并行流

也可以通过parallelStream直接获取并行流对象

private static void test() {
    Stream<Integer> Stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
    Integer sum  = stream.parallel()
        .peek(new Consumer<Integer>() {
            @Override
            public void acept(Integer num) {
                System.out.println(num + Thread.currentThread().getName());
            }
        })
        .filter(num -> num>5)
        .reduce((result,ele) -> result + ele)
        .get();
    
}

List<Author> author = getAuthors();
author.parallelStream()
    .map(author->author.getAge())
    .map(age->age+10)
    .filter(age->age>18)
    .map(age->age+2)
    .forEach(System.out::println)

Optional

本质上Optional是一个包装类，可以把我们具体数据封装到Optional对象内部。然后我们去使用Optional中封装好的方法操作封装进去的数据就可以避免空指针异常。

Optional静态方法

Optional.ofNullable

使用ofNullable来把数据封装成一个Optional对象。无论传入的参数是否为null都不会报异常。

Author author = new Author("迪迦",12);
author = null;
// 如果optional对象存在则进行消费
final Optional<Author> author1 = Optional.ofNullable(author);
author1.ifPresent(author2 -> System.out.println(author2.getAge()));

结果:

当author不为null时，  结果为12
当author为null时， 结果没有结果但是也不报错

Optional.of

如果你确定一个对象不为空，则可以使用Optional.of方法把数据封装成Optional对象。

如果对象为null，则会报出空指针异常

Author author = new Author("迪迦",12);
final Optional<Author> author2 = Optional.of(author);
author2.ifPresent(author3 -> System.out.println(author3.getAge()));

author = null;
final Optional<Author> author1 = Optional.of(author);
System.out.println(author1);
author =

结果：

12
npe

Optional.empty

将null封装成Optional对象。

Author author = new Author("迪迦",12);
author = null;
final Optional<Object> empty = Optional.empty();
// 判断值是否为null
System.out.println(empty.isEmpty());

结果：

true

安全消费值

如果一个对象是Optional对象，则可以调用消费接口进行消费，这个方法会判断Optional中封装的数据是否为空，不为空才会执行具体的消费代码。

这种写法可以避免空指针异常

Author author = new Author("迪迦",12);
author = null;
// 如果optional对象存在则进行消费
final Optional<Author> author1 = Optional.ofNullable(author);
author1.ifPresent(author2 -> System.out.println(author2.getAge()));

结果:

获取值

如果我们想获取值可以使用get方法获取，但是不推荐，因为当Optional内部的数据为空的时候会出现异常。

NoSucElement异常

Author author = new Author("迪迦",12);
final Optional<Author> author1 = Optional.ofNullable(author);
final Author author2 =
        author1.get();
System.out.println(author2);

author = null;
final Optional<Author> author3 = Optional.ofNullable(author);
final Author author4 = author3.get();
System.out.println(author4);

结果：

Author{name='迪迦', age=12}

Exception in thread "main" java.util.NoSuchElementException

安全获取值

orElseGet

获取数据并且设置数据为空时的默认值。如果数据不为空就能获取到该数据，如果为空则根据你传入的参数来创建对象作为默认值进行返回。

示例：

Author author = new Author("迪迦",12);
// author = null;
Optional<Author> author1 = Optional.ofNullable(author);
Author author2 = author1.orElseGet(() -> new Author("戴拿",14));
System.out.println(author2);

结果:

// 当author不为空时，显示结果
Author{name='迪迦', age=12}
// 当author为null时，显示结果
Author{name='戴拿', age=14}

orElseThrow

获取数据，如果数据不为空就能获取到该数据，如果为空则根据你传入的参数来创建异常抛出。

示例:

Author author = new Author("迪迦",12);
final Optional<Author> author1 = Optional.ofNullable(null);
final Author author2 = author1.orElseThrow(() -> new RuntimeException("测试异常"));
System.out.println(author2);

结果:

Exception in thread "main" java.lang.RuntimeException: 测试异常
	at com.Day23.newCharacter.Optional类.lambda$main$0(Optional类.java:16)
	at java.base/java.util.Optional.orElseThrow(Optional.java:408)
	at com.Day23.newCharacter.Optional类.main(Optional类.java:16)

过滤

使用filter方法过滤出符合条件的Optional对象

示例：

Author author = new Author("迪迦",12);
final Optional<Author> author1 = Optional.ofNullable(author);
final Optional<Author> author3 = author1.filter(author2 -> author2.getAge() > 10);
System.out.println(author3);

结果：

// 当满足条件age为12时
Optional[Author{name='迪迦', age=12}]
// 当不满足条件age为10时，返回一个value为null的新的Optional对象
Optional.empty

判断

可以使用isPresent/ifPresent方法判断是否存在数据。如果为空，返回值为false；如果不为空，返回值为true

推荐使用ifPresent，因为ifPresent更能体现Optional的优势

示例：

Author author = new Author("迪迦",12);
author = null;
// 如果optional对象存在则打印年龄
final Optional<Author> author1 = Optional.ofNullable(author);
author1.ifPresent(author2 -> System.out.println(author2.getAge()));

结果：

// 当Optional对象存在时
12
// 当Optional对象不存在时
什么也不显示

数据转换

Optional提供了map方法对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证了我们的使用安全。

示例：

// 将author转换为List<Book>
List<Book> l1 = new ArrayList<>();
l1.add(new Book("西游记","孙悟空三打白骨精"));
l1.add(new Book("红楼梦","黛玉葬花"));
final Optional<Authors> author = Optional.ofNullable(new Authors("迪迦", 12, l1));
Optional<List<Book>> books = author.map(authors -> authors.getBooks());
if (books.isPresent()) {
    System.out.println(books);
}

结果：

Optional[[Books{name='西游记', content='孙悟空三打白骨精'}, Books{name='红楼梦', content='黛玉葬花'}]]

方法引用

简化Lambda表达式的语法糖

基本格式

类名或者对象名::方法名

语法详解

引用类的静态方法

使用前提：

如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且我们要把重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法

格式

类名::方法名

引用对象的实例方法

格式

对象名::方法名

使用前提：

如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个对象的抽象方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用对象的实例方法

引用类的实例方法

格式：

类名::方法名

使用前提：

如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了第一个参数的抽象方法，并且我们把要重写的抽象方法中剩余的所有参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用类的实例方法

构造器引用

使用前提：

如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的构造方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个构造方法中，这个时候我们就可以引用构造器

如果方法体中的一行代码是构造器的话就可以使哟iing构造器引用

格式

类名::new

标签：Author,age,Authors,特性,add,authors,new,JAVA8
From： https://www.cnblogs.com/zzprogram/p/17372763.html

JAVA8新特性

JAVA8新特性

Lambda表达式

核心原则

基本格式

示例

Lambda表达式的省略原则

没有参数，没有返回值的抽象方法

有一个参数，没有返回值的抽象方法

有多个参数，没有返回值的抽象方法

有多个参数，有多条方法体语句，有返回值的抽象方法

Stream流

集合获取流对象的方式:

中间操作

filter过滤操作

map

distinct 去重

sorted 排序

limit 截取

skip 截取

flatMap

终结操作

forEach 遍历

count 数量

max 最大值

min 最小值

collect

anyMatch

allMatch

noneMatch

findAny

findFirst

reduce 归并

基本数据类型优化

并行流

Optional

Optional静态方法

Optional.ofNullable

Optional.of

Optional.empty

安全消费值

获取值

安全获取值

orElseGet

orElseThrow

过滤

判断

数据转换

方法引用

基本格式

语法详解

引用类的静态方法

格式

引用对象的实例方法

格式

引用类的实例方法

格式：

构造器引用

格式

相关文章

赞助商

阅读排行