java8实战 lambda表达式、函数式接口、方法引用双冒号(中)

2023-12-21 06:14:18

前言

书接上文,上一篇博客讲到了lambda表达式的应用场景,本篇接着将java8实战第三章的总结。建议读者先看第一篇博客

其他函数式接口例子

上一篇有讲到Java?API也有其他的函数式接口,书里也举了2个例子,一个是java.util.function.Consumer<T>, 定义了accpet抽象方法,接受泛型T对象,没有返回,一个是java.util.function.Function<T,R>,定义了apply方法,接受一个泛型T对象,返回泛型R对象

用consumer模拟forEach方法?

@FunctionalInterface
public interface Consumer<T>{
    void accept(T t);
}
public static <T> void forEach(List<T> list, Consumer<T> c){\
    for(T i: list) {
        c.accept(i);
    }
}
forEach(Arrays.asList(1,2,3,4,5),(Integer i)->System.out.println(i));

用Function来模拟map方法

@FunctionalInterface
public interface Function<T, R>{
    R apply(T t);
}
public static <T, R> List<R> map(List<T> list, Function<T, R> f){\
    List<R> result = new ArrayList<>();
    for(T s:list){
        result.add(f.apply(s));
    }

    return result;
}
List<Integer> l=map( Arrays.asList("lambdas","in","action"), (String s)->s.length());

常用的函数式接口

因为很多泛型函数式接口,如Predicate<T>,Consumer<T>, 其中T只能绑定要引用类型(如Byte,Integer,Object),不能绑定到原始类型(如int,double,byte,char),所以最后一栏有原始类型特化,对比一下例子:

也就是说IntPredicate是当T=int原始类型的特殊情况。

public interface IntPredicate{
    boolean test(int t);
}

IntPredicate evenNumbers = (int i) -> i % 2 == 0;

evenNumbers.test(1000);

Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;

oddNumbers.test(1000);

?lambda及函数式接口例子

?

?异常捕获的处理

由于任何函数式接口都不允许抛出受检异常,所以需要在lambda表达式抛出异常,如:

Function<BufferedReader, String> f = (BufferedReader b) -> {
    try{
        return b.readline();
    }
    catch(IOException e) {
        throw new RuntimeException(e);
    }
    
}

使用局部变量

lambda可以没有限制地捕获实例变量和静态变量,但是局部变量必须显式声明为final或者事实上是final,如,下面代码无法编译,因为portNumber变量被赋值两次:

int portNumber = 1337;
Runnable r = () -> System.out.println(portnumber);
portNumber = 31337;

这一限制其实背后是因为实例变量是存储在堆上,而局部变量是保持在栈上,如果lambda可以直接访问局部变量,而且lambda是在一个线程中使用的,则使用lambda的线程,可能会在分配该变量的线程将这个变量收回以后,去访问该变量。

方法引用?

inventory.sort(Apple a1, Apple a2) 
                    -> a1.getWeight().compareTo(a2.getWeight());

//使用方法引用
inventory.sort(comparing(Apple::getWeight));

实际上方法引用是lambda的一种快捷写法,基本思想就是,如果一个lambda代表只是“直接调用这个方法”,那么最好还是用名称去调用它,而不是去描述如何调用它。

直观一点,可以认为:

Apple::getWeight 等于 (Apple a) -> a.getWeight()

书本也举了一些例子

总结:方法引用就是lambda只调用特定方法时候一种快捷写法,上述的例子中lambda主体只有调用一个函数。

如何构建方法引用

?方法引用有三类

1.指向静态方法的方法引用(如Integer的parseInt方法,写作Integer::parseInt)

2.指向任意类型实例方法的方法引用(如string的length方法,写作String::length)

3.指向现有对象的实例方法的方法引用(假设有一个局部变量expensiveTransaction用于存放Transanction类型的对象,它支持实例方法getValue, 那么你就可以写expensiveTransaction::getValue)

?书中还有图来表达这三类:

构造函数引用

?对于一个现有构造函数,可以利用它的名称和关键字new来创建它的一个应用:ClassName::new,它的功能与指向静态方法的引用类似。假设一个构造函数没有参数,适合Supplier的签名()->Apple

Supplier<Apple> c1 = Apple::new; //指向默认Apple()的构造函数
Apple a1 = c1.get(); //产生一个新的apple

等价于

Supplier<Apple> c1 = () -> new Apple();
Apple a1 = c1.get(); //产生一个新的apple

如果构造函数是Apple(Integer weight), 那么它就适合Function接口的签名

Function<Integer, Apple> c2 = Apple::new; //指向Apple(Integer weight)的构造函数
Apple a2 = c2.apply(110); //输入重量产生一个新的apple

等价于

Function<Integer Apple> c2 = (weight) -> new Apple(weight);
Apple a2 = c2.get(); //产生一个新的apple

以此类推,如果有两个参数,就可以用BiFunction接口,那么如果多个参数,那么就需要自己构造了,可以参考第一篇的构造一个接口。

最后有个有趣的应用,将上面知识点串在一起,比如说给定一个水果名称和重量,创建一个水果的实例,我个人想到最简单粗暴的方式,写if/else语句,判断水果名称,然后就是new不同的水果,当然也可以结合上面知识点,将new这个起始动作(还没new)放在map中,实际要用时候再apply.

static Map<String, Function<Integer, Fruit>> map = new HashMap<>();
static {
    map.put("apple", Apple::new);
    map.put("orange", Orange::new);
//etc...
}

public static Fruit giveMeFruit(String fruit,  Integer weight) {
    return map.get(fruit.toLowerCase())
                .apply(weight);
}

第三章还有最后的实战部分,放到最后一篇讲。

参考文献:

《java8 实战》

文章来源:https://blog.csdn.net/u012895183/article/details/135095894
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。