生命不息，学习不止，对一切都要维持敬畏之心。
若有不正之处，请谅解和批评指正，不胜感激。
1.Lambda
1.1 函数式编程思想概述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。
做什么，而不是怎么做
我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将run方法体内的代码传递给Thread类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。
1.2 Lambda的优化
当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来启动该线程。
传统写法,代码如下：
public class Demo03Thread {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行！");
}
}).start();
}
} 本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个Runnable接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。
代码分析:
对于Runnable的匿名内部类用法，可以分析出几点内容：
Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心；- 为了指定
run的方法体，不得不需要Runnable接口的实现类； - 为了省去定义一个
RunnableImpl实现类的麻烦，不得不使用匿名内部类； - 必须覆盖重写抽象
run方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错； - 而实际上，似乎只有方法体才是关键所在。
Lambda表达式写法,代码如下：
Lambda是一个匿名函数，可以理解为一段可以传递的代码。
借助Java 8的全新语法，上述Runnable接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：
public class Demo04LambdaRunnable {
public static void main(String[] args) {
new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程
}
} 这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。
Lambda的优点 简化匿名内部类的使用，语法更加简单。
1.3 Lambda的格式
1.3.1标准格式:
Lambda省去面向对象的条条框框，格式由3个部分组成：
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为：
(参数类型 参数名称) -> { 代码语句 }格式说明：
- 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
->是新引入的语法格式，代表指向动作。- 大括号内的语法与传统方法体要求基本一致。
匿名内部类与lambda对比:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行！");
}
}).start(); () -> System.out.println("多线程任务执行！") - 前面的一对小括号即
run方法的参数（无），代表不需要任何条件； - 中间的一个箭头代表将前面的参数传递给后面的代码；
- 后面的输出语句即业务逻辑代码。
练习无参数无返回值的Lambda
public interface Fly {
public abstract void fly();
}
public class Test {
public static void main(String[] args) {
method(new Fly() {
@Override
public void fly() {
System.out.println("飞");
}
});
method(() -> {
System.out.println("就这样飞了");
});
}
public static void method(Fly f){
f.fly();
}
}
练习有参数有返回值的Lambda
下面举例演示 java.util.Comparator<t>接口的使用场景代码，其中的抽象方法定义为： </t>
- public abstract int compare(T o1, T o2);
当需要对一个对象集合进行排序时， Collections.sort方法需要一个 Comparator接口实例来指定排序的规则。 传统写法
如果使用传统的代码对 ArrayList集合进行排序，写法如下：
public class Person {
private String name;
private int age;
} public class Test {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("柳岩", 38));
list.add(new Person("唐嫣", 18));
list.add(new Person("金莲", 138));
list.add(new Person("大郎", 8));
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
System.out.println(list);
}
} 这种做法在面向对象的思想中，似乎也是“理所当然”的。其中 Comparator接口的实例（使用了匿名内部类）代表 了“按照年龄从小到大”的排序规则。
接下来使用Lambda改写:
public class Test {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("柳岩", 38));
list.add(new Person("唐嫣", 18));
list.add(new Person("金莲", 138));
list.add(new Person("大郎", 8));
// Collections.sort(list, new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o1.getAge() - o2.getAge();
// }
// });
Collections.sort(list,(Person o1,Person o2)->{
return o1.getAge() - o2.getAge();
});
System.out.println(list);
}
} 1.3.2 省略格式:
省略规则
在Lambda标准格式的基础上，使用省略写法的规则为：
- 小括号内参数的类型可以省略；
- 如果小括号内有且仅有一个参，则小括号可以省略；
- 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
备注：掌握这些省略规则后，请对应地回顾本章开头的多线程案例。
Runnable接口简化:
1. () -> System.out.println("多线程任务执行！")
Comparator接口简化:
2. Arrays.sort(array, (a, b) -> a.getAge() - b.getAge()); 以后我们调用方法时,看到参数是接口就可以考虑使用Lambda表达式,Lambda表达式相当于是对接口中抽象方法的重写.
1.4 Lambda的前提条件
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有两个问题需要特别注意：
- 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。 - 使用Lambda必须具有接口作为方法参数。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
2.函数式接口
2.1 概述
函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
备注:从应用层面来讲，Java中的Lambda可以看做是匿名内部类的简化格式，但是二者在原理上不同。
格式
只要确保接口中有且仅有一个抽象方法即可：
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
} 由于接口当中抽象方法的public abstract是可以省略的，所以定义一个函数式接口很简单：
public interface MyFunctionalInterface {
void myMethod();
} 2.1 FunctionalInterface注解
与@Override注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface。该注解可用于一个接口的定义上：
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
} 一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。不过，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
2.2 常用函数式接口
我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。它们主要在java.util.function包中被提供.
Supplier接口
java.util.function.Supplier<T>接口，它意味着"供给" , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
抽象方法 : get
仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。
public class Test {
public static void main(String[] args) {
//匿名内部类
Supplier<String> s = new Supplier<String>() {
@Override
public String get() {
return "abc";
}
};
System.out.println(s.get());
//lambda
Supplier<String> s2 = ()->"abc";
System.out.println(s2.get());
}
} 求数组元素最大值
使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。提示：接口的泛型请使用java.lang.Integer类。
代码示例:
public class DemoIntArray {
public static void main(String[] args) {
int[] array = { 10, 20, 100, 30, 40, 50 };
printMax(() -> {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
});
}
private static void printMax(Supplier<Integer> supplier) {
int max = supplier.get();
System.out.println(max);
}
} Consumer接口
java.util.function.Consumer<T>接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。
抽象方法：accept
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。基本使用如：
import java.util.function.Consumer;
public class Test {
public static void main(String[] args) {
//匿名内部类
Consumer<Integer> c = new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
};
c.accept(100);
//lambda
Consumer<Integer> c2 = (i) -> System.out.println(i);
c2.accept(200);
}
} 练习:使用Consumer接口作为方法的参数将一个字符串转换为大写并打印
public class Test {
public static void main(String[] args) {
getUpper("world", new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.toUpperCase());
}
});
getUpper("hello",(s)->{
System.out.println(s.toUpperCase());
});
}
public static void getUpper(String s ,Consumer<String> consumer){
consumer.accept(s);
}
} 默认方法：andThen
如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现效果：消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer接口中的default方法andThen。下面是JDK的源代码：
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
} 备注：
java.util.Objects的requireNonNull静态方法将会在参数为null时主动抛出NullPointerException异常。这省去了重复编写if语句和抛出空指针异常的麻烦。
要想实现组合，需要两个或多个Lambda表达式即可，而andThen的语义正是“一步接一步”操作。例如两个步骤组合的情况：
public class Test {
public static void main(String[] args) {
printString("Hello", new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.toUpperCase());
}
}, new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.toLowerCase());
}
});
printString("hello",
s-> System.out.println(s.toUpperCase()),
s -> System.out.println(s.toLowerCase()));
}
public static void printString(String s ,Consumer<String> consumer,Consumer<String> consumer2){
// consumer.accept(s);
// consumer2.accept(s);
consumer.andThen(consumer2).accept(s);
}
} 运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的组合。
Function接口
java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有进有出，所以称为“函数Function”。
抽象方法：apply
Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。使用的场景例如：将String类型转换为Integer类型。
public class Test {
public static void main(String[] args) {
Function<String,Integer> f = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s);
}
};
Integer apply = f.apply("100");
System.out.println(apply);
Function<String,Integer> f2 = s -> Integer.parseInt(s);
System.out.println(f2.apply("200"));
}
} 练习: 使用Function接口作为方法参数 将一个存储字符串名字的集合,转换为一个存储Person对象的集合
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("柳岩");
list.add("唐嫣");
change(list, new Function<String, Person>() {
@Override
public Person apply(String s) {
return new Person(s);
}
});
change(list,s -> new Person(s));
}
public static void change(List<String> list , Function<String, Person> f){
List<Person> personList = new ArrayList<>();
for (String name : list) {
Person p = f.apply(name);
personList.add(p);
}
System.out.println(personList);
}
} 默认方法：andThen
Function接口中有一个默认的andThen方法，用来进行组合操作。JDK源代码如：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
} 该方法同样用于“先做什么，再做什么”的场景，和Consumer中的andThen差不多：
public class Test {
public static void main(String[] args) {
method("10",s -> {
return Integer.parseInt(s);
},s->{
return s*=10;
});
}
//将字符串转为 int 在扩大10倍
private static void method( String str,Function<String, Integer> one, Function<Integer, Integer> two) {
// Integer i = one.apply(str);
// Integer num = two.apply(i);
// System.out.println(num);
Integer num = one.andThen(two).apply(str);
System.out.println(num);
}
} 第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过andThen按照前后顺序组合到了一起。
请注意，Function的前置条件泛型和后置条件泛型可以相同。
Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T>接口。
抽象方法：test
Predicate接口中包含一个抽象方法：boolean test(T t)。用于条件判断的场景：
public class Test {
public static void main(String[] args) {
Predicate<String> p = new Predicate<String>() {
@Override
public boolean test(String s) {
return s.endsWith(".java");
}
};
System.out.println(p.test("abc.java"));
Predicate<String> p2 = s -> s.endsWith(".java");
System.out.println(p2.test("aaa.java"));
}
} 练习:使用Predicate作为方法参数 判断一个字符串是否很长 如果长度大于5则为true 小于5则为false
public class Test {
public static void main(String[] args) {
isLong("aaa", new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length()>=5;
}
});
isLong("bbbaa",s -> s.length()>=5);
}
public static void isLong(String s , Predicate<String> p){
boolean test = p.test(s);
System.out.println(test);
}
} 默认方法：and
既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个Predicate条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法and。其JDK源码为：
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
} 如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：
public class Test {
public static void main(String[] args) {
method("Helloworld" ,s -> s.contains("H"), s -> s.contains("W"));
}
private static void method(String str ,Predicate<String> one, Predicate<String> two) {
boolean b1 = one.test(str);
boolean b2 = two.test(str);
System.out.println("字符串符合要求吗：" + (b1 && b2));
boolean isValid = one.and(two).test(str);
System.out.println("字符串符合要求吗：" + isValid);
}
} 默认方法：or
与and的“与”类似，默认方法or实现逻辑关系中的“或”。JDK源码为：
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
} 如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变：
public class Test {
public static void main(String[] args) {
method("Helloworld" ,s -> s.contains("H"), s -> s.contains("W"));
}
private static void method(String str ,Predicate<String> one, Predicate<String> two) {
boolean b1 = one.test(str);
boolean b2 = two.test(str);
System.out.println("字符串符合要求吗：" + (b1 || b2));
boolean isValid = one.and(two).test(str);
System.out.println("字符串符合要求吗：" + isValid);
}
} 默认方法：negate
“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法negate的JDK源代码为：
default Predicate<T> negate() {
return (t) -> !test(t);
} 从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在test方法调用之前调用negate方法，正如and和or方法一样：
public class Test {
public static void main(String[] args) {
isLong("aaa", new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length()<5;
}
});
isLong("bbbaa",s -> s.length()>=5);
}
public static void isLong(String s , Predicate<String> p){
boolean test = p.test(s);
System.out.println(!test);
boolean b2 = p.negate().test(s);
System.out.println(b2);
}
} 3.Stream流
在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
4.1 引言
传统集合的多步遍历代码
几乎所有的集合（如Collection接口或Map接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：
public class Demo10ForEach {
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);
}
}
} 这是一段非常简单的集合遍历操作：对集合中的每一个字符串都进行打印输出操作。
循环遍历的弊端
Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行了对比说明。现在，我们仔细体会一下上例代码，可以发现：
- for循环的语法就是“怎么做”
- for循环的循环体才是“做什么”
为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环。前者是目的，后者是方式。
试想一下，如果希望对集合中的元素进行筛选过滤：
- 将集合A根据条件一过滤为子集B；
- 然后再根据条件二过滤为子集C。
那怎么办？在Java 8之前的做法可能为：
这段代码中含有三个循环，每一个作用不同：
- 首先筛选所有姓张的人；
- 然后筛选名字有三个字的人；
- 最后进行对结果进行打印输出。
public class Demo11NormalFilter {
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);
}
}
} 每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。
那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？
Stream的更优写法
下面来看一下借助Java 8的Stream API，什么才叫优雅：
public class Demo12StreamFilter {
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(s -> System.out.println(s));
}
} 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。
4.2 流式思想概述
注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。
当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。
Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。Stream是流式思想,相当于工厂的流水线,对集合中的数据进行加工处理
4.3 获取流方式
java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：
- 所有的
Collection集合都可以通过stream默认方法获取流； Stream接口的静态方法of可以获取数组对应的流。
方式1 : 根据Collection获取流
首先，java.util.Collection接口中加入了default方法stream用来获取流，所以其所有实现类均可获取流。
import java.util.*;
import java.util.stream.Stream;
/*
获取Stream流的方式
1.Collection中 方法
Stream stream()
2.Stream接口 中静态方法
of(T...t) 向Stream中添加多个数据
*/
public class Demo13GetStream {
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();
}
} 方式2: 根据数组获取流
如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以Stream接口中提供了静态方法of，使用很简单：
import java.util.stream.Stream;
public class Demo14GetStream {
public static void main(String[] args) {
String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
Stream<String> stream = Stream.of(array);
}
} 备注：
of方法的参数其实是一个可变参数，所以支持数组。
4.4 常用方法
流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：
- 终结方法：返回值类型不再是
Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。本小节中，终结方法包括count和forEach方法。 - 非终结方法：返回值类型仍然是
Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为非终结方法。）
备注：本小节之外的更多方法，请自行参考API文档。
forEach : 逐一处理
虽然方法名字叫forEach，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的。
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。例如：
import java.util.stream.Stream;
public class Demo15StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷爷","蛇精","蝎子精");
//Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
stream.forEach((String str)->{System.out.println(str);});
}
} 在这里，lambda表达式(String str)->{System.out.println(str);}就是一个Consumer函数式接口的示例。
filter：过滤
可以通过filter方法将一个流转换成另一个子集流。方法声明：
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个Predicate函数式接口参数（可以是一个Lambda）作为筛选条件。
基本使用**
Stream流中的filter方法基本使用的代码如：
public class Demo16StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
}
} 在这里通过Lambda表达式来指定了筛选的条件：必须姓张。
count：统计个数
正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：
long count();
该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：
public class Demo17StreamCount {
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方法可以对流进行截取，只取用前n个。方法签名：
Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象
参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。
基本使用：
import java.util.stream.Stream;
public class Demo18StreamLimit {
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): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
基本使用：
import java.util.stream.Stream;
public class Demo19StreamSkip {
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): 把参数列表中的两个Stream流对象a和b,合并成一个新的Stream流对象
备注：这是一个静态方法，与
java.lang.String当中的concat方法是不同的。
该方法的基本使用代码如：
import java.util.stream.Stream;
public class Demo20StreamConcat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("张无忌");
Stream<String> streamB = Stream.of("张翠山");
Stream<String> result = Stream.concat(streamA, streamB);
}
} distinct:去重
如果需要去除重复数据，可以使用 distinct方法。方法签名：
Stream<T> distinct()
基本使用:
public class Test {
public static void main(String[] args) {
Stream.of(22, 33, 22, 11, 33)
.distinct()
.forEach(s-> System.out.println(s));
}
} map:映射
如果需要将流中的元素映射到另一个流中，可以使用 map方法。方法签名：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口需要一个 Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
基本使用:
public class Test {
public static void main(String[] args) {
Stream<String> original = Stream.of("11", "22", "33");
Stream<Integer> result = original.map(Integer::parseInt);
result.forEach(s -> System.out.println(s + 10));
}
}4.5 Stream综合案例
现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下若干操作步骤：
- 第一个队伍只要名字为3个字的成员姓名；
- 第一个队伍筛选之后只要前3个人；
- 第二个队伍只要姓张的成员姓名；
- 第二个队伍筛选之后不要前2个人；
- 将两个队伍合并为一个队伍；
- 打印整个队伍的姓名信息。
两个队伍（集合）的代码如下：
public class Demo21ArrayListNames {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("老子");
one.add("庄子");
one.add("孙子");
one.add("洪七公");
List<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("张三丰");
two.add("赵丽颖");
two.add("张二狗");
two.add("张天爱");
two.add("张三");
// ....
}
} 传统方式
使用for循环 , 示例代码:
public class Demo22ArrayListNames {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
// ...
List<String> two = new ArrayList<>();
// ...
// 第一个队伍只要名字为3个字的成员姓名；
List<String> oneA = new ArrayList<>();
for (String name : one) {
if (name.length() == 3) {
oneA.add(name);
}
}
// 第一个队伍筛选之后只要前3个人；
List<String> oneB = new ArrayList<>();
for (int i = 0; i < 3; i++) {
oneB.add(oneA.get(i));
}
// 第二个队伍只要姓张的成员姓名；
List<String> twoA = new ArrayList<>();
for (String name : two) {
if (name.startsWith("张")) {
twoA.add(name);
}
}
// 第二个队伍筛选之后不要前2个人；
List<String> twoB = new ArrayList<>();
for (int i = 2; i < twoA.size(); i++) {
twoB.add(twoA.get(i));
}
// 将两个队伍合并为一个队伍；
List<String> totalNames = new ArrayList<>();
totalNames.addAll(oneB);
totalNames.addAll(twoB);
// 打印整个队伍的姓名信息。
for (String name : totalNames) {
System.out.println(name);
}
}
} 运行结果为：
宋远桥 苏星河 洪七公 张二狗 张天爱 张三
Stream方式
等效的Stream流式处理代码为：
public class Demo23StreamNames {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
// ...
List<String> two = new ArrayList<>();
// ...
// 第一个队伍只要名字为3个字的成员姓名；
// 第一个队伍筛选之后只要前3个人；
Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
// 第二个队伍只要姓张的成员姓名；
// 第二个队伍筛选之后不要前2个人；
Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
// 将两个队伍合并为一个队伍；
// 根据姓名创建Person对象；
// 打印整个队伍的Person对象信息。
Stream.concat(streamOne, streamTwo).forEach(s->System.out.println(s));
}
} 运行效果完全一样：
宋远桥 苏星河 洪七公 张二狗 张天爱 张三
4.6 函数拼接与终结方法[了解]
在上述介绍的各种方法中，凡是返回值仍然为Stream接口的为函数拼接方法，它们支持链式调用；而返回值不再为Stream接口的为终结方法，不再支持链式调用。如下表所示：
| 方法名 | 方法作用 | 方法种类 | 是否支持链式调用 |
|---|---|---|---|
| count | 统计个数 | 终结 | 否 |
| forEach | 逐一处理 | 终结 | 否 |
| filter | 过滤 | 函数拼接 | 是 |
| limit | 取用前几个 | 函数拼接 | 是 |
| skip | 跳过前几个 | 函数拼接 | 是 |
| concat | 组合 | 函数拼接 | 是 |
4.7 Stream流中的结果到集合中
Stream流提供 collect方法，其参数需要一个 java.util.stream.Collector<T,A, R>接口对象来指定收集到哪 种集合中。java.util.stream.Collectors 类提供一些方法，可以作为 Collector`接口的实例：
- public static <t> Collector<T, ?, List<t>> toList()：转换为 List集合。 </t></t>
- public static <t> Collector<T, ?, Set<t>> toSet()：转换为 Set集合。 </t></t>
下面是这两个方法的基本使用代码
public class Test {
public static void main(String[] args) {
Stream<String> stream = Stream.of("aa", "bb", "cc");
//转换为list集合
List<String> list = stream.collect(Collectors.toList());
//转换为set集合
Set<String> set = stream.collect(Collectors.toSet());
//转换为ArrayList集合
ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
//转换为HashSet集合
HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
}
} 4.8 Stream流中的结果到数组中
Stream提供 toArray方法来将结果放到一个数组中，返回值类型是Object[]的：
Object[] toArray();
其使用场景如：
public class Test {
public static void main(String[] args) {
Stream<String> stream = Stream.of("aa", "bb", "cc");
Object[] objects = stream.toArray();
System.out.println(Arrays.toString(objects));
String[] strings = stream.toArray(String[]::new);
System.out.println(Arrays.toString(strings));
}
} 
京公网安备 11010502036488号