1. 스트림 흐름
스트림을 말하기는 내가 생각하기 쉽다 / O 스트림은, 사실, 사람들은 "IO 스트림"을 의미해야한다 "흐름"처방? 자바 8에서 스트림의 새로운 개념의 도입에 의해 초래 함수형 프로그래밍 람다 덕분에 기존 라이브러리 컬렉션의 단점을 해결하기 위해 사용되어왔다.
1.1 소개
코드 세트를 통해 종래의 다단계
거의 모든 (가령,지도 컬렉션 인터페이스 또는 인터페이스 등)의 세트에 직접 또는 간접적으로 순회 작업을 지원한다. 우리가 필요한 추가하는 것 외에도 컬렉션의 요소를 운영 삭제하는 데 필요한 때, 가장 일반적으로는 탐색의 모음입니다. 예를 들면 :
import java.util.ArrayList;
import java.util.List;
public class Demo01ForEach {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
for (String name : list) {
System.out.println(name);
}
}
}이 탐색 동작의 매우 간단한 설정된다 스트링의 세트의 각각은 인쇄 출력 동작이다.
루프 단점을 통해
자바 람다 8 우리가에 더 집중할 수 있도록 무엇을해야하는지합니다 (무엇) 보다는 (방법)하는 방법 . 이제, 우리는 신중하게 예제 코드, 당신은 무엇을 찾을 수 이해 :
- 루프 구문은 "어떻게 할"입니다
- 루프 루프는 "무엇"이다
왜 자전거? 통과 할 수 있기 때문에. 그러나 사이클링을 통과하는 유일한 방법은 무엇입니까? 개별적 요소를 처리하기위한 수단을 이송, 그리고 순차 처리의 마지막에 첫 번째 사이클에서. 전자는 방법입니다 목표입니다.
당신이 세트 필터 요소 필터링하려면, 상상 :
- B의 일부로서 필터를 조건에 따라 집합;
- 두 번째 조건과 여과 서브셋 C.
어떻게 할까? 실제로 8 자바는 수 있습니다 전에 :
import java.util.ArrayList;
import java.util.List;
public class Demo02NormalFilter {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
List<String> zhangList = new ArrayList<>();
for (String name : list) {
if (name.startsWith("张")) {
zhangList.add(name);
}
}
List<String> shortList = new ArrayList<>();
for (String name : zhangList) {
if (name.length() == 3) {
shortList.add(name);
}
}
for (String name : shortList) {
System.out.println(name);
}
}
}이 코드는 3주기, 다른 기능의 각을 포함 :
- 장 먼저 모든 사람을 선별 것;
- 그런 사람들의 이름이 세 단어 상영이 있습니다;
- 마지막으로, 결과를 프린트합니다.
우리가 작동 할 수있는 요소를 설정해야 할 때마다, 항상주기,주기, 재활용해야합니다. 그것은 당연한 일이다? 아니오. 자전거는 일이 아니라 말을하는 방법입니다. 한편,이 한 번만 통과 선형 순환 수단을 사용. 당신은 처음부터 시작할 수있는 또 다른 사이클을 사용하여 다시 통과하고 싶은 경우. 즉, 람다 유도체 스트림은 더 우아한 무엇 표현을 우리가 가져올 수 있는가?
스트림 더욱 바람직하게 표현
우아한 무엇을 의미하는지 자바 스트림 API 지원의 8에서 다음보기 :
import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
list.stream()
.filter(s ‐> s.startsWith("张"))
.filter(s ‐> s.length() == 3)
.forEach(System.out::println);
}
}논리적으로 독립적 인 의미의 완벽한 디스플레이의 문자 적 의미에 직접 코드 읽기 : 획득 스트림 장을 여과하고, 필터 길이는 3 번, 상기 인쇄이다. 이 코드는 선형 순환 또는 통과 할 다른 알고리즘의 사용을 반영하지 않습니다, 우리가 정말해야 더 나은 코드의 내용을 반영하는 것입니다.
1.2 스트리밍 생각
참고 : 기존의 IO의 고정 관념 스트림을 잊어주세요!
전반적으로, 아이디어는 공장 바닥의 흐름과 유사하다 "생산 라인."
!
여러 요소가 작동 할 필요 (특히 여러 단계의 작업이) 계정 성능과 편리 성을 고려했을 때, 우리는 우선 좋은는 "모델"단계 프로그램을 싸움을하고 그것을 실행하는 프로그램을 따라야합니다.
이 프로그램은 동안 매핑, 그 요소의 집합의 처리 방식이다 여러 카운팅 동작, 이동, 필터링도된다 "기능 모델." 도 각 블록은 "유동"방법은 특정 호출하고, 다른 흐름 모델 변환에서 흐름 모델 일 수있다. 가장 오른쪽 숫자 3은 최종 결과이다.
필터지도 여기 함수 모델을 이동하는 동작, 그리고 수집 소자를 실제로 처리되지 않는다. 실행 카운트 종료에있어서, 전체 동작은 모델 특정 정책에 따라 수행 될 때만. 그리고 람다 특성의 구현에 지연에 감사합니다.
"스트림 흐름"실제로 모델 함수의 요소의 집합이고, 그것이 설정되지 않고, 데이터 구조 자체는 임의의 요소 (또는 주소 값)에 저장하지 않는다 아니다.
스트림 (흐름)은 큐가 형성되어, 데이터 소스 큐 요소의 요소는 물체의 특정 유형이다. 자바 스트림에서와 요소를 저장하지 않고, 온 디맨드 컴퓨팅. 데이터 소스의 유래. 이 배열과 같은 집합이 될 수있다.
컬렉션 다른 이전 작업, 두 가지 기본 특성이있다 스트림 작업 :
- 파이프 라인 : 중간 작업 스트림 객체 자체를 반환합니다. 이러한 동작은 유동 양식 (유창한 스타일)로서, 복수 개의 파이프로서, 직렬로 접속 될 수있다. 이것은 지연된 실행 (게으름) 및 (단락) 단락 회로로서 동작을 최적화한다.
- 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭 代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。
当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结 果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以 像链条一样排列，变成一个管道。
1.3 获取流
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> stream3 = vector.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);
}
}of 方法的参数其实是一个可变参数，所以支持数组。
1.4 常用方法
流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调 用。本小节中，终结方法包括 count 和 forEach 方法。
逐一处理：forEach
虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。
void forEach(Consumer<? super T> action);该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。
java.util.function.Consumer<T>接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。基本使用
public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.stream().forEach(name-> System.out.println(name));
}
}过滤：filter
可以通过 filter 方法将一个流转换成另一个子集流。方法签名：
Stream<T> filter(Predicate<? super T> predicate);该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。
复习Predicate接口
java.util.stream.Predicate函数式接口，其中唯一的抽象方法为：
boolean test(T t);该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法 将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。
基本使用
Stream流中的 filter 方法基本使用的代码如：
public class Test02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("张三丰");
list.add("王五");
list.add("张无忌");
list.stream()
.filter(name->name.startsWith("张"))
.forEach(name-> System.out.println(name));
}
}在这里通过Lambda表达式来指定了筛选的条件：必须姓张。
映射：map
如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
复习Function接口
此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：
R apply(T t);这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”
基本使用
public class Test03 {
public static void main(String[] args) {
String[]strs = {"11","22","33","44"};
Stream.of(strs)
.map((s -> Integer.parseInt(s)))
.forEach(i-> System.out.println(i+2));
}
}这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对 象）。
统计个数：count
正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：
long count();该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("张三丰");
list.add("王五");
list.add("张无忌");
long i = list.stream()
.filter(name->name.startsWith("张"))
.count();
System.out.println(i);//3
}取用前几个：limit
limit 方法可以对流进行截取，只取用前n个。方法签名：
Stream<T> limit(long maxSize);参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：
public class Test06 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("张三丰");
list.add("王五");
list.add("张无忌");
list.stream()
.filter(name->name.startsWith("张"))
.limit(2)
.forEach(name-> System.out.println(name));
}
}
// 结果-张三、张三丰跳过前几个：skip
如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：
Stream<T> skip(long n);如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：
public class Test07 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("张三丰");
list.add("王五");
list.add("张无忌");
list.stream()
.filter(name->name.startsWith("张"))
.skip(2)
.forEach(name-> System.out.println(name));
}
}
// 结果：张无忌组合：concat
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
该方法的基本使用代码如：
public class Test08 {
public static void main(String[] args) {
Stream<String> s1 = Stream.of("张三","李四");
Stream<String> s2 = Stream.of("王五","赵六");
Stream.concat(s1,s2).forEach(name-> System.out.println(name));
}
}
// 结果：张三、李四、王五、赵六2. 方法引用
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。那么考虑 一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？
2.1 冗余的Lambda场景
来看一个简单的函数式接口以应用Lambda表达式：
@FunctionalInterface
public interface Printable {
void print(String str);
}
在 Printable 接口当中唯一的抽象方法 print 接收一个字符串参数，目的就是为了打印显示它。那么通过Lambda 来使用它的代码很简单：
public class Demo01PrintSimple {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(s ‐> System.out.println(s));
}
}其中 printString 方法只管调用 Printable 接口的 print 方法，而并不管 print 方法的具体实现逻辑会将字符串 打印到什么地方去。而 main 方法通过Lambda表达式指定了函数式接口 Printable 的具体操作方案为：拿到 String（类型可推导，所以可省略）数据后，在控制台中输出它。
2.2 问题分析
这段代码的问题在于，对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是 System.out 对象中的 println(String) 方法。既然Lambda希望做的事情就是调用 println(String) 方法，那何必自己手动调 用呢？
2.3 用方法引用改进代码
能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“引用”过去就好了：
public class Demo02PrintRef {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(System.out::println);
}
}
请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法。
2.4方法引用符
双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方 法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。
语义分析
例如上例中， System.out 对象中有一个重载的 println(String) 方法恰好就是我们所需要的。那么对于 printString 方法的函数式接口参数，对比下面两种写法，完全等效：
- Lambda表达式写法：
s -> System.out.println(s); - 方法引用写法：
System.out::println
第一种语义是指：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。 第二种等效写法的语义是指：直接让 System.out 中的 println 方法来取代Lambda。两种写法的执行效果完全一 样，而第二种方法引用的写法复用了已有方案，更加简洁。
注:Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常
推导与省略
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都 将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。 函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。
下面这段代码将会调用 println 方法的不同重载形式，将函数式接口改为int类型的参数：
@FunctionalInterface
public interface PrintableInteger {
void print(int str);
}由于上下文变了之后可以自动推导出唯一对应的匹配重载，所以方法引用没有任何变化：
public class Demo03PrintOverload {
private static void printInteger(PrintableInteger data) {
data.print(1024);
}
public static void main(String[] args) {
printInteger(System.out::println);
}
}
这次方法引用将会自动匹配到 println(int) 的重载形式。
2.5 通过对象名引用成员方法
这是最常见的一种用法，与上例相同。如果一个类中已经存在了一个成员方法：
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
函数式接口仍然定义为：
@FunctionalInterface
public interface Printable {
void print(String str);
}那么当需要使用这个 printUpperCase 成员方法来替代 Printable 接口的Lambda的时候，已经具有了 MethodRefObject 类的对象实例，则可以通过对象名引用成员方法，代码为
public class Demo04MethodRef {
private static void printString(Printable lambda) {
lambda.print("Hello");
}
public static void main(String[] args) {
MethodRefObject obj = new MethodRefObject();
printString(obj::printUpperCase);
}
}2.6 通过类名称引用静态方法
由于在 java.lang.Math 类中已经存在了静态方法 abs ，所以当我们需要通过Lambda来调用该方法时，有两种写 法。首先是函数式接口：
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
第一种写法是使用Lambda表达式：
public class Demo05Lambda {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(‐10, n ‐> Math.abs(n));
}
}但是使用方法引用的更好写法是：
public class Demo06MethodRef {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(‐10, Math::abs);
}
}在这个例子中，下面两种写法是等效的：
Lambda表达式： n -> Math.abs(n)
方法引用： Math::abs
2.7通过super引用成员方法
如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。首先是函数式接口：
@FunctionalInterface
public interface Greetable {
void greet();
}
然后是父类 Human 的内容：
public class Human {
public void sayHello() {
System.out.println("Hello!");
}
}最后是子类 Man 的内容，其中使用了Lambda的写法：
public class Man extends Human {
@Override
public void sayHello() {
System.out.println("大家好,我是Man!");
}
//定义方法method,参数传递Greetable接口
public void method(Greetable g){
g.greet();
}
public void show(){
//调用method方法,使用Lambda表达式
method(()‐>{
//创建Human对象,调用sayHello方法
new Human().sayHello();
});
//简化Lambda
method(()‐>new Human().sayHello());
//使用super关键字代替父类对象
method(()‐>super.sayHello());
}
}
但是如果使用方法引用来调用父类中的 sayHello 方法会更好，例如另一个子类 Woman ：
public class Man extends Human {
@Override
public void sayHello() {
System.out.println("大家好,我是Man!");
}
//定义方法method,参数传递Greetable接口
public void method(Greetable g){
g.greet();
}
public void show(){
method(super::sayHello);
}
}在这个例子中，下面两种写法是等效的：
- Lambda表达式：
() -> super.sayHello() - 方法引用：
super::sayHello
2.8 通过this引用成员方法
this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用“this::成员方法”的格式来使用方 法引用。首先是简单的函数式接口：
@FunctionalInterface
public interface Richable {
void buy();
}
下面是一个丈夫 Husband 类：
public class Husband {
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() ‐> System.out.println("买套房子"));
}
}开心方法 beHappy 调用了结婚方法 marry ，后者的参数为函数式接口 Richable ，所以需要一个Lambda表达式。 但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对 Husband 丈夫类进行修改：
public class Husband {
private void buyHouse() {
System.out.println("买套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() ‐> this.buyHouse());
}
}如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：
public class Husband {
private void buyHouse() {
System.out.println("买套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(this::buyHouse);
}
}
在这个例子中，下面两种写法是等效的：
- Lambda表达式：
() -> this.buyHouse() - 方法引用：
this::buyHouse
2.9 类的构造器引用
由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用 类名称::new 的格式表示。首先是一个简单 的 Person 类：
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
사람의 객체는 함수 인터페이스를 만드는 데 사용됩니다 :
public interface PersonBuilder {
Person buildPerson(String name);
}람다 표현식을 통해이 기능 인터페이스를 사용하려면 :
public class Demo09Lambda {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("赵丽颖", name ‐> new Person(name));
}
}그러나 구성하여, 더 나은 표현을 인용 :
public class Demo10ConstructorRef {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("赵丽颖", Person::new);
}
}
이 예제에서는 다음과 같은 두 가지가 해당하는 표현입니다 :
- 람다 표현식 :
name -> new Person(name) - 방법 참조 :
Person::new
배열 2.10 생성자 레퍼런스
객체 배열 객체의 하위 클래스이므로, 동일한 구성을 갖는 약간 상이한 구문이다. 람다, 요구 된 인터페이스 기능을 이용하여 대응하는 장면의 경우 :
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);
}
이 인터페이스를 적용함에있어, 할 수 있습니다 람다 식 :
public class Demo11ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, length ‐> new int[length]);
}
}그러나 표현은 배열 참조 생성자를 사용하는 것이 좋습니다 :
public class Demo12ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, int[]::new);
}
}이 예제에서는 다음과 같은 두 가지가 해당하는 표현입니다 :
- 람다 표현식 :
length -> new int[length] - 방법 참조 :
int[]::new