Java8新特性

一、Lambda表达式

Lambda表达式是一个匿名函数，即没有函数名的函数。从动态引用到动态定义，可以简化写法。

对比两种写法：

Lambda表达式的语法如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

还有如下特性：

• 可选类型声明：不需要声明参数类型，由编译器统一识别参数值
• 可选参数的圆括号：一个参数时可以不要写括号，多个参数需要写括号,如下面例子中的2例和3例
• 可选的大括号：只有一行时可以不用写大括号
• 可选的返回关键字：如果只有一个返回值，则编译器可以自动返回，如例1，没有写成return 5;

示例：

1. 不需要参数,返回值为5

() -> 5

2. 接受一个参数，返回乘以2的值

x -> x*2

3. 接受2个参数，并返回他们的差

(x,y) -> x-y

4. 接受两个int类型的整数，返回他们的和

(int x,int y) -> x+y

5. 接受一个String类型的参数，不返回值

(String x) -> System.out.print(x)

Java8给我们提供了一些接口，可供使用：

• Predicate 有参数、条件判断
• Function<T, R> 有参数、有返回值
• Consumer 无返回值
• Supplier 无参数、有返回值

还有很多，都在java.util.function包里面。

示例：

//java7写法
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println(new Date());
    }
}).start();

//java8 写法
new Thread(()-> System.out.println(new Date())).start();

二、Stream

Stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素 ： 特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。
• 数据源：流的来源。 可以是集合，数组，I/O channel， 产生器 generator 等。
• 聚合操作 类似 SQL 语句一样的操作， 比如 filter, map, reduce, find, match, sorted 等。
• 和以前的 Collection 操作不同， Stream 操作还有两个基础的特征：
• Pipelining：中间操作都会返回流对象本身。这样多个操作可以串联成一个管道， 如同流式风格(fluent style)。这样做可以对操作进行优化，比如延迟执行(laziness)和短路((short-circuiting)。
• 内部迭代：以前对集合遍历都是通过 Iterator 或者 For-Each 的方式, 显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

创建Stream的几种方式：

1. 使用数组

   String[] array={"a","b","c","d"};
   Stream<String> stream1 = Stream.of(array);
   Stream<String> stream2 = Arrays.stream(array);

2. 使用Collections

List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.stream();

3. 使用Stream.generate()

 Stream<String> stream3 = Stream.generate(() -> "love").limit(10);

4. 使用Stream.iterate()

Stream<BigInteger> bigIntStream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE)).limit(10);

5. 其他API创建

Stream stream = Stream.concat(stream1, stream2);
Stream<String> wordStream = Pattern.compile("\\W").splitAsStream(sentence);

Stream操作：

中间操作：

1. 选择与过滤

• filter(Predicate p) 接收Lambda，从流中排除某些元素
• distinct() 筛选，通过流生成的元素的hashCode()与equals()去除重复元素
• limit(long maxSize)截断流，使其元素不超过指定数量
• skip(long n)跳过元素，返回一个扔掉了前n个元素的流。

2. 映射

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

3. 排序

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

终止操作：

1. 查找与匹配

• allMatch 检查是否匹配所有元素
• anyMatch 检查是否至少匹配一个元素
• noneMatch 检查是否没有匹配的元素
• findFirst 返回第一个元素
• findAny 返回当前流中的任意元素
• count 返回流中元素的总个数
• max 返回流中的最大值
• min 返回流中的最小值

2. 规约 reduce
3. 收集 collect

• toList 把流中元素收集到List
• toSet 把流中元素收集到set
• toCollection Collection 把流中元素收集到创建的集合
• count 计算流中元素的个数
• summaryStatistics 统计最大最小平均值

4. 迭代

• forEach

代码示例：

 public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        list.stream().filter(x->x>2).forEach(System.out::println);

        list.stream().mapToDouble(x->Double.valueOf(x)).forEach((b)-> System.out.println(b));

        list.stream().flatMap(x->Arrays.stream(new Integer[]{x})).forEach(System.out::println);

        boolean flag = list.stream().anyMatch(x -> x % 3 == 0);

        long count = list.stream().count();
        System.out.println("元素个数:"+count);

        long sum = list.stream().collect(Collectors.summarizingInt(x -> x)).getSum();
        System.out.println("总元素的和是:"+sum);

        Integer integer = list.stream().reduce((a, b) -> a + b).get();
        System.out.println("规约求和："+integer);

    }