标签：类的声明 类继承 类型 fun compareto 运算 spl 二次 .com
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
以下是一个 java.util.Optional<T> 类的声明：
public final class Optional<T> extends Object
序号 方法 & 描述 1 static <T> Optional<T> empty() 返回空的 Optional 实例。 2 boolean equals(Object obj) 判断其他对象是否等于 Optional。 3 Optional<T> filter(Predicate<? super <T> predicate) 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。 4 <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) 如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional 5 T get() 如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException 6 int hashCode() 返回存在值的哈希码，如果值不存在 返回 0。 7 void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。 8 boolean isPresent() 如果值存在则方法会返回true，否则返回 false。 9 <U>Optional<U> map(Function<? super T,? extends U> mapper) 如果存在该值，提供的映射方法，如果返回非null，返回一个Optional描述结果。 10 static <T> Optional<T> of(T value) 返回一个指定非null值的Optional。 11 static <T> Optional<T> ofNullable(T value) 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。 12 T orElse(T other) 如果存在该值，返回值， 否则返回 other。 13 T orElseGet(Supplier<? extends T> other) 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。 14 <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常 15 String toString() 返回一个Optional的非空字符串，用来调试
注意： 这些方法是从 java.lang.Object 类继承来的。
import java.util.Optional; public class Java8Tester { public static void main(String args[]){ Java8Tester java8Tester = new Java8Tester(); Integer value1 = null; Integer value2 = new Integer(10); // Optional.ofNullable - 允许传递为 null 参数 Optional<Integer> a = Optional.ofNullable(value1); // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException Optional<Integer> b = Optional.of(value2); System.out.println(java8Tester.sum(a,b)); } public Integer sum(Optional<Integer> a, Optional<Integer> b){ // Optional.isPresent - 判断值是否存在 System.out.println("第一个参数值存在: " + a.isPresent()); System.out.println("第二个参数值存在: " + b.isPresent()); // Optional.orElse - 如果值存在，返回它，否则返回默认值 Integer value1 = a.orElse(new Integer(0)); //Optional.get - 获取值，值需要存在 Integer value2 = b.get(); return value1 + value2; } }
输出
第一个参数值存在: false 第二个参数值存在: true 10
Stream（流）是一个来自数据源的元素队列并支持聚合操作
和以前的Collection操作不同， Stream操作还有两个基础的特征：
由于操作过程完全由Java处理，因此它可以根据当前硬件环境选择最优的方法处理，我们也无需编写复杂又容易出错的多线程代码了。
在 Java 8 中, 集合接口有两个方法来生成流：
stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。
流的操作分为两种，分别为中间操作 和 终端操作。
中间操作
当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。
中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。
中间操作都是filter()、distinct()、sorted()、map()、flatMap()等，其一般是对数据集的整理（过滤、排序、匹配、抽取等）
终端操作
当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终端操作。
终端操作将返回一个执行结果，这就是你想要的数据。
终止方法往往是完成对数据集中数据的处理，如forEach()，还有allMatch()、anyMatch()、findAny()、 findFirst()，数值计算类的方法有sum、max、min、average等等。终止方法也可以是对集合的处理，如reduce()、 collect()等等。reduce()方法的处理方式一般是每次都产生新的数据集，而collect()方法是在原数据集的基础上进行更新，过程中不产生新的数据集。
使用流一共需要三步：
准备一个数据源
1、集合 这种数据源较为常用，通过stream()方法即可获取流对象： List<Person> list = new ArrayList<Person>(); Stream<Person> stream = list.stream(); 2、数组 通过Arrays类提供的静态函数stream()获取数组的流对象： String[] names = {"chaimm","peter","john"}; Stream<String> stream = Arrays.stream(names); 3.直接将几个值变成流对象： Stream<String> stream = Stream.of("chaimm","peter","john"); 4、文件 try(Stream lines = Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){ //可对lines做一些操作 }catch(IOException e){ } PS：Java7简化了IO操作，把打开IO操作放在try后的括号中即可省略关闭IO的代码。
执行中间操作 【中间操作可以有多个，它们可以串连起来形成流水线。】、执行终端操作 【执行终端操作后本次流结束，你将获得一个执行结果。】
// 1. Array String[] strArray1 = stream.toArray(String[]::new); // 2. Collection【list,set,stack】 List<String> list1 = stream.collect(Collectors.toList()); List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new)); Set set1 = stream.collect(Collectors.toSet()); Stack stack1 = stream.collect(Collectors.toCollection(Stack::new)); // 3. String String str = stream.collect(Collectors.joining()).toString();
6、使用
6.1、筛选filter
filter函数接收一个Lambda表达式作为参数，该表达式返回boolean，在执行过程中，流将元素逐一输送给filter，并筛选出执行结果为true的元素。
List<Person> result = list.stream() .filter(p->p.getIsStudent()) .collect(toList());
6.2、去重distinct
返回一个有唯一元素的stream(根据stream中元素的equals实现)。内部需要重写equals
List<Person> result = list.stream()
.distinct()
.collect(toList());
6.3、截取limit
截取流的前N个元素：
List<Person> result = list.stream() .limit(3) .collect(toList());
6.4、跳过【skip】
跳过流的前n个
List<Person> result = list.stream() .skip(3) .collect(toList());
6.5、映射【map】
对流中的每个元素执行一个函数，使得元素转换成另一种类型输出。流会将每一个元素输送给map函数，并执行map中的Lambda表达式，最后将执行结果存入一个新的流中。
final List<Integer> numbers = Arrays.asList(1, 2, 3, 4); final List<Integer> doubleNumbers = numbers.stream().map(number -> number * 2).collect(Collectors.toList()); System.out.println(doubleNumbers);
6.6、合并【flagmap】
List<String> list = new ArrayList<String>(); list.add("I am a boy"); list.add("I love the girl"); list.add("But the girl loves another girl"); list.stream() .map(line->line.split(" ")) .flagmap(Arrays::stream) .distinct() .collect(toList());
6.7、排序【sorted】
不指定一个自定义的Comparator则会使用默认排序。
result = list.stream() .sorted((a,b)->a.getAge().compareTo(b.getAge())) .collect(toList()); result = list.stream() .sorted(Comparator.comparing(Person::getAge)) .collect(toList());
6.8、是否匹配任意一个元素anyMatch
anyMatch用于判断流中是否存在至少一个元素满足指定的条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。
//如，判断list中是否有学生： boolean result = list.stream().anyMatch(Person::isStudent); //等价于 boolean result = list.stream().anyMatch(p->p.getIsStudent());
6.9、是否匹配所有元素：allMatch
allMatch用于判断流中的所有元素是否都满足指定条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。
如，判断是否所有人都是学生： boolean result = list.stream().allMatch(Person::isStudent);
6.10、是否未匹配所有元素：noneMatch
noneMatch与allMatch恰恰相反，它用于判断流中的所有元素是否都不满足指定条件：
boolean result = list.stream().noneMatch(Person::isStudent);
6.11、获取任一元素findAny
findAny能够从流中随便选一个元素出来，它返回一个Optional类型的元素。
Optional<Person> person = list.stream().findAny();
6.12、获取第一个元素
Optional<Person> person = list.stream().findFirst();
Stream.reduce，常用的方法有average, sum, min, max, and count，返回单个的结果值，并且reduce操作每处理一个元素总是创建一个新值
归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。
在流中，reduce函数能实现归约。
T reduce(T identity, BinaryOperatoraccumulator)
// identity：它允许用户提供一个循环计算的初始值。accumulator：计算的累加器，其方法签名为apply(T t,U u)，在该reduce方法中第一个参数t为上次函数计算的返回值，
// 第二个参数u为Stream中的元素，这个函数把这两个值计算apply，得到的和会被赋值给下次执行这个方法的第一个参数。有点绕看代码： int value = Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item); Assert.assertSame(value, 110); /* 或者使用方法引用 */ value = Stream.of(1, 2, 3, 4).reduce(100, Integer::sum); //这个例子中100即为计算初始值，每次相加计算值都会传递到下一次计算的第一个参数。
reduce还有其它两个重载方法：
Optionalreduce(BinaryOperatoraccumulator):与上面定义基本一样，无计算初始值，所以他返回的是一个Optional。
U reduce(U identity, BiFunction accumulator, BinaryOperator combiner):与前面两个参数的reduce方法几乎一致，你只要注意到BinaryOperator其实实现了BiFunction和BinaryOperator两个接口。
Integer类还提供了min、max等一系列数值操作，当流中元素为数值类型时可以直接使用。
8、 聚合操作-Stream.collect
收集器用来将经过筛选、映射的流进行最后的整理，可以使得最后的结果以不同的形式展现。
流由一个个元素组成，归约就是将一个个元素“折叠”成一个值，如求和、求最值、求平均值都是归约操作。
Collectors
toList()、toSet、joining、mapping、sum、age、group、max、min
8.1、count
long count = list.stream().count(); Long count2 = list.stream().collect(Collectors.counting());
8.2、max，min
Optional<Person> personOptionalMax = list.stream().max(Comparator.comparing(p -> p.getAge())); Optional<Person> personOptionalMax1 = list.stream().collect(maxBy(Comparator.comparing(Person::getAge))); Optional<Person> personOptionalMin = list.stream().min(Comparator.comparing(p -> p.getAge())); Optional<Person> personOptionalMin1 = list.stream().collect(minBy(Comparator.comparing(Person::getAge)));
8.3、sum、avg
Integer sum = list.stream().collect(summingInt(Person::getAge));
Double avg = list.stream().collect(averagingInt(Person::getAge));
8.4、summarizingInt一次性计算所有归约操作
Collectors.summarizingInt函数能一次性将最值、均值、总和、元素个数全部计算出来，并存储在对象IntSummaryStatisics中。
可以通过该对象的getXXX()函数获取这些值。
DoubleSummaryStatistics dss = list.stream().collect(Collectors.summarizingDouble(p->p.getAge())); double average=dss.getAverage(); double max=dss.getMax(); double min=dss.getMin(); double sum1=dss.getSum(); double count1=dss.getCount();
8.5、Join
String names = list.stream().collect(Collectors.joining()); //每个字符串默认分隔符为空格，若需要指定分隔符，则在joining中加入参数即可： String names = list.stream().collect(Collectors.joining(", "));
8.6、自定义规约
若你需要自定义一个归约操作，那么需要使用Collectors.reducing函数，该函数接收三个参数：
第一个参数为归约的初始值
第二个参数为归约操作进行的字段
第三个参数为归约操作的过程
//例：计算所有人的年龄总和 Optional<Integer> sumAge = list.stream().collect(Collectors.reducing(0,Person::getAge,(i,j)->i+j));
Collectors.reducing方法还提供了一个单参数的重载形式。
你只需传一个归约的操作过程给该方法即可(即第三个参数)，其他两个参数均使用默认值。
第一个参数默认为流的第一个元素
第二个参数默认为流的元素
这就意味着，当前流的元素类型为数值类型，并且是你要进行归约的对象。
//例：采用单参数的reducing计算所有人的年龄总和 Optional<Integer> sumAge = list.stream().filter(Person::getAge).collect(Collectors.reducing((i,j)->i+j));
8.7、结果收集
Collectors.toList()、Collectors.toMap、Collectors.toSet
注意：其中Collectors.toMap方法的第三个参数为键值重复处理策略，如果不传入第三个参数，当有相同的键时，会抛出一个IlleageStateException。
8.8、分组和分区
对具有相同特性的值进行分组是一个很常见的任务，Collectors提供了一个groupingBy方法，方法签名为：
Collector<T,?,Map> groupingBy(Function classifier, Collector downstream)
classifier：一个获取Stream元素中主键方法。downstream：一个操作对应分组后的结果的方法。这里可进行很多分组后的二次操作，如再次分组，统计等
//示例 根据年龄分组 Map<Integer, List<Person>> collect = list.stream().collect(Collectors.groupingBy(p -> p.getAge(), Collectors.toList()));
多级分组
//先按照年龄分组，再分组内再次按照名称分组 Map<Integer, Map<String, List<Person>>> collect1 = list.stream().collect( Collectors.groupingBy(p -> p.getAge(), Collectors.groupingBy(t -> t.getName())));
分区是分组的一种特殊情况，它只能分成true、false两组。
分区使用partitioningBy方法，该方法接收一个Lambda表达式，该表达是必须返回boolean类型，partitioningBy方法会将Lambda返回结果为true和false的元素各分成一组。
partitioningBy方法返回的结果为Map< Boolean,List< T>>。
此外，partitioningBy方法和groupingBy方法一样，也可以接收第二个参数，实现二级分区或对分区结果进行统计。
groupingBy与partitioningBy，它们的区别是partitioningBy为键值为Boolean类型的groupingBy，这种情况下它比groupingBy更有效率。
9、数值流的使用
采用reduce进行数值操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作，因此效率较低。 当流操作为纯数值操作时，使用数值流能获得较高的效率。
1、将普通流转换成数值流
StreamAPI提供了三种数值流：IntStream、DoubleStream、LongStream，也提供了将普通流转换成数值流的三种方法：mapToInt、mapToDouble、mapToLong。
如，将Person中的age转换成数值流：
IntStream stream = list.stream().mapToInt(Person::getAge);
2 数值计算
每种数值流都提供了数值计算函数，如max、min、sum等。
如，找出最大的年龄：
OptionalInt maxAge = list.stream().mapToInt(Person::getAge).max();
由于数值流可能为空，并且给空的数值流计算最大值是没有意义的，因此max函数返回OptionalInt，它是Optional的一个子类，能够判断流是否为空，并对流为空的情况作相应的处理。
此外，mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为：OptionalInt、OptionalDouble、OptionalLong
010-jdk1.8版本新特性二-Optional类，Stream流
标签：类的声明 类继承 类型 fun compareto 运算 spl 二次 .com
原文地址：https://www.cnblogs.com/bjlhx/p/9733040.html
