Java8（JDK8）{Lambda表达式、函数式接口、stream流、方法引用}

Lambda表达式

使得代码更加的简洁，不再有“不得不创建接口对象”的束缚，也不再有“抽象方法覆盖覆写”的负担。
核心代码：

( )  -> System.out.println("aaaaaaaa~")

语义分析：

Lambda标准格式：
Lambda省去了面向对象的条条框框，格式由三个部分组成；
（参数类型 参数名称） -> {代码语句}

格式说明：
1.小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
2.-> 是新引入的语法格式，代表指向动作。
3.大括号内的语法与传统方法体要求基本一致。

Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

Lambda使用的三类语法：

• （params）-> 单行语句；
• （params） -> 表达式；
• （params） -> 多行语句；//多行语句要用return返回

方法引用

1、类之中静态方法的引用； 类名称 :: 静态方法名称；
2、类之中普通方法的引用； 实例化对象 :: 普通方法；
3、类之中构造方法的引用； 类名称 :: new；
4、特定类型的任意方法的引用； 类名称 :: 方法名称；

掌握1至3的方法引用，例如：(以下两种写法完全等效)

• Lambda表达式写法： s -> System.out.println(s);
• 方法引用写法：System.out::println

推导与省略
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都 将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。既是不管什么样的参数类型，什么样的重载形式，最后都会自动匹配到相应的println()输出形式。

通过super引用成员方法：
（）-> super.成员方法(); 等效于 super: :成员方法();

通过this引用成员方法：
（）-> this.成员方法(); 等效于 this: :成员方法();

函数式接口

函数式接口：有且仅有一个抽象方法的接口，称为“函数式接口”。
也就是说有两个及也上的抽象方法的接口就不适用Lambda表达式。

格式

修饰符 interface 接口名称 {
 	public abstract 返回值类型 方法名称(可选参数信息);
  // 其他非抽象方法内容 
  }

default方法定义普通方法，static方法来定义由接口直接调用的方法。
一个已经实现好的接口，现在又希望增加新方法，但这个新方法又不希望影响到子类，这种情况下可以使用default方法。这个default方法并不要求子类强制进行实现，static方法亦是如此，不强制进行实现。
但是如果子类继承父类又继承接口时，父类和接口中都有同样的方法，此时子类会使用父类的方法。

@FunctionalInterface

注解作用：该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。

函数式编程

Lambda的延迟执行

使用Lambda作为参数和返回值

常用的函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

Supplier—供给型接口

java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
范例：

import java.util.function.Supplier; 

public class Demo08Supplier { 
private static String getString(Supplier<String> function) { 
		return function.get(); 
		}
public static void main(String[] args) { 
		String msgA = "Hello";
		String msgB = "World"; 
		System.out.println(getString(() ‐> msgA + msgB)); 
		} 
}

Consumer—消费型接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

抽象方法： accept
Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

import java.util.function.Consumer; 

public class Demo09Consumer { 
private static void consumeString(Consumer<String> function) {
	 function.accept("Hello"); 
	}
public static void main(String[] args) {
	 consumeString(s ‐> System.out.println(s)); 
	 } 
 }

运行结果：
Hello

默认方法： andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。

import java.util.function.Consumer; 

public class Demo10ConsumerAndThen { 
private static void consumeString(Consumer<String> one, Consumer<String> two) { 
			  one.andThen(two).accept("Hello"); 
}
public static void main(String[] args) { 
consumeString( s ‐> System.out.println(s.toUpperCase()), 
			   s ‐> System.out.println(s.toLowerCase())); 
	} 
}

运行结果：
将会首先打印完全大写的HELLO，然后打印完全小写的hello。

Predicate—断言型接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。

抽象方法：test
Predicate 接口中包含一个抽象方法： boolean test(T t) 。
用于条件判断的场景，范例代码如下：

import java.util.function.Predicate; 

public class Demo15PredicateTest { 
private static void method(Predicate<String> predicate) { 
	boolean veryLong = predicate.test("HelloWorld"); 
	System.out.println("字符串很长吗：" + veryLong); 	
}
public static void main(String[] args) { 
	method(s ‐> s.length() > 5); 
	} 
}

默认方法：and
既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果时，可以使用default方法 and 。

范例：

import java.util.function.Predicate;

public class Demo16PredicateAnd { 
private static void method(Predicate<String> one, Predicate<String> two) { 
boolean isValid = one.and(two).test("Helloworld"); 
   	 System.out.println("字符串符合要求吗：" + isValid); 
}
public static void main(String[] args) {
	 method(s ‐> s.contains("H"), s ‐> s.contains("W")); 
	 }
}

默认方法：or
与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。
范例类似默认方法and的。

默认方法：negate
“与”、“或”已经了解了，剩下的“非”（取反）也会简单。

Function—功能性接口

接口代码

@FunctionalInterface
public interface Function<T,R>{
	public R apply(T,t);//接受数据而后返回处理结果
}

抽象方法：apply
Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。 使用的场景例如：将 String 类型转换为 Integer 类型。

范例：实现功能型接口的使用
本次引用Integer类的parseInt()方法，这个方法要求接受String型数据，而后返回int型数据。

import java.util.function.Function; 

public class Demo11FunctionApply { 
private static void method(Function<String, Integer> function) { 
	int num = function.apply("10"); 
	System.out.println(num + 20); 
}
public static void main(String[] args) { 
	method(s ‐>Integer.parseInt(s)); 
}
 }

Stream流

“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何 元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列元素是特定类型的对象，形成一个队列。

• Java中的Stream并不会存储元素，而是按需计算。
• 数据源流的来源。，可以是集合，数组等。

Stream操作有两个基础的特征：

• Pipelining： 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭 代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。） 获取一个流非常简单，有以下几种常用的方式：

• 所有的 Collection 集合都可以通过 stream 默认方法获取流；
• Stream 接口的静态方法 of 可以获取数组对应的流。

根据 Collection获取流
首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

import java.util.*; 
import java.util.stream.Stream; 
public class Demo04GetStream { 
public static void main(String[] args) {
	 List<String> list = new ArrayList<>();
 // ... 
	Stream<String> stream1 = list.stream(); 

	Set<String> set = new HashSet<>(); 
// ... 
	Stream<String> stream2 = set.stream(); 

	Vector<String> vector = new Vector<>(); 
// ...
	Stream<String> stream2 = set.stream(); 

根据Map获取流
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key、value或entry等情况：

import java.util.HashMap; 
import java.util.Map; 
import java.util.stream.Stream; 

public class Demo05GetStream { 
public static void main(String[] args) { 
Map<String, String> map = new HashMap<>(); 
// ... 
Stream<String> keyStream = map.keySet().stream(); 
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); 
	} 
}

根据数组获取流
如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of ，使用很简单：

import java.util.stream.Stream;

public class Demo06GetStream { 
	public static void main(String[] args) { 
		String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
 			Stream<String> stream = Stream.of(array); 
	} 
}

常用方法

逐一处理：forEach

方法签名：

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。

基本使用：

import java.util.stream.Stream; 
public class Demo12StreamForEach { 
	public static void main(String[] args) { 
		Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若"); 
		stream.forEach(name‐> System.out.println(name)); 
	} 
}

过滤filter
可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

基本使用：

import java.util.stream.Stream; 

public class Demo07StreamFilter { 
public static void main(String[] args) { 
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
Stream<String> result = original.filter(s ‐> s.startsWith("张")); 
	} 
}

在Stream接口里面有一个收集器：

public <R,A>R collect(Collector<? super T,A,R> collector);

代码例子：
List abc = 集合.stream().filter((x) -> x.contains(“a”)).collect(Collectors.toList());

映射map
如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

基本使用：

import java.util.stream.Stream; 
public class Demo08StreamMap { 
public static void main(String[] args) {
 	Stream<String> original = Stream.of("10", "12", "18"); 
 	Stream<Integer> result = original.map(
 	str‐>Integer.parseInt(str)); 
 	} 
}

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。

统计个数：count
正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数： long count()；

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。
基本使用：

import java.util.stream.Stream; 

public class Demo09StreamCount { 
public static void main(String[] args) { 
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); Stream<String> result = original.filter(s ‐> s.startsWith("张")); 
		System.out.println(result.count()); // 2 
	} 
}

取用前几个：limit
limit()方法可以对流进行截取，只取前几个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

import java.util.stream.Stream; 

public class Demo10StreamLimit { 
public static void main(String[] args) { 
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
	Stream<String> result = original.limit(2); 
		System.out.println(result.count()); // 2 
	} 
}

跳过前几个：skip
如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

import java.util.stream.Stream; 

public class Demo11StreamSkip { 
public static void main(String[] args) { 
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
	Stream<String> result = original.skip(2); 
		System.out.println(result.count()); // 1 
	}
}

组合：concat
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

基本使用：

import java.util.stream.Stream; 

public class Demo12StreamConcat { 
public static void main(String[] args) { 
	Stream<String> streamA = Stream.of("张无忌"); 
	Stream<String> streamB = Stream.of("张翠山"); 
	Stream<String> result = Stream.concat(streamA, streamB); 
	} 
}