Java教程

链式编程

本文主要是介绍链式编程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

强大的链式编程 Stream API :Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregate operation),或者大批量数据操作 (bulk data operation)

Stream API 借助于同样新出现的 Lambda 表达式,极大的提高编程效率和程序可读性。

所以说,Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。


 

Lambda 表达式 本质是匿名方法

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口,Lambda表达式只能出现在目标类型为函数式接口的上下文中

表达式:   (参数列表)   →   {  语句块  };

比如:声明一个方法  

public int sum(int i,int j){
    return i+j;
}

转换成lambda表达式后可以写成

(int i,int j)→ i+j;

参数的类型也是可以省略的,Java编译器可以过根据上下文感知到参数类型:

(i,j)→  i+j;  或者  (i,j)→  { retrun i+j;}

可见:Lambda 表达式有三部分组成:参数列表 ,箭头(→) ,以及 语句块

接下来由浅入深通过四种简化方式简化一下:

 展开原码

Lambda表达式方法引用简化

java中的双冒号操作符   ::

定义

双冒号运算操作符是类方法的句柄,lambda表达式的一种简写

范式:   类名 ::  方法名

注意:

  1. 方法后面并没有()

  2. 懒加载方法是否调用要看调用方使用情况

有时候已经有其他方法实现了函数接口的方法了,那么我们可以直接引用此方法代替函数接口的实现方法,常见的引用形式有以下语法:

调用方法简化

静态方法引用:ClassName   ::   methodName
实例方法引用:object   ::            methodName
超类方法引用:super   ::            methodName
构造方法简化

构造方法引用:ClassName::new 

数组构造引用:TypeName[]::new

什么是流 Stream API

Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的 Iterator。

原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作;

高级版本的 Stream,用户只要给出需要对其包含的元素执行什么操作,比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等,Stream 会隐式地在内部进行遍历,做出相应的数据转换。

流的构成:

当我们使用一个流的时候,通常包括三个基本步骤:

      获取一个数据源(source) →  数据转换 →  执行操作获取想要的结果。

  1. 创建Stream;

  2. 转换Stream,每次转换原有Stream对象不改变,返回一个新的Stream对象(**可以有多次转换**);

  3. 对Stream进行聚合(Reduce)操作,获取想要的结果;

每次转换原有的Stream对象不改变,返回一个新的Stream 对象(可以有多次转换),这样就允许对其操作可以像链条一样排列,变成一个通道。

第一步:获取数据源    创建stream

  • Collection接口的stream()或parallelStream()方法

  • 静态的Stream.of()、Stream.empty()方法

  • Arrays.stream(array, from, to)

  • 静态的Stream.generate()方法生成无限流,接受一个不包含引元的函数

  • 静态的Stream.iterate()方法生成无限流,接受一个种子值以及一个迭代函数

  • Pattern接口的splitAsStream(input)方法

  • 静态的Files.lines(path)、Files.lines(path, charSet)方法

  • 静态的Stream.concat()方法将两个流连接起来

  • 。。。。

第二步: 中间操作(中间操作不会执行任何操作,直到执行了终止操作时,才会一次性执行所有中间操作 侧面说明了流是惰性的 :转换Stream  比如    筛选和过滤     映射

筛选和过滤

  • Stream<T> filter(Predicate<? super T> predicate) 

filter() : 接受一个lambda表达式 (自定以过滤条件 ,返回 boolean),从流中排除某些元素。

  • Stream<T> limit(long maxSize)

limit(maxSize):截取前maxSize元素的流。但已经满足返回添加,可发生短路,不再继续执行流

  • Stream<T> skip(long n)

skip(N): 跳过元素,返回一个扔掉了前个元素的流,如流中的元素不满足N 个,则返回一个空流。 与limit() 互补

  • Stream<T> distinct() 

distinct(): 筛选去重,通过流所生成元素的  hashCode() 和equals()   去除重复的元素。 需要重写类的 hashCode() 和equals() 方法

映射:

  • <R> Stream<R> map(Function<? super T, ? extends R> mapper);

map(): 接受一个函数 Function   作为参数,该函数会作用到每个元素上,并将其映射称为一个新的元素。然后返回一个Stream<R> ( 接收Lambda  ,将元素转换成其他形式或提取信息)

  • <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

flatmap() :   接受一个函数 Function   作为参数,将流Stream中的每一个值都换成另一个流Stream,然后将所有的流  合并成一个流 ,然后返回一个Stream<R> 

比较map() 和 flatmap方法可以类比  集合中的 add() 和 addAll() 方法。

排序:

  • Stream<T> sorted()
    sorted():  自然排序 ,根据Comparable 进行排序。

  • Stream<T> sorted(Comparator<? super T> comparator)  
    sorted(Comparator): 根据Comparator  排序,可自定义排序规则

第三步:终结操作

查找元素:

boolean allMatch(Predicate<? super T> predicate)

allMatch(Predicate):   流中所有的元素都能够满足 定义的断言规则  就会返回true ,若存在一个元素不满足断言规则,则返回false。

boolean anyMatch(Predicate<? super T> predicate)

anyMatch(Predicate): 流中任何一个元素能够 满足定义的断言规则 就会返回true ,若所有元素都不满足断言规则,则返回false。

boolean noneMatch(Predicate<? super T> predicate) 

noneMatch(Predicate): 流中所有元素都无法匹配 定义的断言规则 就会返回true,  若存在一个元素满足断言规则,则返回false。

Optional<T> findAny()

findFirst(): 返回第一个元素

Optional<T> findAny()

findAny() :返回任意元素,随机返回

组函数:

max(Comparator):返回指定比较规则 的最大值 对应的元素

min(Comparator):返回 指定比较规则 的最小值 对应的元素

count() :返回流中元素的个数


归约

T reduce(T identity, BinaryOperator<T> accumulator)     

reduce(a, fun) a为起始值,作为累积器的起点,reduce方法可以将该流中元素反复结合起来,得到一个新值 类型为T ,该值不可能为空,至少也是  起始值a

Optional<T> reduce(BinaryOperator<T> accumulator)   (可能为空的值需要封装进Optional 中

reduce(fun) 从流中计算某个值,接受一个二元函数作为累积器,从前两个元素开始持续应用它,累积器的中间结果作为第一个参数,流元素作为第二个参数。

可结合map形成 map-reduce 模式

收集

<R, A> R collect(Collector<? super T, A, R> collector)

collect(Collector) :将流转换为其他形式,接受一个收集器Collector,用于给stream中的元素做汇总方法

Collector接口中方法的实现决定了如何对流执行收集操作(如:收集到List  set  map),但是Collectors 实用类提供了很多静态方法,可以方便地创建常见收集器的实例,具体方法与实例如下表:


    • Collectors.toList()    收集到list集合中

    • Collectors.toSet()    收集到set 集合中

    • Collectors.toCollection 收集到指定类型的集合中去, 比如收集到HashSet中   HashSet<String> hs=    ObjectStream.collect(Collectors.toCollection(HashSet::new ))

    • Collectors.toMap(fun1, fun2)   /  toConcurrentMap(fun1, fun2)                            两个fun用来产生键和值,若值为元素本身,则fun2为Function.identity()

    • Collectors.toMap(fun1, fun2, fun3) /    toConcurrentMap(fun1, fun2, fun3)       fun3用于解决键冲突,例如(oldValue, newValue) -> oldValue,有冲突时保

    • 还有 计算 平均值 averagingInt/averagingLong/avergingDouble 最大值maxBy  最小值minBy  总和summingInt/sunmmingLong/summingDouble   分组groupingBy   分区 partitioningBy   组函数合辑 summarizingInt

      等等方法

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) 

collect(fun1, fun2, fun3)  :fun1转换流元素;fun2为累积器,将fun1的转换结果累积起来;fun3为组合器,将并行处理过程中累积器的各个结果组合起来 

 

forEach(fun)   遍历流中的元素
forEachOrdered(fun)  指定遍历的顺序,遍历流中的元素。 可以应用在并行流上以保持元素顺序
toArray()
toArray(T[] :: new)  返回正确的元素类型



 

 


这篇关于链式编程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!