Java高级重点知识点-25-Stream流、方法引用

Stream流

通过循环遍历来讲解流的优势；
要求：筛选所有姓张的人；然后筛选名字有三个字的人； 最后进行对结果进行打印输出。

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);}}
}

这段代码中我们可以看到，我们首先通过遍历集合list来获取到了所有姓张的人，然后我们通过遍历shortList集合来获取到了名字长度为三个字的人。最终打印出了名字三个字并且姓张的人，很显然这个过程很麻烦，下面我们来看一下Stream流式写法；

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);}
}

这里我们可以看到我们通过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 可以获取数组对应的流。

1. 根据Collection获取流

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();}
}

2. 根据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();}
}

3. 根据数组获取流
   Stream 接口中提供了静态方法of来实现数组的流化。

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);

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);

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); 将流中的元素映射到另一个流中

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类型，也就是说可以用来获取更大的集合对象的大小。

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个

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 方法获取一个截取之后的新流

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) 两个流合并成为一个流

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场景：

1. 首先定义一个函数式接口

@FunctionalInterface
public interface Printable {void print(String str);
}

2. 通过lambda表达式来使用该字符串

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) 方法。因此我们不必自己动手调用该方法。使用方法引用即可。

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的孪生兄弟。因此方法引用同时也是可推导可省略的；

通过对象名引用成员方法

1. 首先定义一个函数式接口

@FunctionalInterface
public interface Printable {void print(String str);
}

2. 创建一个实现了指定方法的类

public class MethodRefObject {public void printUpperCase(String str) {System.out.println(str.toUpperCase());}
}

3. 测试

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);}
}

这里我们可以看到，我们通过方法引用了MethodRefObject中的printUpperCase（String str）方法，并没有通过lambda表达式来实现，而是使用一个已经实现了类中的方法，与我们引用System.out对象中的println（）方法类似。

通过类名称引用静态方法

通过java.lang.Math 类中的静态方法 abs举例

1. 声明一个函数式接口

@FunctionalInterface
public interface Calcable {int calc(int num);
}

2. 使用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));}
}

3. 使用方法引用的方式来实现

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调用时，也可以使用方法引用进行替代。

1. 定义函数式接口

@FunctionalInterface
public interface Greetable {void greet();
}

2. 定义父类

public class Human {public void sayHello() {System.out.println("Hello!");}
}

3. 定义子类(Lambda)

public class Man extends Human {@Overridepublic 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();});//简化Lambdamethod(()->new Human().sayHello());//使用super关键字代替父类对象method(()->super.sayHello());}
}

4. 定义子类（方法引用）

public class Man extends Human {@Overridepublic void sayHello() {System.out.println("大家好,我是Man!");}//定义方法method,参数传递Greetable接口public void method(Greetable g){g.greet();}public void show(){method(super::sayHello);}
}

通过this引用成员方法

这里与父类super类似，直接展示通过方法引用的写法

public class Husband {private void buyHouse() {System.out.println("买套房子");}private void marry(Richable lambda) {lambda.buy();}public void beHappy() {marry(this::buyHouse);}
}

类的构造器引用

1. 定义一个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;}
}

2. 定义用来创建Person 对象的函数式接口

public interface PersonBuilder {Person buildPerson(String name);
}

3. 使用Lambda表达式创建指定名称的Person对象

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));}
}

4. 使用方法引用创建指定名称的Person对象

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 的子类对象，所以同样具有构造器

1. 定义一个函数式接口

@FunctionalInterface
public interface ArrayBuilder {int[] buildArray(int length);
}

2. 使用lambda表达式应用该接口

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]);}
}

3. 使用方法引用应用该接口

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热爱者了解文章，作者将会持续更新中，期待各位友友的关注和收藏。。。