文章目录
Stream流
通过循环遍历来讲解流的优势;
要求:筛选所有姓张的人;然后筛选名字有三个字的人; 最后进行对结果进行打印输出。
java
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);
}
}
}
![](https://i-blog.csdnimg.cn/direct/37944d99b1a54cc0afa44f2dad7bc1f9.png)
这段代码中我们可以看到,我们首先通过遍历集合list来获取到了所有姓张的人,然后我们通过遍历shortList集合来获取到了名字长度为三个字的人。最终打印出了名字三个字并且姓张的人,很显然这个过程很麻烦,下面我们来看一下Stream流式写法;
java
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);
}
}
![](https://i-blog.csdnimg.cn/direct/f312fbb1e0b546f69a2d3a870734b0d7.png)
这里我们可以看到我们通过filter()过滤方法过滤掉了姓张且名字长度为3的人,并且通过方法引用来输出打印。
流式思想概述
流式思想类似于工厂车间的"生产流水线"
Stream流"其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何元素(或其地址值)。
Stream(流)是一个来自数据源的元素队列
- 元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
数据源 流的来源。 可以是集合,数组 等。 - Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluentstyle)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
- 内部迭代: 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式,流可以直接调用遍历方法。
获取流
java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口
- 所有的 Collection 集合都可以通过 stream 默认方法获取流;
- Stream 接口的静态方法 of 可以获取数组对应的流。
- 根据Collection获取流
java
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等情况
java
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来实现数组的流化。
java
import java.util.stream.Stream;
public class Demo06GetStream {
public static void main(String[] args) {
String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
Stream<String> stream = Stream.of(array);
}
}
常用方法
- 延迟方法:返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方法均为延迟方法。)
- 终结方法:返回值类型不再是 Stream 接口自身类型的方法,因此不再支持类似 StringBuilder 那样的链式调用。
逐一处理:forEach
void forEach(Consumer<? super T> action)
;
java
import java.util.stream.Stream;
public class StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("张三", "张三丰", "周姐");
stream.forEach(name‐> System.out.println(name));
}
}
过滤:filter
Stream<T> filter(Predicate<? super T> predicate)
;
java
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("张"));
}
}
映射:map
<R> Stream<R> map(Function<? super T, ? extends R> mapper)
; 将流中的元素映射到另一个流中
java
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));
}
}
统计个数:count
long count()
; 这里的返回值是long类型,不再和旧集合一样是int类型,也就是说可以用来获取更大的集合对象的大小。
java
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
Stream<T> limit(long maxSize)
; 对流进行截取,只取用前maxSize个
java
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
Stream<T> skip(long n)
; skip 方法获取一个截取之后的新流
java
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
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
两个流合并成为一个流
java
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);
}
}
方法引用
冗余的Lambda场景:
- 首先定义一个函数式接口
java
@FunctionalInterface
public interface Printable {
void print(String str);
}
- 通过lambda表达式来使用该字符串
java
public class PrintSimple {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(s ‐> System.out.println(s));
}
}
对字符串进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是 System.out对象中的 println(String) 方法。因此我们不必自己动手调用该方法。使用方法引用即可。
java
public class Demo02PrintRef {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(System.out::println);
}
}
方法引用符
双冒号 :: 为引用运算符,而它所在的表达式被称为方法引用。
- Lambda表达式写法: s -> System.out.println(s); 语义:拿到参数之后经Lambda之手,继而传递给 System.out.println 方法去处理。
- 方法引用写法: System.out::println 语义: 直接让 System.out 中的 println 方法来取代Lambda。
注意 : Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常
函数式接口是Lambda的基础,而方法引用是Lambda的孪生兄弟。因此方法引用同时也是可推导可省略的;
通过对象名引用成员方法
- 首先定义一个函数式接口
java
@FunctionalInterface
public interface Printable {
void print(String str);
}
- 创建一个实现了指定方法的类
java
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
- 测试
java
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);
}
}
![](https://i-blog.csdnimg.cn/direct/0d3f90628fd04e88ace6a06da72d32ec.png)
这里我们可以看到,我们通过方法引用了MethodRefObject中的printUpperCase(String str)方法,并没有通过lambda表达式来实现,而是使用一个已经实现了类中的方法,与我们引用System.out对象中的println()方法类似。
通过类名称引用静态方法
通过java.lang.Math 类中的静态方法 abs举例
- 声明一个函数式接口
java
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
- 使用lambda表达式来实现
java
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));
}
}
- 使用方法引用的方式来实现
java
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);
}
}
通过super引用成员方法
如果存在继承关系,当Lambda中需要出现super调用时,也可以使用方法引用进行替代。
- 定义函数式接口
java
@FunctionalInterface
public interface Greetable {
void greet();
}
- 定义父类
java
public class Human {
public void sayHello() {
System.out.println("Hello!");
}
}
- 定义子类(Lambda)
java
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());
}
}
- 定义子类(方法引用)
java
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);
}
}
通过this引用成员方法
这里与父类super类似,直接展示通过方法引用的写法
java
public class Husband {
private void buyHouse() {
System.out.println("买套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(this::buyHouse);
}
}
类的构造器引用
- 定义一个Person类
java
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;
}
}
- 定义用来创建Person 对象的函数式接口
java
public interface PersonBuilder {
Person buildPerson(String name);
}
- 使用Lambda表达式创建指定名称的Person对象
java
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));
}
}
- 使用方法引用创建指定名称的Person对象
java
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);
}
}
数组的构造器引用
数组也是 Object 的子类对象,所以同样具有构造器
- 定义一个函数式接口
java
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);
}
- 使用lambda表达式应用该接口
java
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]);
}
}
- 使用方法引用应用该接口
java
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);
}
}
欢迎java热爱者了解文章,作者将会持续更新中,期待各位友友的关注和收藏。。。