Java8 函数式编程读书总结

Android · luhaoaimama1 · 于 发布 · 619 次阅读
2919 1486395760

本文在 DiyCodeZone的个人博客 首发,关注作者的 DiyCode帐号 或者作者微博可第一时间收到新文章推送。

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

  • *DIL*XXX:代表参数值泛型
  • To*DIL*XXX:代表返回值泛型
  • *DIL*To*DIL*XXX:To前面代表参数值泛型 ,To后边代表返回值泛型
  • Obj*DIL*Consumer(特殊) :相当于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 返回流中任意元素<br /> 实测还是第一个元素
collect 终结符 R Collector<T, A, R> 流中的元素收集到R中
collect 终结符 R Supplier<R> supplier,<br />BiConsumer<R,T> ,<br />BiConsumer<R, R> 流中的元素收集到R中
reduce 终结符 Optional<T> BinaryOperator<T> 累加运算: 求和,求积等
reduce 终结符 Optional<T> T identity,<br />BinaryOperator<T> 累加运算: 求和,求积等
reduce 终结符 U U,<br />BiFunction<U,T, U>,<br />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> 原来的流转换成新流:方形过渡到圆形
mapTo*DIL* 中间符 *DIL*Stream To*DIL*Function<T>
flatMap 中间符 Stream<T> Function<T,R> 合并流
flatMapTo*DIL* 中间符 DIL Stream To*DIL*Function<T>
sort 中间符 Stream<T> Comparator<T>/None 排序
sequential 中间符 Stream<T> None 串行
parallel 中间符 Stream<T> None 并行
unordered 中间符 Stream<T> None 返回一个无序的流<br />实际测试无效
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> 对比器中最大/小元素
averaging*DIL* Collector<T, ?, DIL> To*DIL*Function>T> 平均值
summing*DIL* Collector<T, ?, DIL> To*DIL*Function<T> 求和
summarizing*DIL* Collector<T, ?, *DIL*SummaryStatistics> To*DIL*Function<T> 简易的统计
collectingAndThen Collector<T,A,RR> Collector<T,A,R>,<br />Function<R,RR> 收集之后装起来
mapping Collector<T, ?, R> Function<T,U>,<br />Collector<U, A, R> 原来的流转换成新流:方形过渡到圆形
toCollection Collector<T, ?, C> Supplier<C> 制定一个集合去装载进来的流元素
toList Collector<T, ?, List<T>> None 用List去收集,<br />Array/Linked等会选优
toSet Collector<T, ?, Set<T>> None 用Set去收集,<br />Hash/Tree等会选优
toMap<br />toConcurrentMap Collector<T, ?, Map<K,U>> Function<T, K>,<br />Function<T,U> Hash/ConcurrentMap去收集
joining Collector<CharSequence, ?, String> None 流连起来
joining Collector<CharSequence, ?, String> CharSequence delimiter 流连起来<br />delimiter:连接符
joining Collector<CharSequence, ?, String> CharSequence delimiter,<br />CharSequence prefix,<br />CharSequence suffix 流连起来<br />delimiter:连接符 <br />prefix:开始字符<br />suffix:结尾字符
groupingBy<br />groupingByConcurrent Collector<T, ?, Map<K, List<T>>> Function<T, K> 类型分组
groupingBy<br />groupingByConcurrent Collector<T, ?, Map<K, D<T>>> Function<T, K>,<br />Collector<T, A, D> 类型分组
groupingBy<br />groupingByConcurrent Collector<T, ?, M > Function<T, K>,<br />Supplier<M>,<br />Collector<T, A, D> 类型分组
partitioningBy Collector<T, ?, Map<Boolean, List<T>>> Predicate<T> groupingBy的简化<br />仅有两种分组类型true,false
partitioningBy Collector<T, ?, Map<Boolean, D>> Predicate<T>,<br />Collector<T, A, D> groupingBy的简化<br />仅有两种分组类型true,false
reducing Collector<T, ?, Optional<T>> BinaryOperator<T> 累加器
reducing Collector<T, ?, T> T identity,<br />BinaryOperator<T> 累加器
reducing Collector<T, ?, U> T identity,<br />Function<T, U> ,<br />BinaryOperator<T&gt 累加器<br />这个就不需要并行了请注意

groupingBy等方法内包含Collector参数的含义,因为这个设计的时候就是不能连用只能通过传递参数更改泛型之类的。外部的collector会传递到新的collector中;

自定义收集器

演示范例

Reference&Thanks:

http://tangpj.com/2017/04/24/java8-inAndroid/

http://www.jianshu.com/p/c0d5c3094324

暂无回复。
需要 登录 后方可回复, 如果你还没有账号请点击这里 注册