Java8新特性

Stream API

Stream 常见操作（后面还会有案例说明）

• Stream对象的创建
  Stream对象分为两种，一种串行的流对象，一种并行的流对象
  
• filter
  对Stream中的元素进行过滤操作，当设置条件返回true时返回相应元素
  
• map
  对Stream中的元素进行转换处理后获取。比如可以将a对象转换成b对象。 我们经常会有这样的需求：需要把某些对象的id提取出来，然后根据这些id去查询其他对象，这时可以使用此方法
  
• limit
  从Stream中获取指定数量的元素
  
• count
  仅获取Stream中元素的个数
  
• sorted
  对Stream中元素按指定规则进行排序
  
  tip:注意，如果要使用Comparator.reverseOrder()来进行自然降序，那么在流中的对象要实现Comparable< T >接口

@Data
public class Person implements Comparable<Person>{

    public long id;

    public String name;

    public Person(long id, String name){
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(Person e) {
        return name.compareTo(e.getName());
    }

    @Override
    public boolean equals(final Object obj) {
        if (obj == null) {
            return false;
        }
        final Person p = (Person) obj;
        if (this == p) {
            return true;
        } else {
            return (this.name.equals(p.name) && (this.id == p.id));
        }
    }

    @Override
    public int hashCode() {
        int hashno = 7;
        hashno = 13 * hashno + (name == null ? 0 : name.hashCode());
        return hashno;
    }

}

• skip
  跳过指定个数的Stream中元素，获取后面的元素
  
• 用collect方法将List转成map
  有时候我们需要反复对List中的对象根据id进行查询，我们可以先把该List转换为以id为key的map结构，然后再通过map.get(id)来获取对象，这样比较方便
  

使用Arrays 中的 stream() 方法，将数组转成流

使用Stream中的静态方法：of()、iterate()、generate()

使用 BufferedReader.lines() 方法，将每行内容转成流

使用 Pattern.splitAsStream() 方法，将字符串分隔成流

IDEAL中建议Pattern应该设置为静态变量

例如：

private static Pattern STRING_PATTERN = Pattern.compile(",");

流的中间操作

• 筛选与切片
  filter：过滤流中的某些元素
  limit(n)：获取n个元素
  skip(n)：跳过n元素，配合limit(n)可实现分页
  distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素

Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
.distinct() //6 7 9 8 10 12 14
.skip(2) //9 8 10 12 14
.limit(2); //9 8
newStream.forEach(System.out::println);

• 映射
  map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

		List<String> list = Arrays.asList("a,b,c", "1,2,3");
        //将每个元素转成一个新的且不带逗号的元素
        Stream<String> stream4 = list.stream().map(e -> e.replaceAll(",", ""));
        stream4.forEach(System.out::println);

        Stream<String> stream5 = list.stream().flatMap(s -> {
            //将每个元素转换成一个stream
            String[] split = s.split(",");
            Stream<String> s1 = Arrays.stream(split);
            return s1;
        });
        stream5.forEach(System.out::println);

• 排序
  sorted()：自然排序，流中元素需实现Comparable接口
  sorted(Comparator com)：定制排序，自定义Comparator排序器

List<String> list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口
list.stream().sorted().forEach(System.out::println);// aa dd ff
  
Student s1 = new Student("aa", 10);
Student s2 = new Student("bb", 20);
Student s3 = new Student("aa", 30);
Student s4 = new Student("dd", 40);
List<Student> studentList = Arrays.asList(s1, s2, s3, s4);
  
//自定义排序：先按姓名升序，姓名相同则按年龄升序
studentList.stream().sorted(
(o1, o2) -> {
if (o1.getName().equals(o2.getName())) {
return o1.getAge() - o2.getAge();
} else {
return o1.getName().compareTo(o2.getName());
}
}
).forEach(System.out::println);　

• 消费
  peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。
  
  结果：
  

流的终止操作

• 匹配、聚合操作
  allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false。
  noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false。
  anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false。
  findFirst：返回流中第一个元素。
  findAny：返回流中的任意元素。
  count：返回流中元素的总个数。
  max：返回流中元素最大值。
  min：返回流中元素最小值。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
  
boolean allMatch = list.stream().allMatch(e -> e > 10); //false
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true
  
Integer findFirst = list.stream().findFirst().get(); //1
Integer findAny = list.stream().findAny().get(); //1
  
long count = list.stream().count(); //5
Integer max = list.stream().max(Integer::compareTo).get(); //5
Integer min = list.stream().min(Integer::compareTo).get(); //1　　

• 规约操作
  Optional reduce(BinaryOperator accumulator)：第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。
  T reduce(T identity, BinaryOperator accumulator)：流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。
  U reduce(U identity,BiFunction<U, ? super T,U>accumulator,BinaryOperator combiner)：在串行流(stream)中，该方法跟第二个方法一样，即第三个参数combiner不会起作用。在并行流(parallelStream)中,我们知道流被fork join出多个线程进行执行，此时每个线程的执行流程就跟第二个方法reduce(identity,accumulator)一样，而第三个参数combiner函数，则是将每个线程的执行结果当成一个新的流，然后使用第一个方法reduce(accumulator)流程进行规约。

 List<Integer> list = new ArrayList<>(16);
        for (int i=1;i<=24;i++){
            list.add(i);
        }
        //TIP:经过测试，当元素个数小于24时，并行时线程数等于元素个数，当大于等于24时，并行时线程数为16
        //Optional reduce(BinaryOperator accumulator)：
        // 第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；
        // 第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。
        Integer v1 = list.stream().reduce((e1, e2) -> e1 + e2).get();
        System.out.println(v1);

        //T reduce(T identity, BinaryOperator accumulator)：
        // 流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，
        // 而第二个参数为流中的第一个元素。
        Integer v2 = list.stream().reduce(10, (e1, e2) -> e1 + e2);
        System.out.println(v2);
        //U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator combiner)：
        // 在串行流(stream)中，该方法跟第二个方法一样，即第三个参数combiner不会起作用。
        // 在并行流(parallelStream)中,我们知道流被fork join出多个线程进行执行，
        // 此时每个线程的执行流程就跟第二个方法reduce(identity,accumulator)一样，
        // 而第三个参数combiner函数，则是将每个线程的执行结果当成一个新的流，
        // 然后使用第一个方法reduce(accumulator)流程进行规约。
        //以下是串行流，第三个参数不起作用
        Integer v3 = list.stream().reduce(0,
                (e1, e2) -> {
                    System.out.println("stream accumulator:e1" + e1 + "e2:" + e2);
                    return e1 - e2;
                },
                (e1, e2) -> {
                    System.out.println("stream combiner:e1" + e1 + "e2:" + e2);
                    return e1 * e2;
                });
        System.out.println(v3);
        //以下是并行流
        Integer v4 = list.parallelStream().reduce(0,
                (x1, x2) -> {
                    System.out.println("parallelStream accumulator: x1:" + x1 + " x2:" + x2);
                    return x1 - x2;
                },
                (x1, x2) -> {
                    System.out.println("parallelStream combiner: x1:" + x1 + " x2:" + x2);
                    return x1 * x2;
                });
        System.out.println(v4); //197474048

收集操作

collect：接收一个Collector实例，将流中元素收集成另外一个数据结构。
Collector<T, A, R> 是一个接口，有以下5个抽象方法：

• Supplier< A > supplier()：创建一个结果容器A
• BiConsumer< A, T > accumulator()：消费型接口，第一个参数为容器A，第二个参数为流中元素T。
• BinaryOperator< A > combiner()：函数接口，该参数的作用跟上一个方法(reduce)中的combiner参数一样，将并行流中各 个子进程的运行结果(accumulator函数操作后的容器A)进行合并。
• Function<A, R> finisher()：函数式接口，参数为：容器A，返回类型为：collect方法最终想要的结果R。
• Set< Characteristics > characteristics()：返回一个不可变的Set集合，用来表明该Collector的特征。有以下三个特征：
• CONCURRENT：表示此收集器支持并发。（官方文档还有其他描述，暂时没去探索，故不作过多翻译）
• UNORDERED：表示该收集操作不会保留流中元素原有的顺序。
• IDENTITY_FINISH：表示finisher参数只是标识而已，可忽略。

Collector 工具库：Collectors

Student s1 = new Student("aa", 10,1);
Student s2 = new Student("bb", 20,2);
Student s3 = new Student("cc", 10,3);
List<Student> list = Arrays.asList(s1, s2, s3);
  
//装成list
List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList()); // [10, 20, 10]
  
//转成set
Set<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 10]
  
//转成map,注:key不能相同，否则报错
Map<String, Integer> studentMap = list.stream().collect(Collectors.toMap(Student::getName, Student::getAge)); // {cc=10, bb=20, aa=10}
  
//字符串分隔符连接
String joinName = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)
  
//聚合操作
//1.学生总数
Long count = list.stream().collect(Collectors.counting()); // 3
//2.最大年龄 (最小的minBy同理)
Integer maxAge = list.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get(); // 20
//3.所有人的年龄
Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40
//4.平均年龄
Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334
// 带上以上所有方法
DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
  
//分组
Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getType, Collectors.groupingBy(Student::getAge)));
  
//分区
//分成两部分，一部分大于10岁，一部分小于等于10岁
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));
  
//规约
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40

Stream的介绍就到这里

JAVA 中的 OPTIONAL

从 Java 8 引入的一个很有趣的特性是 Optional 类。Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException）
本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。

为什么使用OPTIONAL

因为在 Java 8 之前，任何访问对象方法或属性的调用都可能导致 NullPointerException：
在这个小示例中，如果我们需要确保不触发异常，就得在访问每一个值之前对其进行明确地检查

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

创建 Optional 实例

你可以使用 of() 和 ofNullable() 方法创建包含值的 Optional。两个方法的不同之处在于如果你把 null 值作为参数传递进去，of() 方法会抛出 NullPointerException：

如果对象即可能是 null 也可能是非 null，应该使用 ofNullable() 方法

访问 Optional 对象的值

从 Optional 实例中取回实际值对象的方法之一是使用 get() 方法

这里需要注意，这个方法会在值为 null 的时候抛出异常。要避免异常，你可以选择首先验证是否有值：可以通过isPresent()方法验证Optional中是否有值
检查是否有值的另一个选择是 ifPresent() 方法。该方法除了执行检查，还接受一个Consumer(消费者) 参数，如果对象不是空的，就对执行传入的 Lambda 表达式：

返回默认值

Optional 类提供了 API 用以返回对象值，或者在对象为空的时候返回默认值。
这里你可以使用的第一个方法是 orElse()，它的工作方式非常直接，如果有值则返回该值，否则返回传递给它的参数值：

第二个同类型的 API 是 orElseGet() —— 其行为略有不同。这个方法会在有值的时候返回值，如果没有值，它会执行作为参数传入的 Supplier(供应者) 函数式接口，并将返回其执行结果：

orElse() 和 orElseGet() 的不同之处
乍一看，这两种方法似乎起着同样的作用。然而事实并非如此。我们创建一些示例来突出二者行为上的异同
我们先来看看对象为空时他们的行为：

上面的代码中，两种方法都调用了 createNewUser() 方法，这个方法会记录一个消息并返回 User 对象。
代码输出如下：

由此可见，当对象为空而返回默认对象时，行为并无差异。

我们接下来看一个类似的示例，但这里 Optional 不为空：

这次的输出：

这个示例中，两个 Optional 对象都包含非空值，两个方法都会返回对应的非空值。不过，orElse() 方法仍然创建了 User 对象。与之相反，orElseGet() 方法不创建 User 对象。
在执行较密集的调用时，比如调用 Web 服务或数据查询，这个差异会对性能产生重大影响。

返回异常

除了 orElse() 和 orElseGet() 方法，Optional 还定义了 orElseThrow() API —— 它会在对象为空的时候抛出异常，而不是返回备选的值：

转换值

有很多种方法可以转换 Optional 的值。我们从 map() 和 flatMap() 方法开始。

map() 对值应用(调用)作为参数的函数，然后将返回的值包装在 Optional 中。这就使对返回值进行链试调用的操作成为可能 —— 这里的下一环就是 orElse()。

过滤值

除了转换值之外，Optional 类也提供了按条件“过滤”值的方法。
filter() 接受一个 Predicate 参数，返回测试结果为 true 的值。如果测试结果为 false，会返回一个空的 Optional。

Preconditions断言类（一个优雅的检验参数的工具类）

• checkArgument(boolean) ：
  功能描述：检查boolean是否为真。 用作方法中检查参数
  失败时抛出的异常类型: IllegalArgumentException
• checkNotNull(T)：
  功能描述：检查value不为null， 直接返回value；
  失败时抛出的异常类型：NullPointerException
• checkState(boolean)：
  功能描述：检查对象的一些状态，不依赖方法参数。 例如， Iterator可以用来next是否在remove之前被调用。
  失败时抛出的异常类型：IllegalStateException
• checkElementIndex(int index, int size)：
  功能描述：检查index是否为在一个长度为size的list， string或array合法的范围。 index的范围区间是[0, size)(包含0不包含size)。无需直接传入list， string或array， 只需传入大小。返回index。
  失败时抛出的异常类型：IndexOutOfBoundsException
• checkPositionIndex(int index, int size)：
  功能描述：检查位置index是否为在一个长度为size的list， string或array合法的范围。 index的范围区间是[0， size)(包含0不包含size)。无需直接传入list， string或array， 只需传入大小。返回index。
  失败时抛出的异常类型：IndexOutOfBoundsException
• checkPositionIndexes(int start, int end, int size)：
  功能描述：检查[start, end)是一个长度为size的list， string或array合法的范围子集。伴随着错误信息。
  失败时抛出的异常类型：IndexOutOfBoundsException
  下面是使用例子：

public class train4 {
    public static void main(String[] args){
       String str = null;
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Boolean result = false;
        Preconditions.checkNotNull(str,"字符串为空");
        Preconditions.checkArgument(list.size()<2,"列表长度大于2");
        Preconditions.checkState(result,"布尔值为false");
        Preconditions.checkElementIndex(9,list.size(),"数组下标越界");
        Preconditions.checkPositionIndex(9,list.size(),"数组下标越界");
        Preconditions.checkPositionIndexes(9,10,list.size());
    }
}