Java8函数式编程读书总结

最新推荐文章于 2024-01-02 09:14:26 发布
最新推荐文章于 2024-01-02 09:14:26 发布
阅读量121 收藏
点赞数
分类专栏： Java8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010395024/article/details/103576101
版权

Lambda表达式

  • Lambda表达式的类型:函数接口是只有一个抽象方法的接口
  • @FunctionalInterface:是否仅仅一个抽象方法！不然编译错误，主要为了lambda提供方便;
    有些多抽象方法的接口不必使用此注解！
  • interface
    • default(注意有方法体!)：符合多态 子类如果覆盖,既用自己的行为；
      事件原因：Java8中Collection接口增加stream方法，意味所有子类都需要增加。
    • static default：未构造即可使用,一般用于构造 例如Stream.rang()方法构造流；

快捷键提示

 

lambda简单使用Tips:Lambda中的引用值是既成事实的final而不是变量。如果用的变量的话。编译器会告诉你的
    //无参数
    Runnable runnable = () -> log();
    //单个参数
    Predicate<String> p=o -> o.isEmpty();
    //两个参数 不能省略括号！
    BiConsumer<String,String> biFunction=(o, o2) -> log();
    //有返回值的Lambda.一句逻辑既是的时候可以省略return!
    Callback callback = a -> 1==1?"Lambda":"Java8";
    public interface Callback {
        String a(String a);
       }
方法引用

这种方法很普遍

artist -> artist.getName()
java8为其提供简化语法，叫做方法引用 去重用已有方法；

Artist:getName
标准语法为 Classname::methodName

凡是使用Lambda表达式的地方都可以使用方引用
特殊 构造

(name,age)-> new Artist(name,age)
Artist::new
数组的话
String[]::new
数组

    //老方法
    String[] array = new String[]{"hello", "world"};
    //lambda 数组新写法；根据上下文推断类型信息；
    String[] array2 = {"hello", "world"};
default多重继承。碰到相同签名的方法

public interface Juckbox{
        public default String rock(){
            return "...all over the world!";
        }
    }
    public interface Carriage{
        public default String rock(){
            return "...from side to side!";
        }
    }
    public class Child implements Juckbox,Carriage{
        @Override
        public String rock() {
            return Carriage.super.rock();
        }
    }
Java8中重要的函数接口
 

英文翻译是有道的翻译~
接口
英文含义
函数描述符
示例

 

Predicate<T>
断言
T -> boolean
Predicate<String> p=o -> o.isEmpty()

 

Consumer<T>
消费
T -> void
Consumer<String> consumer=s -> log();

 

Function<T>
功能/函数
T -> R
转换成另一个对象:Function<String,File> f= s -> new File(s);

 

Supplier<T>
功能
None -> T
供应者:Supplier<String> s=() -> "heihei";

 

UnaryOperator<T>
一元运算
T -> T
UnaryOperator<String> s=s1 -> s1+"," ;

 

BinaryOperator<T>
二元运算
T,T -> T
BinaryOperator<String> a=(s, s2) -> s+s2;）

Bi系列

BiConsumer,BiFunction,BiPredicate:从一个参数值,扩展支持到两个参数； 范例：
@FunctionalInterface
public interface BiConsumer<T, U>{
void accept(T t, U u);
}
基本类型系列
 
为了减小装箱拆箱而消耗的性能；
 
Double/Int/Long 简称 DIL
DILXXX：代表参数值泛型
ToDILXXX：代表返回值泛型
DILToDILXXX：To前面代表参数值泛型 ,To后边代表返回值泛型
ObjDILConsumer(特殊) :相当于BiConsumer, 代表的第二个参数类型的泛型
范例：
 
@FunctionalInterface
public interface LongToIntFunction {
    /**
     * Applies this function to the given argument.
     * @param value the function argument
     * @return the function result
     */
    int applyAsInt(long value);
}
流
 
Double/Int/Long 简称 DIL
集合stream的方法简介；
 
  Arrays.asList("a","b").stream();
  new HashSet<>().stream();
  new HashMap<>().entrySet().stream()
Stream终结符
 
官方演示范例
 
演示范例
方法名
类型
return
函数接口
功能

 

all/any/none Match
终结符
boolean
Predicate<T>
筛选

 

count
终结符
long
None
同list.size()

 

max/min
终结符
Optional<T>
Comparator<T>
返回一个最大/最小元素

 

findFirst
终结符
Optional<T>
None
返回流中第一个元素

 

findAny
终结符
Optional<T>
None
返回流中任意元素
实测还是第一个元素

 

collect
终结符
R
Collector<T, A, R>
流中的元素收集到R中

 

collect
终结符
R
Supplier<R> supplier,
BiConsumer<R,T> ,
BiConsumer<R, R>
流中的元素收集到R中

 

reduce
终结符
Optional<T>
BinaryOperator<T>
累加运算: 求和,求积等

 

reduce
终结符
Optional<T>
T identity,
BinaryOperator<T>
累加运算: 求和,求积等

 

reduce
终结符
U
U,
BiFunction<U,T, U>,
BinaryOperator<U>
累加运算: 求和,求积等

 

forEach
终结符
void
Consumer<T>
遍历流中元素

 

forEachOrdered
终结符
void
Consumer<T>
顺序遍历流中元素

 

isParallel
终结符
void
None
是并行？

 

close
终结符
void
None
手动关闭流

 

spliterator
终结符
Spliterator<T>
None
？？？

 

toArray
起始符
Object/A[]
None/IntFunction<A[]>
流转换成数组

Stream中间符

方法名
类型
return
函数接口
功能

 

filter
中间符
Stream<T>
Predicate<T>
筛选

 

peek
中间符
Stream<T>
Consumer<T>
查看流元素

 

distinct
中间符
Stream<T>
None
去掉重复元素

 

skip
中间符
Stream<T>
long
扔掉前面n个元素

 

limit
中间符
Stream<T>
long
返回不超过跟定长度n的流

 

map
中间符
Stream<T>
Function<T,R>
原来的流转换成新流:方形过渡到圆形

 

mapToDIL
中间符
DILStream
ToDILFunction<T>

flatMap
中间符
Stream<T>
Function<T,R>
合并流

 

flatMapToDIL
中间符
DIL Stream
ToDILFunction<T>

sort
中间符
Stream<T>
Comparator<T>/None
排序

 

sequential
中间符
Stream<T>
None
串行

 

parallel
中间符
Stream<T>
None
并行

 

unordered
中间符
Stream<T>
None
返回一个无序的流
实际测试无效

 

onClose
中间符
Stream<T>
Runnable
流关闭会执行这个任务
parallel 不一定并行就是最快的。与数据还有多核处理器有关. 例如(本意是并行不一定快的。范例仅仅是个大概 请当看着玩)：如果处理10个元素，串行代码速度是并行的8倍。如果数量增至100则速度相等。如果增至10000 则并行是串行的2.5倍；

Stream静态起始符

方法名
类型
return
函数接口
功能

 

concat
起始符
Stream<T>
Stream<T> a, Stream<T> b
合并流

 

generate
起始符
Stream<T>
Supplier<T>
while循环

 

iterate
起始符
Stream<T>
final T , final UnaryOperator<T>
while循环+累加器

 

of
起始符
Stream<T>
T/T...
转成流

 

empty
起始符
Stream<T>
None
返回一个空的流

 

builder
起始符
Builder <T>
None
通过add.build一个流

IntStream多出来的方法IntStream 中间符/终结符

DoubleStream,LongStream与之相同；
方法名
类型
return
函数接口
功能

 

asDoubleStream
中间符
DoubleStream
None
转换成DoubleStream

 

asLongStream
中间符
LongStream
None
转换成LongStream

 

boxed
中间符
Stream:Integer
None
装箱操作,int编程Integer

 

average
终结符
OptionalDouble
None
平均值

 

sum
终结符
int
None
求和

 

summaryStatistics
终结符
IntSummaryStatistics
None
简易的统计

IntStream 静态起始符

方法名
类型
return
函数接口
功能

 

range
起始符
IntStream
int startInclusive, int endExclusive
不包括后边界

 

rangeClosed
起始符
IntStream
int startInclusive, int endExclusive
包括后边界
例子:
IntStream.range(1,3)//流为:1,2
IntStream.rangeClosed(1,3)//流为:1,2,3
IntSummaryStatistics简介
 
IntSummaryStatistics（ Summary:简易的 Statistics：统计）
accept(int） 添加一个值
combine(IntSummaryStatistics)与另一个合并成一个
getAverage 平均数
getCount 元素的个数
getSum 求和
getMin 最小的值
getMax 最大的值
toString
收集器
 
Steam类会为你自动挑选合适的类型；
 
Stream.of("a","b","c").collect(Collectors.toSet());
如果你想制定类型用toCollection他接受一个参数来创建集合
 
Stream.of("a","b","c").collect(Collectors.toCollection(TreeSet::new));
Collectors
 
Collector<T, A, R>
T 流中的元素类型
A 中间类型

 

R Stream.collect返回的类型
方法名
return
函数接口
功能

 

counting
Collector<T, ?, Long>
None
同list.size()

 

max/minBy
Collector<T, ?, Optional<T>>
Comparator<T>
对比器中最大/小元素

 

averagingDIL
Collector<T, ?, DIL>
ToDILFunction>T>
平均值

 

summingDIL
Collector<T, ?, DIL>
ToDILFunction<T>
求和

 

summarizingDIL
Collector<T, ?, DILSummaryStatistics>
ToDILFunction<T>
简易的统计

 

collectingAndThen
Collector<T,A,RR>
Collector<T,A,R>,
Function<R,RR>
收集之后装起来

 

mapping
Collector<T, ?, R>
Function<T,U>,
Collector<U, A, R>
原来的流转换成新流:方形过渡到圆形

 

toCollection
Collector<T, ?, C>
Supplier<C>
制定一个集合去装载进来的流元素

 

toList
Collector<T, ?, List<T>>
None
用List去收集,
Array/Linked等会选优

 

toSet
Collector<T, ?, Set<T>>
None
用Set去收集,
Hash/Tree等会选优

 

toMap
toConcurrentMap
Collector<T, ?, Map<K,U>>
Function<T, K>,
Function<T,U>
Hash/ConcurrentMap去收集

 

joining
Collector<CharSequence, ?, String>
None
流连起来

 

joining
Collector<CharSequence, ?, String>
CharSequence delimiter
流连起来
delimiter:连接符

 

joining
Collector<CharSequence, ?, String>
CharSequence delimiter,
CharSequence prefix,
CharSequence suffix
流连起来
delimiter:连接符 
prefix:开始字符
suffix:结尾字符

 

groupingBy
groupingByConcurrent
Collector<T, ?, Map<K, List<T>>>
Function<T, K>
类型分组

 

groupingBy
groupingByConcurrent
Collector<T, ?, Map<K, D<T>>>
Function<T, K>,
Collector<T, A, D>
类型分组

 

groupingBy
groupingByConcurrent
Collector<T, ?, M >
Function<T, K>,
Supplier<M>,
Collector<T, A, D>
类型分组

 

partitioningBy
Collector<T, ?, Map<Boolean, List<T>>>
Predicate<T>
groupingBy的简化
仅有两种分组类型true,false

 

partitioningBy
Collector<T, ?, Map<Boolean, D>>
Predicate<T>,
Collector<T, A, D>
groupingBy的简化
仅有两种分组类型true,false

 

reducing
Collector<T, ?, Optional<T>>
BinaryOperator<T>
累加器

 

reducing
Collector<T, ?, T>
T identity,
BinaryOperator<T>
累加器

 

reducing
Collector<T, ?, U>
T identity,
Function<T, U> ,
BinaryOperator<T&gt
累加器
这个就不需要并行了请注意
groupingBy等方法内包含Collector参数的含义，因为这个设计的时候就是不能连用只能通过传递参数更改泛型之类的。外部的collector会传递到新的collector中;

自定义收集器

Reference&Thanks：

码农的世界，你不懂
关注
专栏目录
Spark编程模型与函数式编程
AI天才研究院
10-04 1424
《Spark编程模型与函数式编程》 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 随着大数据时代的到来，数据处理和分析的需求
java收集器Collector
clyu的博客
03-08 3909
一、收集器Collector //T：表示流中每个元素的类型。 A：表示中间结果容器的类型。 R：表示最终返回的结果类型。 public interface Collector<T, A, R> { Supplier<A> supplier()//生成容器 BiConsumer<A,T> accumulator()//是添加元素 BinaryOperator<A> combiner()//是合并容器 Function<A,R&
Java 8中字符串拼接新姿势：StringJoiner
HollisChuang's Blog
03-05 2758
在为什么阿里巴巴不建议在for循环中使用”+”进行字符串拼接一文中，我们介绍了几种Java中字符串拼接的方式，以及优缺点。其中还有一个重要的拼接方式我没有介绍，那就是Java 8中提供的StringJoiner ，本文就来介绍一下这个字符串拼接的新兵。 如果你想知道一共有多少种方法可以进行字符串拼接，教你一个简单的办法，在Intellij IDEA中，定义一个Java Bean，然后尝试使用快捷键...
Collectors方法常见的异常
最新发布
扬帆天涯
01-02 962
报错 NullPointerException。Collectors.toMap常见的异常。
Java笔记 – 泛型 泛型方法 泛型接口 擦除 边界 通配符
DennisRuan(米粒橙)
03-20 3901
Java笔记 – 泛型 泛型方法 泛型接口 擦除 边界 通配符         Java中的泛型参考了C++的模板，Java的界限是Java泛型的局限。 2、简单泛型 促成泛型出现最引人注目的一个原因就是为了创造容器类。 首先看一个只能持有单个对象的类，这个类可以明确指定其持有的对象的类型 class Holder1 { private Circle a; pu
Java8 Stream收集器collect操作
老猫喜欢今日爬山的博客
06-29 1152
最终返回Map。： 将Stream中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组，然后通过downstream再对每组进行统计(得到统计结果D)，最后得到并返回Map。提示： 串行流下的reduce与并行流下的reduce可能结果不一样，如果不太熟悉的话，建议使用stream的reduce()，而不使用.stream().collect(Collectors.reducing())。
Java函数式编程测试工程读书笔记整理
资源摘要信息:"该文件是关于Java函数式编程的读书笔记，通过测试工程的方式进行知识点的学习和总结。文件中可能包含了对Java函数式编程的核心概念、优势以及如何在实际项目中应用的详细记录。函数式编程是一种编程...
Java函数式编程学习心得与实践总结
在深度历险Java函数式编程的过程中，学习者需要理解这些核心概念，并且能够在实际项目中灵活运用它们。例如，在处理集合数据时，使用流（Streams）可以有效地简化集合的处理流程，提高代码的可读性和维护性。在设计...
深入理解算法与Java函数式编程笔记
总之，这本读书笔记是对算法、数据结构以及Java 8之后函数式编程的深入学习与总结。它不仅覆盖了基础理论，还可能包括了实际应用和最佳实践，适合希望通过提高编程技能来解决复杂问题的开发者阅读和学习。
变量类型 R 的实例不存在，因此void 符合 R
高朋举的博客
03-21 1961
解决方法：在实体类上加注解 @Accessors(chain = true)
详细解决java中的Collectors.toMap引起的java.lang.IllegalStateException: Duplicate key xxx 的错误
念兮为美
09-28 4647
详细解决java中的Collectors.toMap引起的java.lang.IllegalStateException: Duplicate key xxx 的错误，比如java.lang.IllegalStateException: Duplicate key 2、java.lang.IllegalStateException: Duplicate key 1。
010Java新特性004Collector接口和Collectors工具类
执笔未来的博客
10-08 395
本文主要学习了在JDK1.8中新增的Collector接口和Collectors工具类，以及使用它们在处理集合时的改进和优化。
3.基础知识-Lambda表达式
进击的代码君
01-11 309
本章内容 Lambda管中窥豹 在哪里以及如何使用Lambda 环绕执行模式 函数式接口，类型推断 方法引用 Lambda复合 核心问题 概述 3.1 Lambda管中窥豹 3.2 在哪里以及如何使用Lambda 3.3 把Lambda付诸实践：环绕执行模式 3.4 使用函数式接口 3.5 类型检查、类型推断、限制 3.6 方法引用 3.7 Lambda和方法引用实践 3.8 符合Lambd...
Collector和Collectors类（收集器原理分析）
qq_43621307的博客
01-07 1275
Collector收集器源码分析
JDK1.8新特性(五): Collectors
热门推荐
人不风流枉少年
05-06 1万+
一：简介 JDK1.8中Map新增了一些方法，其中一部分方法是为了简化代码的，如forEach，另外一些方法是为了防止null，使操作代码更加严谨。 二：Map public interface Map&amp;amp;amp;amp;amp;lt;K,V&amp;amp;amp;amp;amp;gt; { // 如果key存在，则忽略put操作 default V putIfAbsent(K key, V value) { V ...
Collectors简单使用
w15997402070的博客
10-26 558
Collectors Collectors类API 1. public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory); 2. public static <T> Collector<T, ?, List<T>> toList(); 3. public static <
[Java8新特性]Collector接口的组成详解
lingfy1234的博客
06-14 1916
1.Collector常常出现的地方 java8引入了stream，Collector是与stream一起出现的，配合stream使用的好帮手，如果用过stream，我们应该都有写过这样的代码 例子1： lists.stream()....collect(Collectors.toList()); 例子2： lists.stream().collect(groupingBy(String::length)); 这两个例子中，toList()和groupingBy返回的都是一个Collector对象,
java8 新特性（四）之收集器Collector
yin__ren的博客
01-27 2861
Oracle官方API（Collectors） Oracle官方API（Collector） Collector与Collectors之间的关系 作为collect方法的参数，Collector是一个接口，它是一个可变的汇聚操作，将输入元素累计到一个可变的结果容器中；它会在所有元素都处理完毕后，将累积的结果转换为一个最终的表示（这是一个可选操作）； Collectors本身提供了关
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值