java8新特性lambda等

1.lambda表达式

为什么使用Lambda表达式？

lambda表达式是一个匿名函数，我们可以把lambda表达式理解为是一段可以传递的代码，可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使java的语言能力得到了提升。

lambda表达式从匿名类到lambda的转换

//匿名内部类
Runnable r1 = new Runnable(){
    @Override
    public void run(){
        System.out.println("Thanks");
    }
};

//Lambda表达式
Runnable r1 = () -> System.out.println("xxx");

//原来的使用匿名内部类作为参数传递
TreeSet<String> ts = new TreeSet<>(new Comparator<String>(){
    @Overide
    public int compare(String o1, String o2){
        return Integer.compare(o1.length(), o2.length());
    }
});

//lambda表达式作为参数传递
TreeSet<String> ts2 = new TreeSet<>(
    (o1, o2) -> Integer.compare(o1.length(), o2.length())
);

lambda表达式语法

lambda表达式在java语言中引入了一个新的语法元素和操作符。这个操作符为“->”,该操作符被称为lambda操作符或箭头操作符。它将lambda分为两个部分：

左侧：指定了lambda表达式需要的所有参数

右侧：指定了lambda体，即lambda表达式要执行的功能

语法格式：

//语法格式一：无参，无返回值，lambda体只需一条语句
Runnable r1 = () -> System.out.println("hello");

//语法格式二：lambda需要一个参数
Consumer<String> fun = (args) -> System.out.println(args);

//语法格式三：lambda只需要一个参数时，参数的小括号可以忽略
Consumer<String> fun = args -> System.out.println(args)

//语法格式四：lambda需要两个参数，并且有返回值
BinaryOperator<Long> bo = (x, y) -> {
    System.out.println("实现函数接口的方法");
    return x + y;
}

//语法格式五：当lambda体只有一条语句时，return与大括号可以省略
BinaryOperator<Long> bo = (x, y) -> x + y;

//语法格式六：数据类型可以省略，因为可由编译器推断得出，称为类型推断

2.函数式接口

只包含一个抽象方法的接口，称为函数式接口。

可以在函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否为函数式接口。

@FunctionalInterface
public interface MyNumber{
    public double getValue();
}

//函数式接口中使用泛型：
@FunctionalInterface
public interface MyFunc<T>{
    public T getValue(T t);
}

//作为参数传递lambda表达式
public String toUpperString(MyFunc<String> mf, String str){
    return mf.getValue(str);
}

String newStr = toUpperString(
    (str) -> str.toUpperCase(), "abcdef"
)

3.方法引用与构造器引用

方法引用：

当要传递给Lambda体的操作，可以使用方法引用。

使用操作符： " :: " 将方法名和对象或类的名字分隔开来

如下主要三种情况：

对象::实例方法

类::静态方法

类::实例方法

例如：

(x) -> System.out.println(x);

等同于

System.out::println


BinaryOperator<Double> bo = (x,y) -> Math.pow(x, y);
等同于：
BinaryOperator<Double> bo = Math::pow;


compare((x,y) -> x.equals(y), "abcdef", "abcdef");
等同于：
compare(String::equals, "abc","abc");

构造器引用：

格式：   ClassName::new 

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致。

例如：
Function<Integer, MyClass> fun = (n) -> new MyClass(n);
等同于
Function<Integer, MyClass> fun = MyClass::new 

数组引用：

格式：type[] :: new 

例如：

Function<Integer, Integer[]> fun = (n) -> new Integer[n];

等同于：

Function<Integer, Integer[]> fun = Integer[] :: new;

4.Stream API

流（Stream）是数据渠道，用于操作数据源（集合，数组等）所生成的元素序列。集合讲的是数据，流讲的是计算。

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

stream的操作三个步骤

①创建Stream

一个数据源（如：集合、数组），获取一个流。

java8扩展了Collection接口，提供了两个获取流的方法
default Stream<E> stream(): 返回一个顺序流
default Stream<E> parallelStream(): 返回一个并行流


由数组创建流
static <T> Stream<T> stream(T[] array): 返回一个流
重载：
public static IntStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)


由值创建流
可以用静态方法Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数
public static<T> Stream<T> of(T... values): 返回一个流


创建无限流，由函数创建流
可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流
迭代
public static<T> Stream<T> iterate(final T seed, finalUnaryOperator<T> f)
生成：
public static<T> Stream<T> generate(Supplier<T> s)

②中间操作

一个中间操作链，对数据源的数据进行处理

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会进行任何的处理。而在终止操作时一次性全部处理，称为惰性求值。

③终止操作（终端操作）

一个终止操作，执行中间操作链，并产生结果