Table of Contents generated with DocToc (opens new window)

• java8其它新特性
  • Lambda表达式
  • 函数式(Functional)接口
    • 概述
    • 如何理解函数式接口
    • java内置四大核心函数式接口
    • 其他接口
    • 方法引用与构造器引用
      • 方法引用
      • 构造器引用
      • 数组引用
  • Stream API
    • 创建Stream方式一：通过集合
    • 创建Stream方式二：通过数组
    • 创建Stream方式三：通过Stream的of()
    • 创建Stream方式四：创建无限流
  • 流的一些中间操作
    • 筛选与切片
    • 映射
    • 排序
  • 流的终止操作
    • 1 匹配与查找
    • 2 规约
    • 6 收集
  • Optional类

---

java8其它新特性

Lambda表达式

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

lambda表达式的本质：就是作为(函数式)接口的实例

总结：

-> 左边：lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数，其一对()也可省略

-> 右边：lambda体应该使用一对{}包裹 ;如果lambda体只有一条执行语句(可能是return语句)，可以省略这一对{}和return关键字

函数式(Functional)接口

概述

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常(即:非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明)。
• 我们可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时 javadoc也会包含一条声明，说明这个接口是一个函数式接口。
• 在java.util.function包下定义了Java8的丰富的函数式接口

如何理解函数式接口

• Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程)
• 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
• 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
• 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

java内置四大核心函数式接口

• 消费型接口Consumer< T> void accept(T t)
• 供给型接口Supplier< T> T get()
• 函数型接口Function<T,R> R apply(T t)
• 断定型接口Predicate< T> booLean test(T t)

代码示例:

public class Java8Test {
    @Test
    public void test1(){
        happyTime(263, money -> System.out.println("花了"+money));
    }
    public void happyTime(double money, Consumer<Double> consumer){
        consumer.accept(money);
    }

    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
        List<String> filterList = filterString(list, s -> s.contains("京"));
        System.out.println(filterList);
    }
    /**
     * 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
     * @param list
     * @param predicate
     */
    public List<String> filterString(List<String> list, Predicate<String> predicate){
        List<String> filterList = new ArrayList<>();
        for (String s : list) {
            if (predicate.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }
}

其他接口

方法引用与构造器引用

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
• 要求：实现接口的抽象方法的参数列表和返回值类型们必须与方法医用的方法的参数列表和返回值类型保持一致！
• 格式：使用操作符 "::" 将类(或对象) 与方法名分隔开来
• 如下三种主要使用情况：
  • 对象::实例(非静态)方法名
  • 类::静态方法名
  • 类::实例(非静态)方法名

构造器引用

@Test
    public void test3(){
        //构造器引用 无参 public Person()
        Supplier<Person> sup = Person::new;
        Person person = sup.get();
        System.out.println(person);
        //构造器引用 有1个参 public Person(Integer id)
        Function<Integer,Person> function = Person::new;
        Person person1 = function.apply(230);
        System.out.println(person1);
        //构造器引用 有2个参 public Person(String name, Integer age)
        BiFunction<String,Integer,Person> biFunction = Person::new;
        Person person2 = biFunction.apply("张迪凯", 20);
        System.out.println(person2);
    }

数组引用

@Test
    public void test4(){
        Function<Integer, String[]> function = String[]::new;
        String[] strings = function.apply(5);
        System.out.println(Arrays.toString(strings));
    }

Stream API

Java8中有两大最为重要的改变。第一个是Lambda表达式;另外一个则是Stream API。

Stream APl ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQt的数据就需要Java层面去处理。

Stream和 Collection集合的区别:Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。

• Stream自己不会储存元素
• Stream不会改变源对象。相反它们返回一个持有结果的新Stream
• Stream操作是延迟执行的，这意味着它们会等到需要结果的时候才执行

创建Stream方式一：通过集合

Java8中的Collection接口被扩展，提供了两个获取流的方法:

default Stream< E> stream():返回一个顺序流

default Stream< E> parallelStream():返回一个并行流

创建Stream方式二：通过数组

Java8中的Arrays的静态方法stream()可以获取数组流:

static< T> Stream< T>stream(Tarray):返回一个流

重载形式，能够处理对应的基本数据类型的数组:

• public static IntStream stream(int[] array)
• public static LongStream stream(long[]array)
• public static DoubleStream stream(double[]array)

创建Stream方式三：通过Stream的of()

可以调用Stream类的静态方法of()，通过显式值创建一个流。它可以接收任意数量的参数

public static< T> Stream< T> of(T ...values) 返回一个流

创建Stream方式四：创建无限流

可以使用静态方法Stream.iterate() 和 Stream.generate() 创建无限流

• 迭代

  public static< T> Stream< T> iterate(final T seed, final UnaryOperator< T> f )

• 生成

  public static< T> Stream< T> generate(Supplier< T>s)

生成示例：

@Test
    public void test(){
        //1.通过集合创建流
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream<Integer> stream = list.stream();
        Stream<Integer> parallelStream = list.parallelStream();

        //2.通过数组创建流
        int[] arr = new int[]{1,2,3,4,5};
        IntStream stream1 = Arrays.stream(arr);

        //3.通过Stream.of()
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);

        //4.创建无限流
        //迭代
        Stream.iterate(0, t->t+2).limit(5).forEach(System.out::println);

        //生成
        Stream.generate(Math::random).limit(5).forEach(System.out::println);
    }

流的一些中间操作

筛选与切片

/**
     * 测试Stream的中间操作
     */
    @Test
    public void test2(){
        List<Employee> list = getEmployeesData();
        Stream<Employee> stream = list.stream();
        //filter(Predicate p) 接收lambda 从流中排除某些元素
        stream.filter(e->e.getSalary()>7000).forEach(System.out::println);
        System.out.println("=========");
        //limit(n) 截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("=========");

        //skip(n)跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("=========");

        //distinct：筛选 通过流所生成元素的hashCode()和equals()去除重复元素
        list.add(new Employee(1010,"刘强东",40,8000.0));
        list.add(new Employee(1010,"刘强东",40,8000.0));
        list.add(new Employee(1010,"刘强东",40,8000.0));
        list.add(new Employee(1010,"刘强东",40,8000.0));
        list.stream().distinct().forEach(System.out::println);
        System.out.println("=========");
    }

• filter(Predicate p) 接收lambda 从流中排除某些元素
• limit(n) 截断流，使其元素不超过给定数量
• skip(n)跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流
• distinct：筛选 通过流所生成元素的hashCode()和equals()去除重复元素

映射

• map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
• mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
• mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
• flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

/**
     * 测试映射操作
     */
    @Test
    public void test3(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee", "ff");
        //map(Function f) 接收一个函数作为参数，将元素转换成其他形式或提取信息
        //该函数会被应用到每一个元素上，并将其映射成一个新的元素
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        //获取姓名长度大于3的员工的姓名
        List<Employee> employees = getEmployeesData();
        employees.stream().map(Employee::getName).filter(name->name.length()>3)
                .forEach(System.out::println);

        System.out.println("==============");

        //flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，
        // 然后 把所有流连接成一个流
        list.stream().flatMap(StreamTest::stringToStream).forEach(System.out::println);
        //输出结果是aabbccddeeff

    }

排序

• sorted() 产生一个新流，其中按自然顺序排序
• sorted(Comparator comparator) 产生一个新流，其中按比较器顺序排序

示例：

 @Test
    public void test4(){
        //自然排序
        List<Integer> list = Arrays.asList(12, 56, 2, 589, 6, 22, 33, 0, -2);
        list.stream().sorted().forEach(System.out::println);

        //Comparator
        List<Employee> employees = getEmployeesData();
//        employees.stream().sorted((e1,e2)->Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);
//        employees.stream().sorted(Comparator.comparingInt(Employee::getAge)).forEach(System.out::println);
        employees.stream().sorted((e1,e2)->{
            int compare = Integer.compare(e1.getAge(), e2.getAge());
            if (compare!=0){
                return compare;
            }else {
                return Double.compare(e1.getSalary(), e2.getSalary());
            }
        }).forEach(System.out::println);
    }

流的终止操作

• 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void
• 流进行了终止操作后，不能再次使用

1 匹配与查找

• allMatch(Predicate p) 检查是否匹配所有元素
• anyMatch(Predicate p) 检查是否至少匹配一个元素
• noneMatch(Predicate p) 检查是否没有匹配所有元素
• findFirst() 返回第一个元素
• findAny() 返回当前流中的任意元素
• count() 返回流中的元素的总个数
• max(Comparatot c) 返回流中最大值
• min(Comparatot c) 返回流中最小值
• forEach(Cosumer c) 内部迭代

代码示例：

/**
     * 1 匹配与查找
     */
    @Test
    public void test1(){
        List<Employee> employees = StreamTest.getEmployeesData();
        //allMatch(Predicate p) 检查是否匹配所有元素 false
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println("allMatch = " + allMatch);

        //anyMatch(Predicate p) 检查是否至少匹配一个元素 true
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 8000);
        System.out.println("anyMatch = " + anyMatch);

        //noneMatch(Predicate p) 检查是否没有匹配所有元素 true 没有姓张的
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("张"));
        System.out.println("noneMatch = " + noneMatch);

        //findFirst() 返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println("employee = " + employee);

        //findAny() 返回当前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println("employee1 = " + employee1);
    }

    @Test
    public void test2(){
        List<Employee> employees = StreamTest.getEmployeesData();
        //count() 返回流中的元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
        //max(Comparatot c) 返回流中最大值
        Optional<Double> maxSalary = employees.stream().map(e -> e.getSalary()).max(Double::compareTo);
        System.out.println("maxSalary = " + maxSalary);
        //min(Comparatot c) 返回流中最小值
//        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        Optional<Employee> employee = employees.stream().min(Comparator.comparingDouble(Employee::getSalary));
        System.out.println("工资最低的员工"+employee);

        //forEach(Cosumer c) 内部迭代
        employees.stream().forEach(System.out::println);
    }

2 规约

• reduce(T identity,BinaryOperator b) ：可以将流中元素反复结合起来，得到一个值，返回T
• reduce(BinaryOperator b) ：可以将流中元素反复结合起来，得到一个值，返回Optional< T>

备注: map和 reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名。

代码示例：

/**
     * 规约
     */
    @Test
    public void test3(){
        //reduce(T iden,BinaryOperator b)：可以将流中元素反复结合起来，得到一个值，返回T
        //计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println("sum = " + sum);

        //reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值，返回Optional<T>
        //计算所有员工工资的总和
        List<Employee> employees = StreamTest.getEmployeesData();
//        Optional<Double> total = employees.stream().map(Employee::getSalary).reduce((s1,s2)->s1+s2);
        Optional<Double> total = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println("total = " + total);
    }
}

6 收集

Collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map)。另外，Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例,具体方法与实例如下表:

• toList：返回类型List T> 把流中的元素收集到List
• toSet：返回类型Set< T> 把流中的元素收集到Set
• toCollection：返回类型Collection< T> 把流中的元素收集到创建的集合
• counting：返回类型 Long，计算流中元素的个数
• summingInt：返回类型 Integer，对流中元素的整数属性求和
• averagingInt：返回类型Double，计算流中元素Integer属性的平均值
• summarizingInt：返回类型IntSummaryStatistics，收集流中Integer属性的统计值。如：平均值

代码示例：

/**
     * 3 收集
     */
    @Test
    public void test4(){
        List<Employee> employees = StreamTest.getEmployeesData();
        List<Employee> list = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        Set<Employee> set = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        Map<String, String> map = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toMap(Employee::getName, Employee::getName));
    }

Optional类

• 到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java8类库的一部分。
• Optional< T>类(java.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null 表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
• Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional提供很多有用的方法，这样我们就不用显式进行空值检测了

• 创建Optional类对象的方法：
  • Optional.of(T t):创建一个 Optional实例，t必须非空;
  • Optional.empty():创建一个空的Optional 实例
  • Optional.ofNullable(T t): t可以为null
• 判断Optional容器中是否包含对象
  • boolean isPresent():判断是否包含对象
  • void ifPresent(Consumer<? super T> consumer):如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
• 获取Optional容器的对象
  • T get():如果调用对象包含值，返回该值，否则抛异常
  • T orElse(T other):如果有值则将其返回，否则返回orElse()方法参数里指定的other对象。
  • T orElseGet(Supplier<? extends T> other):如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
  • T orElseThrow(Supplier<? extends X> exceptionSupplier):如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。