Java 8—Java 10 特性详解(上)

本文章转载出处来自民工哥的总结,链接地址: 民工哥之路

Java现在发布的版本很快，每年两个，但是真正会被大规模使用的是三年一个的TLS版本。

每3年发布一个TLS，长期维护版本。意味着Java 8 ，Java 11， Java 17 才可能被大规模使用。

每年发布两个正式版本，分别是3月份和9月份。

函数编程

在Java世界里面，面向对象还是主流思想，对于习惯了面向对象编程的开发者来说，抽象的概念并不陌生。面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。现实世界中，数据和行为并存，程序也是如此，因此这两种编程方式我们都得学。

这种新的抽象方式还有其他好处。很多人不总是在编写性能优先的代码，对于这些人来说，函数式编程带来的好处尤为明显。程序员能编写出更容易阅读的代码——这种代码更多地表达了业务逻辑，而不是从机制上如何实现。易读的代码也易于维护、更可靠、更不容易出错。

在写回调函数和事件处理器时，程序员不必再纠缠于匿名内部类的冗繁和可读性，函数式编程让事件处理系统变得更加简单。能将函数方便地传递也让编写惰性代码变得容易，只有在真正需要的时候，才初始化变量的值。

面向对象编程是对数据进行抽象；函数式编程是对行为进行抽象。

核心思想: 使用不可变值和函数，函数对一个值进行处理，映射成另一个值。

对核心类库的改进主要包括集合类的API和新引入的流Stream。流使程序员可以站在更高的抽象层次上对集合进行操作。

lambda表达式

lambda表达式仅能放入如下代码: 预定义使用了 @Functional 注释的函数式接口，自带一个抽象函数的方法，或者SAM(Single Abstract Method 单个抽象方法)类型。这些称为lambda表达式的目标类型，可以用作返回类型，或lambda目标代码的参数。例如，若一个方法接收Runnable、Comparable或者 Callable 接口，都有单个抽象方法，可以传入lambda表达式。类似的，如果一个方法接受声明于 java.util.function 包内的接口，例如 Predicate、Function、Consumer 或 Supplier，那么可以向其传lambda表达式。

lambda表达式内可以使用方法引用，仅当该方法不修改lambda表达式提供的参数。本例中的lambda表达式可以换为方法引用，因为这仅是一个参数相同的简单方法调用。

list.forEach(n -> System.out.println(n)); list.forEach(System.out::println); // 使用方法引用

然而，若对参数有任何修改，则不能使用方法引用，而需键入完整地lambda表达式，如下所示:

list.forEach((String s) -> System.out.println("*" + s + "*"));

事实上，可以省略这里的lambda参数的类型声明，编译器可以从列表的类属性推测出来。

lambda内部可以使用静态、非静态和局部变量，这称为lambda内的变量捕获。

Lambda表达式在Java中又称为闭包或匿名函数，所以如果有同事把它叫闭包的时候，不用惊讶。

Lambda方法在编译器内部被翻译成私有方法，并派发 invokedynamic 字节码指令来进行调用。可以使用JDK中的 javap 工具来反编译class文件。使用 javap -p 或 javap -c -v 命令来看一看lambda表达式生成的字节码。大致应该长这样:

private static java.lang.Object lambda$0(java.lang.String);

lambda表达式有个限制，那就是只能引用 final 或 final 局部变量，这就是说不能在lambda内部修改定义在域外的变量。

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});

int factor = 2;

primes.forEach(element -> { factor++; });

Compile time error : "local variables referenced from a lambda expression must be final or effectively final" 另外，只是访问它而不作修改是可以的，如下所示:

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});

int factor = 2;

primes.forEach(element -> { System.out.println(factor*element); });

分类

惰性求值方法

lists.stream().filter(f -> f.getName().equals("p1"))

如上示例，这行代码并未做什么实际性的工作，filter只是描述了Stream，没有产生新的集合。

如果是多个条件组合，可以通过代码块{}

及早求值方法

List<Person> list2 = lists.stream().filter(f -> f.getName().equals("p1")).collect(Collectors.toList());

如上示例，collect最终会从Stream产生新值，拥有终止操作。

理想方式是形成一个惰性求值的链，最后用一个及早求值的操作返回想要的结果。与建造者模式相似，建造者模式先是使用一系列操作设置属性和配置，最后调用build方法，创建对象。

stream & parallelStream

每个Stream都有两种模式: 顺序执行和并行执行。

顺序流:

List <Person> people = list.getStream.collect(Collectors.toList());

并行流:

List <Person> people = list.getStream.parallel().collect(Collectors.toList());

顾名思义，当使用顺序方式去遍历时，每个item读完后再读下一个item。而使用并行去遍历时，数组会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。

parallelStream原理:

List originalList = someData;split1 = originalList(0, mid);//将数据分小部分

split2 = originalList(mid,end);

new Runnable(split1.process());//小部分执行操作

new Runnable(split2.process());

List revisedList = split1 + split2;//将结果合并

大家对hadoop有稍微了解就知道，里面的 MapReduce 本身就是用于并行处理大数据集的软件框架，其处理大数据的核心思想就是大而化小，分配到不同机器去运行map，最终通过reduce将所有机器的结果结合起来得到一个最终结果，与MapReduce不同，Stream则是利用多核技术可将大数据通过多核并行处理，而MapReduce则可以分布式的。

stream与parallelStream性能测试对比

如果是多核机器，理论上并行流则会比顺序流快上一倍，下面是测试代码

long t0 = System.nanoTime();//初始化一个范围100万整数流,求能被2整除的数字，toArray()是终点方法int a[]=IntStream.range(0, 1_000_000).filter(p -> p % 2==0).toArray();l

ong t1 = System.nanoTime();//和上面功能一样，这里是用并行流来计算

int b[]=IntStream.range(0, 1_000_000).parallel().filter(p -> p % 2==0).toArray();

long t2 = System.nanoTime();//我本机的结果是serial: 0.06s, parallel 0.02s，证明并行流确实比顺序流快

System.out.printf("serial: %.2fs, parallel %.2fs%n", (t1 - t0) * 1e-9, (t2 - t1) * 1e-9);

Stream中常用方法如下:

~ stream(), parallelStream()

~ filter()

~ findAny() findFirst()

~sort

~ forEach void

~map(), reduce()

~flatMap() - 将多个Stream连接成一个Stream

~collect(Collectors.toList())

~ distinct, limit

~count

~ min, max, summaryStatistics

看下所有API:

常用例子

匿名类简写

new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

// 用法

(params) -> expression

(params) -> statement

(params) -> { statements }

forEach

// forEachList features = Arrays.asList("Lambdas", "Default Method",

"Stream API", "Date and Time API");

features.forEach(n -> System.out.println(n)); // 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，

features.forEach(System.out::println);

方法引用

构造引用

// Supplier<Student> s = () -> new Student();Supplier<Student> s = Student::new;

对象::实例方法 Lambda表达式的(形参列表)与实例方法的(实参列表)类型，个数是对应

// set.forEach(t -> System.out.println(t));set.forEach(System.out::println);

类名::静态方法

// Stream<Double> stream = Stream.generate(() -> Math.random());

Stream<Double> stream = Stream.generate(Math::random);

类名::实例方法

// TreeSet<String> set = new TreeSet<>((s1,s2) -> s1.compareTo(s2));

/* 这里如果使用第一句话，编译器会有提示: Can be replaced with Comparator.naturalOrder，这句话告诉我们 String已经重写了compareTo()方法，在这里写是多此一举，这里为什么这么写，是因为为了体现下面这句编译器的提示: Lambda can be replaced with method reference。好了，下面的这句就是改写成方法引用之后: */

TreeSet<String> set = new TreeSet<>(String::compareTo);

Filter & Predicate

常规用法

public static void main(args[]{

List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

System.out.println("Languages which starts with J :");

filter(languages, (str)->str.startsWith("J"));

System.out.println("Languages which ends with a ");

filter(languages, (str)->str.endsWith("a"));

System.out.println("Print all languages :");    filter(languages, (str)->true);

System.out.println("Print no language : ");    filter(languages, (str)->false);

System.out.println("Print language whose length greater than 4:");

filter(languages, (str)->str.length() > 4);

}

public static void filter(List names, Predicate condition) {

names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {        System.out.println(name + " ");    });

}

多个Predicate组合filter

// 可以用and()、or()和xor()逻辑函数来合并Predicate，

// 例如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入

Predicate<String> startsWithJ = (n) -> n.startsWith("J");

Predicate<String> fourLetterLong = (n) -> n.length() == 4;

names.stream()

.filter(startsWithJ.and(fourLetterLong))

.forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n));

Map&Reduce

map将集合类(例如列表)元素进行转换的。还有一个 reduce() 函数可以将所有值合并成一个

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();

System.out.println("Total : " + bill);

Collectors

// 将字符串换成大写并用逗号链接起来List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");

String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));

System.out.println(G7Countries);

Collectors.joining(", ")

Collectors.toList()

Collectors.toSet() ，生成set集合

Collectors.toMap(MemberModel::getUid, Function.identity())

Collectors.toMap(ImageModel::getAid, o -> IMAGE_ADDRESS_PREFIX + o.getUrl())

flatMap

将多个Stream连接成一个Stream

List<Integer> result= Stream.of(Arrays.asList(1,3),Arrays.asList(5,6)).flatMap(a->a.stream()).collect(Collectors.toList());

结果: [1, 3, 5, 6]

distinct

去重

List<LikeDO> likeDOs=new ArrayList<LikeDO>();

List<Long> likeTidList = likeDOs.stream().map(LikeDO::getTid)

.distinct().collect(Collectors.toList());

count

计总数

int countOfAdult = persons.stream() .filter(p -> p.getAge() > 18).map(person -> new Adult(person)) .count();

Match

boolean anyStartsWithA =    stringCollection.stream().anyMatch((s) -> s.startsWith("a"));

System.out.println(anyStartsWithA); // true

boolean allStartsWithA =    stringCollection .stream().allMatch((s) -> s.startsWith("a"));

System.out.println(allStartsWithA);      // false

boolean noneStartsWithZ =    stringCollection.stream().noneMatch((s) -> s.startsWith("z"));

System.out.println(noneStartsWithZ);      // true

min,max,summaryStatistics

最小值，最大值

List<Person> lists = new ArrayList<Person>();

lists.add(new Person(1L, "p1"));

lists.add(new Person(2L, "p2"));

lists.add(new Person(3L, "p3"));

lists.add(new Person(4L, "p4"));

Person a = lists.stream().max(Comparator.comparing(t -> t.getId())).get();System.out.println(a.getId());

如果比较器涉及多个条件，比较复杂，可以定制

Person a = lists.stream().min(new Comparator<Person>() {

@Override

 public int compare(Person o1, Person o2) {

 if (o1.getId() > o2.getId()) return -1;

 if (o1.getId() < o2.getId()) return 1;

 return 0;

 }

}).get();

summaryStatistics

//获取数字的个数、最小值、最大值、总和以及平均值

List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);

IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("Highest prime number in List : " + stats.getMax());

System.out.println("Lowest prime number in List : " + stats.getMin());

System.out.println("Sum of all prime numbers : " + stats.getSum());

System.out.println("Average of all prime numbers : " + stats.getAverage());

peek

可以使用peek方法，peek方法可只包含一个空的方法体，只要能设置断点即可，但有些IDE不允许空，可以如下文示例，简单写一个打印逻辑。

注意，调试完后要删掉。

List<Person> lists = new ArrayList<Person>();

lists.add(new Person(1L, "p1"));

lists.add(new Person(2L, "p2"));

lists.add(new Person(3L, "p3"));

lists.add(new Person(4L, "p4"));

System.out.println(lists);

List<Person> list2 = lists.stream().filter(f -> f.getName().startsWith("p")).peek(t -> {

System.out.println(t.getName());

}).collect(Collectors.toList());

System.out.println(list2);

FunctionalInterface

理解注解 @FunctionInterface

/**

* An informative annotation type used to indicate that an interface

* type declaration is intended to be a functional interface as

* defined by the Java Language Specification.

*

* Conceptually, a functional interface has exactly one abstract

* method. Since {@linkplain java.lang.reflect.Method#isDefault()

* default methods} have an implementation, they are not abstract. If

* an interface declares an abstract method overriding one of the

* public methods of {@code java.lang.Object}, that also does

* not count toward the interface's abstract method count

* since any implementation of the interface will have an

* implementation from {@code java.lang.Object} or elsewhere.

*

* Note that instances of functional interfaces can be created with

* lambda expressions, method references, or constructor references.

*

* If a type is annotated with this annotation type, compilers are

* required to generate an error message unless:

*

* <ul>

* <li> The type is an interface type and not an annotation type, enum, or class.

* <li> The annotated type satisfies the requirements of a functional interface.

* </ul>

*

* However, the compiler will treat any interface meeting the

* definition of a functional interface as a functional interface

* regardless of whether or not a {@code FunctionalInterface}

* annotation is present on the interface declaration.

*

* @jls 4.3.2. The Class Object

* @jls 9.8 Functional Interfaces

* @jls 9.4.3 Interface Method Body

* @since 1.8

*/

@Documented

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface FunctionalInterface{}

interface做注解的注解类型，被定义成java语言规范

一个被它注解的接口只能有一个抽象方法，有两种例外

第一是接口允许有实现的方法，这种实现的方法是用default关键字来标记的(java反射中java.lang.reflect.Method#isDefault()方法用来判断是否是default方法)

第二如果声明的方法和java.lang.Object中的某个方法一样，它可以不当做未实现的方法，不违背这个原则: 一个被它注解的接口只能有一个抽象方法, 比如: java public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); }

如果一个类型被这个注解修饰，那么编译器会要求这个类型必须满足如下条件:

这个类型必须是一个interface，而不是其他的注解类型、枚举enum或者类class

这个类型必须满足function interface的所有要求，如你给包含两个抽象方法的接口增加这个注解，会有编译错误。

编译器会自动把满足function interface要求的接口自动识别为function interface，所以你才不需要对上面示例中的 ITest接口增加@FunctionInterface注解。

自定义函数接口

@FunctionalInterface

public interface IMyInterface {

    void study();

}

package com.isea.java;

public class TestIMyInterface {

        public static void main(String[] args) {

             IMyInterface iMyInterface = () -> System.out.println("I like study");

             iMyInterface.study();

        }

}

内置四大函数接口

消费型接口:Consumer< T> void accept(T t)有参数，无返回值的抽象方法；

比如: map.forEach(BiConsumer<A, T>)

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);

greeter.accept(new Person("Luke", "Skywalker"));

供给型接口:Supplier < T> T get()无参有返回值的抽象方法；

以stream().collect(Collector<? super T, A, R> collector)为例:

比如:

Supplier<Person> personSupplier = Person::new;

personSupplier.get(); // new Person

再如:

// 调用方法

<R, A> R collect(Collector<? super T, A, R> collector)

// Collectors.toSet

public static <T> Collector<T, ?, Set<T>> toSet() {

 return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,

 (left, right) -> { left.addAll(right); return left;

},

 CH_UNORDERED_ID);

}

// CollectorImpl

private final Supplier<A> supplier;private final BiConsumer<A, T> accumulator;

private final BinaryOperator<A> combiner;private final Function<A, R> finisher;

private final Set<Characteristics> characteristics;CollectorImpl(Supplier<A> supplier,

BiConsumer<A, T> accumulator,

BinaryOperator<A> combiner,

Function<A,R> finisher,

Set<Characteristics> characteristics) {

this.supplier = supplier;

this.accumulator = accumulator;

this.combiner = combiner;

this.finisher = finisher;

this.characteristics = characteristics;

}

CollectorImpl(Supplier<A> supplier,BiConsumer<A, T> accumulatorBinaryOperator<A> combiner,Set<Characteristics> characteristics{

 this(supplier, accumulator, combiner, castingIdentity(), characteristics);

}

// collect()方法实现

public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {

A container;

if (isParallel()

&& (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))

&& (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED)))

{

 container = collector.supplier().get();

 BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();

 forEach(u -> accumulator.accept(container, u));

}

else {

 container = evaluate(ReduceOps.makeRef(collector));

}

return collector.characteristics()

.contains(Collector.Characteristics.IDENTITY_FINISH) ? (R) container : collector.finisher().apply(container);}

断定型接口:Predicate<T> boolean test(T t):有参，但是返回值类型是固定的boolean

比如: steam().filter()中参数就是Predicate

Predicate<String> predicate = (s) -> s.length() > 0;predicate.test("foo");

// true

predicate.negate().test("foo");

// false

Predicate<Boolean> nonNull = Objects::nonNull;

Predicate<Boolean> isNull = Objects::isNull;

Predicate<String> isEmpty = String::isEmpty;

Predicate<String> isNotEmpty = isEmpty.negate();

函数型接口: Function<T,R> R apply(T t)有参有返回值的抽象方法；

比如: steam().map()中参数就是Function<? super T, ? extends R>；reduce()中参数BinaryOperator<T> (ps: BinaryOperator<T> extends BiFunction<T,T,T>)

Function<String, Integer> toInteger = Integer::valueOf;

Function<String, String> backToString = toInteger.andThen(String::valueOf);

backToString.apply("123"); // "123"

一些例子

输出年龄>25的女程序员中名字排名前3位的姓名

javaProgrammers.stream()

.filter((p) -> (p.getAge() > 25))

.filter((p) -> ("female".equals(p.getGender())))

.sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName())))

.limit(3)

//.forEach(e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary()))//涨工资

.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

工资最高的 Java programmer

Person person = javaProgrammers

.stream()

.max((p, p2) -> (p.getSalary() - p2.getSalary()))

.get()

将 Java programmers 的 first name 存放到 TreeSet

TreeSet<String> javaDevLastName = javaProgrammers

.stream()

.map(Person::getLastName)

.collect(toCollection(TreeSet::new))

计算付给 Java programmers 的所有money

int totalSalary = javaProgrammers

.parallelStream()

.mapToInt(p -> p.getSalary())

.sum();

Comparator多属性排序: 先按名字不分大小写排，再按GID倒序排，最后按年龄正序排

public static void main(String[] args) {

 List<Person> personList = getTestList();

 personList.sort(Comparator.comparing(Person::getName, String.CASE_INSENSITIVE_ORDER)

 .thenComparing(Person::getGid, (a, b) -> b.compareTo(a))

 .thenComparingInt(Person::getAge));

 personList.stream().forEach(System.out::println);

}

public static List<Person> getTestList() {

 return Lists.newArrayList(new Person("dai", "301", 10),

 new Person("dai", "303", 10), new Person("dai", "303", 8),

 new Person("dai", "303", 6), new Person("dai", "303", 11),

 new Person("dai", "302", 9), new Person("zhang", "302", 9),

 new Person("zhang", "301", 9), new Person("Li", "301", 8));

}

// 输出结果

// Person [name=dai, gid=303, age=6]// Person [name=dai, gid=303, age=8]

// Person [name=dai, gid=303, age=10]// Person [name=dai, gid=303, age=11]

// Person [name=dai, gid=302, age=9]// Person [name=dai, gid=301, age=10]

// Person [name=Li, gid=301, age=8]// Person [name=zhang, gid=302, age=9]

// Person [name=zhang, gid=301, age=9]

处理字符串

两个新的方法可在字符串类上使用: join和chars。第一个方法使用指定的分隔符，将任何数量的字符串连接为一个字符串。

String.join(":", "foobar", "foo", "bar");// => foobar:foo:bar

第二个方法chars从字符串所有字符创建数据流，所以你可以在这些字符上使用流式操作。

"foobar:foo:bar".chars().distinct().mapToObj(c -> String.valueOf((char)c)).sorted().collect(Collectors.joining());

// => :abfor

不仅仅是字符串，正则表达式模式串也能受益于数据流。我们可以分割任何模式串，并创建数据流来处理它们，而不是将字符串分割为单个字符的数据流，像下面这样:

Pattern.compile(":")

.splitAsStream("foobar:foo:bar")

.filter(s -> s.contains("bar"))

.sorted()

.collect(Collectors.joining(":"));

// => bar:foobar

此外，正则模式串可以转换为谓词。这些谓词可以像下面那样用于过滤字符串流:

Pattern pattern = Pattern.compile(".*@gmail\\.com");

Stream.of("bob@gmail.com", "alice@hotmail.com")

.filter(pattern.asPredicate())

.count();

// => 1

上面的模式串接受任何以@gmail.com结尾的字符串，并且之后用作Java8的Predicate来过滤电子邮件地址流。

Local Cache实现

public class TestLocalCache {

private static Concurrent

HashMap<Integer, Long> cache = new ConcurrentHashMap<>();

 static long fibonacci(int i) {

 if (i == 0) return i;

 if (i == 1) return 1;

 return cache.computeIfAbsent(i, (key) -> {

 System.out.println("Slow calculation of " + key);

 return fibonacci(i - 2) + fibonacci(i - 1); });

 }

 public static void main(String[] args) {

 // warm up

 for (int i = 0; i < 101; i++)

 System.out.println( "f(" + i + ") = " + fibonacci(i));

 // read -> cal

 long current = System.currentTimeMillis();

 System.out.println(fibonacci(100));

 System.out.println(System.currentTimeMillis()-current);

 }

}

集合--》取元素的一个属性--》去重---》组装成List--》返回

List<LikeDO> likeDOs=new ArrayList<LikeDO>();

List<Long> likeTidList = likeDOs.stream().map(LikeDO::getTid)

.distinct().collect(Collectors.toList());

集合--》按表达式过滤--》遍历、每个元系处理--》放入预先定义的集合中

Map<String, StkProduct> newStockName2Product = Maps.newConcurrentMap();

 stockProducts.stream().filter(stkProduct -> stkProduct.enabled).forEach(stkProduct -> {

 String newName = BCConvert.bj2qj(StringUtils.replace(stkProduct.name, " ", "")); newStockName2Product.put(newName, stkProduct);

});

Set<String> qjStockNames; qjStockNames.stream().filter(name -> !acAutomaton.getKey2link().containsKey(name)).forEach(name -> {

 String value = "";

 StkProduct stkProduct = stockNameQj2Product.get(name);

 if (stkProduct != null) { value = stkProduct.name; }

 acAutomaton.getKey2link().put(name, value);

});

集合--》map

List<ImageModel> imageModelList = null;Map<Long, String> imagesMap = null;

imagesMap = imageModelList.stream().collect(Collectors.toMap(ImageModel::getAid, o -> IMAGE_ADDRESS_PREFIX + o.getUrl()));

Map<String, String> kvMap = postDetailCacheList.stream().collect(Collectors.toMap((detailCache) -> getBbsSimplePostKey(detailCache.getTid()), JSON::toJSONString));

Map<Long, Long> pidToTid；List<String> pidKeyList = pidToTid.entrySet().stream().map((o) -> getKeyBbsReplyPid(o.getValue(), o.getKey())).collect(Collectors.toList());

DO模型---》Model模型

List<AdDO> adDOList;adDOList.stream().map(adDo -> convertAdModel(adDo))

.collect(Collectors.toList());

phones 是一个List<String>，将相同的元素分组、归类

List<String> phones=new ArrayList<String>();

phones.add("a");

phones.add("b");

phones.add("a");

phones.add("a");

phones.add("c");

phones.add("b");

Map<String, List<String>> phoneClassify = phones.stream().collect(Collectors.groupingBy(item -> item));

System.out.println(phoneClassify);

返回结果: {a=[a, a, a], b=[b, b], c=[c]}

Optional类深度解析

Optional类包含的方法

为非null的值创建一个Optional。

of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。

//调用工厂方法创建Optional实例

Optional<String> name = Optional.of("Sanaulla");

//传入参数为null，抛出NullPointerException.

Optional<String> someNull = Optional.of(null);

ofNullable

为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。

ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况。示例如下:

//下面创建了一个不包含任何值的Optional实例

//例如，值为'null'

Optional empty = Optional.ofNullable(null);

isPresent

非常容易理解:如果值存在返回true，否则返回false。

类似下面的代码:

//isPresent方法用来检查Optional实例中是否包含值

if (name.isPresent()) {

    //在Optional实例内调用get()返回已存在的值

    System.out.println(name.get());//输出Sanaulla

}

get

如果Optional有值则将其返回，否则抛出NoSuchElementException。

上面的示例中，get方法用来得到Optional实例中的值。下面我们看一个抛出NoSuchElementException的例子:

//执行下面的代码会输出: No value present

try {

    //在空的Optional实例上调用get()，抛出NoSuchElementException

    System.out.println(empty.get());

} catch (NoSuchElementException ex) {

    System.out.println(ex.getMessage());

}

ifPresent

如果Optional实例有值则为其调用consumer，否则不做处理

要理解ifPresent方法，首先需要了解Consumer类。简答地说，Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8支持不用接口直接通过lambda表达式传入参数。

如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式。类似下面的代码:

//ifPresent方法接受lambda表达式作为参数 //lambda表达式对Optional的值调用consumer进行处理。 name.ifPresent((value) -> { System.out.println("The length of the value is: " + value.length());});

orElse

如果有值则将其返回，否则返回指定的其它值。

如果Optional实例有值则将其返回，否则返回orElse方法传入的参数。示例如下:

//如果值不为null，orElse方法返回Optional实例的值。//如果为null，返回传入的消息。//输出: There is no value present!

System.out.println(empty.orElse("There is no value present!"));//输出: Sanaulla

System.out.println(name.orElse("There is some value!"));

orElseGet

orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法将传入的字符串作为默认值，orElseGet方法可以接受Supplier接口的实现用来生成默认值。示例如下:

//orElseGet与orElse方法类似，区别在于orElse传入的是默认值，

//orElseGet可以接受一个lambda表达式生成默认值。

//输出: Default Value

System.out.println(empty.orElseGet(() -> "Default Value"));

//输出: Sanaulla

System.out.println(name.orElseGet(() -> "Default Value"));

orElseThrow

如果有值则将其返回，否则抛出supplier接口创建的异常。

在orElseGet方法中，我们传入一个Supplier接口。然而，在orElseThrow中我们可以传入一个lambda表达式或方法，如果值不存在来抛出异常。示例如下:

try {

        //orElseThrow与orElse方法类似。与返回默认值不同，

         //orElseThrow会抛出lambda表达式或方法生成的异常

        empty.orElseThrow(ValueAbsentException::new);

} catch (Throwable ex) {

         //输出: No value present in the Optional instance

        System.out.println(ex.getMessage());

}

ValueAbsentException定义如下:

class ValueAbsentException extends Throwable {

     public ValueAbsentException() {    super(); }

    public ValueAbsentException(String msg) {    super(msg);  }

    @Override

    public String getMessage() {

         return "No value present in the Optional instance";

     }

}

map

map方法文档说明如下:

如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。

map方法用来对Optional实例的值执行一系列操作。通过一组实现了Function接口的lambda表达式传入操作。如果你不熟悉Function接口，可以参考我的这篇博客。map方法示例如下:

//map方法执行传入的lambda表达式参数对Optional实例的值进行修改。

//为lambda表达式的返回值创建新的Optional实例作为map方法的返回值。

Optional<String> upperName = name.map((value) -> value.toUpperCase());

System.out.println(upperName.orElse("No value found"));

flatMap

如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。flatMap与map(Funtion)方法类似，区别在于flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。

flatMap方法与map方法类似，区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T，而flatMap方法的mapping函数必须是Optional。

参照map函数，使用flatMap重写的示例如下:

//flatMap与map(Function)非常类似，区别在于传入方法的lambda表达式的返回类型。

//map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。

//但flatMap方法中的lambda表达式返回值必须是Optionl实例。

upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));

System.out.println(upperName.orElse("No value found"));//输出SANAULLA

filter

filter个方法通过传入限定条件对Optional实例的值进行过滤。文档描述如下:

如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。

读到这里，可能你已经知道如何为filter方法传入一段代码。是的，这里可以传入一个lambda表达式。对于filter函数我们应该传入实现了Predicate接口的lambda表达式。如果你不熟悉Predicate接口，可以参考这篇文章。

现在我来看看filter的各种用法，下面的示例介绍了满足限定条件和不满足两种情况:

//filter方法检查给定的Option值是否满足某些条件。

//如果满足则返回同一个Option实例，否则返回空Optional。Optional<String> longName = name.filter((value) -> value.length() > 6);

System.out.println(longName.orElse("The name is less than 6 characters"));

//输出Sanaulla//另一个例子是Optional值不满足filter指定的条件。

Optional<String> anotherName = Optional.of("Sana");

Optional<String> shortName = anotherName.filter((value) -> value.length() > 6);

//输出: name长度不足6字符System.out.println(shortName.orElse("The name is less than 6 characters"));

一些例子

一个综合例子

public class OptionalDemo {

public static void main(String[] args) {

 //创建Optional实例，也可以通过方法返回值得到。

 Optional<String> name = Optional.of("Sanaulla");

 //创建没有值的Optional实例，例如值为'null'

 Optional empty = Optional.ofNullable(null);

 //isPresent方法用来检查Optional实例是否有值。

 if (name.isPresent()) {

 //调用get()返回Optional值。

 System.out.println(name.get());

 } try {

 //在Optional实例上调用get()抛出NoSuchElementException。

 System.out.println(empty.get());

} catch (NoSuchElementException ex) {

 System.out.println(ex.getMessage());

}

//ifPresent方法接受lambda表达式参数。

//如果Optional值不为空，lambda表达式会处理并在其上执行操作。

name.ifPresent((value) -> {

 System.out.println("The length of the value is: " + value.length());

});

//如果有值orElse方法会返回Optional实例，否则返回传入的错误信息。

 System.out.println(empty.orElse("There is no value present!"));

 System.out.println(name.orElse("There is some value!"));

 //orElseGet与orElse类似，区别在于传入的默认值。

 //orElseGet接受lambda表达式生成默认值。

 System.out.println(empty.orElseGet(() -> "Default Value"));

 System.out.println(name.orElseGet(() -> "Default Value"));

try {

 //orElseThrow与orElse方法类似，区别在于返回值。

 //orElseThrow抛出由传入的lambda表达式/方法生成异常。

 empty.orElseThrow(ValueAbsentException::new);

} catch (Throwable ex) {

 System.out.println(ex.getMessage());

}

 //map方法通过传入的lambda表达式修改Optonal实例默认值。

 //lambda表达式返回值会包装为Optional实例。

 Optional<String> upperName = name.map((value) -> value.toUpperCase());

 System.out.println(upperName.orElse("No value found"));

 //flatMap与map(Funtion)非常相似，区别在于lambda表达式的返回值。

 //map方法的lambda表达式返回值可以是任何类型，但是返回值会包装成Optional实例。

 //但是flatMap方法的lambda返回值总是Optional类型。

 upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));

 System.out.println(upperName.orElse("No value found"));

 //filter方法检查Optiona值是否满足给定条件。

 //如果满足返回Optional实例值，否则返回空Optional。

 Optional<String> longName = name.filter((value) -> value.length() > 6);

 System.out.println(longName.orElse("The name is less than 6 characters"));

 //另一个示例，Optional值不满足给定条件。

 Optional<String> anotherName = Optional.of("Sana");

 Optional<String> shortName = anotherName.filter((value) -> value.length() > 6);

 System.out.println(shortName.orElse("The name is less than 6 characters"));

}

}

上述代码输出如下:

Sanaulla

No value present

The length of the value is: 8

There is no value present!

Sanaulla

Default Value

Sanaulla

No value present in the Optional instance

SANAULLA

SANAULLA

Sanaulla

The name is less than 6 characters

在 Java 8 中提高 Null 的安全性

假设我们有一个像这样的类层次结构:

class Outer {

        Nested nested;

         Nested getNested() {

                eturn nested;

        }

}

class Nested {

         Inner inner;

         Inner getInner() {

            return inner;

        }

}

class Inner {

        String foo;

         String getFoo() {

         return foo;

        }

}

解决这种结构的深层嵌套路径是有点麻烦的。我们必须编写一堆 null 检查来确保不会导致一个 NullPointerException:

Outer outer = new Outer();

if (outer != null && outer.nested != null && outer.nested.inner != null)

{

System.out.println(outer.nested.inner.foo);

}

我们可以通过利用 Java 8 的 Optional 类型来摆脱所有这些 null 检查。map 方法接收一个 Function 类型的 lambda 表达式，并自动将每个 function 的结果包装成一个 Optional 对象。这使我们能够在一行中进行多个 map 操作。Null 检查是在底层自动处理的。

Optional.of(new Outer())

    .map(Outer::getNested)

    .map(Nested::getInner)

     .map(Inner::getFoo)

    .ifPresent(System.out::println);

还有一种实现相同作用的方式就是通过利用一个 supplier 函数来解决嵌套路径的问题:

Outer obj = new Outer();resolve(() -> obj.getNested().getInner().getFoo());

.ifPresent(System.out::println);

调用 obj.getNested().getInner().getFoo()) 可能会抛出一个 NullPointerException 异常。在这种情况下，该异常将会被捕获，而该方法会返回 Optional.empty()。

public static <T> Optional<T> resolve(Supplier<T> resolver) {

try {

 T result = resolver.get();

 return Optional.ofNullable(result);

 }

 catch (NullPointerException e) {

 return Optional.empty();

 }

}

请记住，这两个解决方案可能没有传统 null 检查那么高的性能。不过在大多数情况下不会有太大问题。

翻译: ImportNew.com - 高俊阳译文链接: http://www.importnew.com/6675.html

default方法解析

什么是默认方法，为什么要有默认方法

先上例子

一个接口A，Clazz类实现了接口A。

public interface A {

        default void foo(){

         System.out.println("Calling A.foo()");

        }

}

public class Clazz implements A {

     public static void main(String[] args){

            Clazz clazz = new Clazz();       clazz.foo();//调用A.foo()

         }

}

代码是可以编译的，即使Clazz类并没有实现foo()方法。在接口A中提供了foo()方法的默认实现。

什么是默认方法

简单说，就是接口可以有实现方法，而且不需要实现类去实现其方法。只需在方法名前面加个default关键字即可。

为什么出现默认方法

为什么要有这个特性? 首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的java 8之前的集合框架没有foreach方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

java 8抽象类与接口对比

这一个功能特性出来后，很多同学都反应了，java 8的接口都有实现方法了，跟抽象类还有什么区别? 其实还是有的，请看下表对比。

多重继承的冲突

由于同一个方法可以从不同接口引入，自然而然的会有冲突的现象，默认方法判断冲突的规则如下:

1.一个声明在类里面的方法优先于任何默认方法(classes always win)

2.否则，则会优先选取路径最短的。

举例子

Case 1

    public interface A{ default void aa() {

        System.out.println("A's aa");

    }

}

    public interface B{ default void aa() {

        System.out.println("B's aa");

    }

}

public static class D implements A,B{ }

报错 Duplicate default methods named aa with the parameters () and () are inherited from the types DocApplication.B and DocApplication.A

如果一定要这么写呢，同时实现A,B并且使用A中aa? 可以这么写:

public static class D implements A,B{

    @Override

     public void aa(){

            A.super.aa();

    }

}

Case 2

public interface A{ default void aa() {

        System.out.println("A's aa");

        }

}

public interface B{ default void aa() {

    System.out.println("B's aa");

    }

}

public interface C extends A, B{ default void aa() {

    System.out.println("C's aa");

    }

}

public static class D implements A,B,C{ }

输出 C's aa

Case 3

public interface A{ default void aa() {

    System.out.println("A's aa");

    }

}

public interface C extends A{ default void aa() {

    System.out.println("C's aa");

     }

}

public static class D implements C{ }

输出 C's aa

通过Case1-3可以知道它是找唯一的最短路径的default，如果是多个那么报错。

Case 4 如果想调用A的默认函数，则用到新语法X.super.m(…),下面修改C类，实现A接口，重写一个hello方法，如下所示:

public interface A{

    default void aa() {

        System.out.println("A's aa");

     }

}

public class X implements A{

        @Override

        public void aa(){

            A.super.aa();

         }

}

输出: A's aa

Case 5

public interface A{ default void aa() {

    System.out.println("A's aa");

    }

}

public interface B{

    default void aa() {

            System.out.println("B's aa");

    }

}

public interface C extends A,B{

default void aa() {

     System.out.println("C's aa");

     }

}

public static class D implements C{

        @Override    public void aa(){

        C.super.aa();

    }

}

输出 C's aa 可见C.super表示的是C接口，同时D无法访问A,B的aa

通过Case 5也可以看出，C虽然有同一个两个最短路径的aa, 但是它自己有一个更高优先级的aa，所以不会报错; case 6 会报错

Case 6

public interface A{ default void aa() {

    System.out.println("A's aa");

    }

}

public interface B{ default void aa() {

    System.out.println("B's aa");

    }

}

public interface C extends A,B{}

总结

默认方法给予我们修改接口而不破坏原来的实现类的结构提供了便利，目前java 8的集合框架已经大量使用了默认方法来改进了，当我们最终开始使用Java 8的lambdas表达式时，提供给我们一个平滑的过渡体验。也许将来我们会在API设计中看到更多的默认方法的应用。

最后编辑于：2021.09.13 17:22:19

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,457评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,837评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,696评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,183评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,057评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,105评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,520评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,211评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,482评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,574评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,353评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,213评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,576评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,897评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,174评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,489评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,683评论 2赞 335

Java 8—Java 10 特性详解(上)

推荐阅读更多精彩内容