函数式接口与Stream流的用法
1.函数式接口
函数接口在java中是指:有且仅有一个抽象方法的接口。函数式接口,即适用于函数式编程场景使用。而java中的函数式编程体现的就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,java中的Lambda才能顺利的推导。
样式:
@FunctionalInterface//用于约束函数式接口的格式
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
@FunctionalInterface:与@Override注解作用相似,java8中专门为函数式接口引入的注解,作用就是判断这个接口是否是一个函数式接口,不加@FunctionalInterface注解也不影响,只要接口中只有一个抽象方法,那么就是函数式接口。
以下简单介绍一下常用的函数式接口用法,主要为了下面的Stream流方法中的函数式接口
1.1 常用函数式接口
-
Supplier 生产型接口
抽象方法:T get() : 返回一个T类型的对象
public static void main(String[] args) { String s = "aa"; System.out.println(getString(() -> s)); } private static String getString(Supplier<String> function) { return function.get(); }
-
Consumer 消费型接口
抽象方法:void accept(T t) : 使用传入的T类型的对象 t
public static void main(String[] args) { consume(s -> System.out.println(s)); } private static void consume(Consumer<String> function) { function.accept("aa"); }
-
Predicate 判断型接口
抽象方法: boolean test(T t) : 判断传入的对象t是否满足某种条件
public static void main(String[] args) { judge(s-> s.equals("aa")); } private static void judge(Predicate<String> predicate) { boolean flag = predicate.test("aa"); }
-
Function<T,R> 转换型接口 把T类型的对象转换成R类型的对象
抽象方法:R apply(T t) : 把传入的T类型的对象 t ,转换成 R类型的结果返回
public static void main(String[] args) { toInteger(s -> Integer.parseInt(s)); } private static void toInteger(Function<String, Integer> function) { Integer aa = function.apply("666"); }
2.Stream流
在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端。
当需要对多个元素进行操作(特别是多步操作)的时候,考虑到性能及便利性,我们应该首先拼好一个“模型”步骤
方案,然后再按照方案去执行它,流式思想类似于工厂车间的“生产流水线 。
这张图中展示了过滤、映射、跳过、计数等多步操作,这是一种集合元素的处理方案,而方案就是一种“函数模 型”。图中的每一个方框都是一个“流”,调用指定的方法,可以从一个流模型转换为另一个流模型。而最右侧的数字 3是最终结果。
这里的 filter 、 map 、 skip 都是在对函数模型进行操作,集合元素并没有真正被处理。只有当终结方法 count 执行的时候,整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。
Lambda延迟加载特性,可以优化操作:
-
普通方式拼接字符串:
public static void get(int i, String s) { if (i == 1) { System.out.println(s); } } public static void main(String[] args) { String a = "a"; String b = "b"; String c = "c"; get(1,a+b+c); } 不管怎么样都会进行字符串拼接
-
使用Lambda拼接字符串:
定义一个函数接口
@FunctionalInterface public interface StringAppend { String append(); }
public static void get(int i, StringAppend stringAppend) { if (i == 1) { String append = stringAppend.append(); System.out.println(append); } } public static void main(String[] args) { String a = "a"; String b = "b"; String c = "c"; get(1, () -> { System.out.println("执行了");//检验是否在条件不满足的情况下执行了字符串拼接 return a + b + c; }); } 当为1的时候,控制台输出:执行了 当不为1的时候,控制台为空 使用Lambda可以延迟加载,并且使用匿名内部类也是可行的,但是匿名内部类会创建对象的class文件,浪费性能,所以使用Lambda效率更高。
总结:有些场景的代码执行后,结果不一定会被使用,从而造成性能浪费。而Lambda表达式是延迟执行的,这正好可以作为解决方案,提升性能。在一些业务中可以使用Lambda的延迟加载特性进行优化。
备注:“Stream流”其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何元素(或其地址值)。
Stream(流)是一个来自数据源的元素队列
-
元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
-
数据源的来源。 可以是集合,数组 等。
和以前的Collection操作不同, Stream操作还有两个基础的特征:
-
Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道,如同流式风格。这样做可以对操作进行优化, 比如延迟执行和短路。
-
内部迭代: 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代, 这叫做外部迭 代。 Stream提供了内部迭代的方式,流可以直接调用遍历方法。
当使用一个流的时候,通常包括三个基本步骤:获取一个数据源(source)→ 数据转换→执行操作获取想要的结
果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以
像链条一样排列,变成一个管道。
1.1 获取流
java.util.stream.Stream是java8新加入的最常用的流接口。获取流的方法非常简单,有以下几种最常用的方式:
- 所有的Collection集合都可以通过stream默认方法获取流
- Stream接口的静态方法of可以获取数组对应的流
更多用法可以查看jdk8 api文档。
demo:
public static void main(String[] args) {
//根据Collection获取流
ArrayList<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
HashSet<String> set = new HashSet<>();
Stream<String> stream1 = set.stream();
//根据Map获取流
//Map接口不是 Collection 的子接口,且其K-V数据结构不符合流元素的单一特征,所以获取对应的流 需要分key、value或entry等情况
HashMap<String, String> map = new HashMap<>();
Stream<String> stream2 = map.keySet().stream();
Stream<String> stream3 = map.values().stream();
Stream<Map.Entry<String, String>> stream4 = map.entrySet().stream();
//根据数组获取流
int [] arr={1,2,3,4,5,6};
//of方法的参数是一个可变参数,所以支持数组
Stream<int[]> arr1 = Stream.of(arr);
}
1.2 常用方法
流模型的操作非常丰富,这里演示一些常用的API。这些方法可以被分为俩种:
- 延迟方法:返回值类型仍然是Stream接口自身类型的方法,因此支持链式调用。(除了终结方法,其他均为延迟方法)。
- 终结方法:返回值类型不再是Stream接口自身的方法,因此不再支持类似StringBuilder那样的链式调用(也就是不可以在继续对流进行操作),本次demo中count和forEach方法为终结方法。
demo:
注意:以下方法中的函数式接口可以看上面的函数接口中具体作用
-
延迟方法:
-
Stream filter(Predicate<? super T> predicate):传入过滤的规则,给数组或集合中的元素进行过滤
public static void main(String[] args) { Stream<String> stream = Stream.of("10", "12", "18"); Stream<String> stringStream = stream.filter(s -> "10".equals(s)); stringStream.forEach(s -> System.out.println(s)); } 结果:10
-
Stream map(Function<? super T, ? extends R> mapper):把集合中的元素类型转换成另一种类型
public static void main(String[] args) { Stream<String> stream = Stream.of("10", "12", "18"); Stream<Integer> result = stream.map(s -> Integer.parseInt(s)); }
-
Stream limit(long maxSize):截取数组或集合 前maxSize个元素
public static void main(String[] args) { Stream<String> stream = Stream.of("10", "12", "18"); Stream<String> limit = stream.limit(1); limit.forEach(s -> System.out.println(s)); } 结果:10
-
Stream skip(long n):跳过数组或集合前n个元素 若n>集合的长度,那么生成的新Stream 是空的
public static void main(String[] args) { Stream<String> stream = Stream.of("10", "12", "18"); Stream<String> skip = stream.skip(1); skip.forEach(s -> System.out.println(s)); } 结果:12 18
-
static Stream concat(Stream<? extends T> a, Stream<? extends T> b):把stream流1和stream流2合并成一个新Stream流
public static void main(String[] args) { Stream<String> stream1 = Stream.of("10", "12"); Stream<String> stream2 = Stream.of("13"); Stream.concat(stream1,stream2).forEach(s -> System.out.println(s)); } 结果:10 12 13
-
-
终结方法
-
void forEach(Consumer<? super T> action) :传入你要对Stream流中的数据进行的操作,并在foreach方法内循环stream流
public static void main(String[] args) { Stream.of(1,2,3,4).forEach(s-> System.out.println(s)); } 结果:1 2 3 4
-
long count(): 统计stream流中数据的个数
public static void main(String[] args) { Stream<String> stream = Stream.of("10", "12","14"); long count = stream.count(); System.out.println(count); } 结果:3
-
注意:
- 流只能操作单列集合 和 数组;双列集合可以拆成单列集合并被Stream流操作
- 从一个车间到另一个车间,原来的Stream对象就不可以继续使用