jdk8中的lambda

最新推荐文章于 2024-09-25 09:43:33 发布

ForAnnuus

最新推荐文章于 2024-09-25 09:43:33 发布

阅读量569

点赞数

文章标签： java 后端

本文链接：https://blog.csdn.net/ForAnnuus/article/details/122070956

版权

lambda

初印象，长得像匿名函数：

(parameters) -> expression
(parameters) -> { statements; }
ClassName::staticMethod

lambda表达式只能引用标记了final的外层局部变量。

int d = 0;
MathOperation addition = (a, b) -> {
    return a + b + d;
};
d = 1;

考虑如上场景，有什么问题？

List<Integer> list = new ArrayList<>();
list.add(1);
MathOperation addition = (a, b) -> {
    list.add(2);
    return a + b;
};
System.out.println(addition.operate(3, 4));
System.out.println(list);

考虑如上场景，list输出结果是？

类似于方法调用可变更引用参数，但是变更不了常量参数。

functional programming

函数式编程的理论基础：lambda演算。

lambda演算有两种方式：应用、抽象。

应用，从左到右：

* ( + 1 2) 3 = * 3 3 = 9

抽象(函数)，从右往左：

(λx.x + 2) 3 // 3 + 2
(λx.x 3) (λx.x + 2) // 3 + 2
λx.λy (xy) = λxy.(xy) // 多个抽象合并一个λ
(λxyz. + (+ x z) y) 1 2 3 // +((+1)3)2 >> 6

函数的参数只能有一个，但是函数的输入和输出也可以函数。

λx λy λz +(+xz)y

λx (λy λz +(+xz)y) 1

λx (λy (λz +(+xz)y) 2) 1

λx (λy (λz (+(+xz)y) 3) 2) 1

λy (λz (+(+1z)y 3) 2)

λz (+(+1z)2 3)

+((+1)3)2

λ演算 (Lambda Calculus) 一：定义与函数式编程 - IP=PSPACE - 博客园

λ演算(Lambda Calculus)入门基础（一）：定义与归约 - 简书

为了避免歧义，多使用小括号，另外：

函数是尽可能地向右扩展，应用是左结合的。

λy.xy
>> (λy.xy)  // √
>> (λy.x) y // x
M N P 
>> (M N) P // √
>> M (N P) // x

自由变量和绑定变量

FV(λx.xy) = {y} // binding: x
FV((λy.y)(λx.xy)) = {y} // binding: y1, x
FV(λx.(λy.xyz)) = {z} // binding: x, y

Currying

当函数需要有多个参数时，使用柯里化做转化。

currying: λx y.xy = λx.(λy.xy)

前者是后者的简写。

reduction

β规约

替换，E[V:=R]

规约，((λV.E) E′) ≡ E[V := E′]

(λx.x)y >> x[x:=y] >> y
x[x := N] >> N
y[x := N] >> y 
(M1 M2)[x := N] >> (M1[x := N]) (M2[x := N])
(λx.M)[x := N] >> λx.M
(λy.M)[x := N] >> λy.(M[x := N])

α转换

设想如下替换

(λx.(λy.xy)) y
= (λy.xy)[x:=y]
= λy.yy

使用α转换，一个函数抽象在更名绑定变量前后是等价的。

α: λx.x = λy.y

再次尝试

(λx.(λy.xy))y
= (λy.xy)[x:=y] // β
= (λz.xz)[x:=y] // α
= λz.yz

η规约

λx.M x >> M

M不包含x，x是冗余的，η的作用就是清除这种冗余函数。

λ演算(Lambda Calculus)入门基础（二）：丘奇编码(Church Encoding) - 简书

Church Numberals

丘奇数就是λ演算中的"自然数"，代表将函数作用于参数的次数。

0 ≡ λf.λx.x
1 ≡ λf.λx.f x
2 ≡ λf.λx.f (f x)
3 ≡ λf.λx.f (f (f x))
...
S ≡ λn.λf.λx.f (n f x)

验证: S(0)=1

S 0
≡ (λn.λf.λx.f (n f x)) λf.λx.x
= (λf.λx.f (n f x))[n := λf.λx.x] // β
= (λg.λy.g (n g y))[n := λf.λx.x] // α
= λg.λy.g ((λf.λx.x) g y) // substitute
= λg.λy.g (x[f := g, x := y]) // β
= λg.λy.g y // substitute
≡ 1

更多运算和验证内容不再赘述(反正也看不懂)。

凯哥带你从零学大数据系列之Java篇---第二十二章:Lambda表达式 - 知乎

lambda表达式，只能实现函数式接口。

函数式接口，就是实现类必须实现的抽象方法，有且只有一个的接口。

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

通过注解@FunctionalInterface可判断接口是否是函数式接口。

interface Foo {
    String toString();
}
interface Bar {
    void test();
    default void test1() {}
    static void test2() {}
    String toString();
}

考虑如上接口，是否是函数式接口？

接下来介绍几个系统内置的函数式接口：

Function，Predicate，Consumer，Supplier，UnaryOperator，Bi*

Function

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

compose和andThen执行顺序相反。

public static int andThen(int a, Function<Integer, Integer> f1,
                          Function<Integer, Integer> f2) {
    return f1.andThen(f2).apply(a);
}

public static int compose(int a, Function<Integer, Integer> f1,
                          Function<Integer, Integer> f2) {
    return f1.compose(f2).apply(a);
}

public static void main(String[] args) {
    int d1 = compose(2, v -> v * 3, v -> v * v);
    System.out.println(d1);
    int d2 = andThen(2, v -> v * 3, v -> v * v);
    System.out.println(d2);
}

考虑如上场景，输出结果是？

BiFunction

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

顾名思义，BiFunction可以接收两个参数，比Function少了一个compose方法，因为Java中方法的返回值只能有一个。

Predicate

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

典型场景：过滤和判断，比如stream filter。

Consumer

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

执行一个void方法，典型案例：

public interface Iterable<T> {
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Supplier

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

调用get会构建一个T实例。

在Optional中可以找到Supplier/Consumer/Predicate的典型案例。

public final class Optional<T> {
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

UnaryOperator

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

一元函数，典型案例：List接口。

public interface List<E> extends Collection<E> {
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
}

Bi*接口指以上函数式接口的二元实现，如BinaryOperator之于UnaryOperator，BiFunction之于Function。

Optional

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

    private Optional() {
        this.value = null;
    }

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    public boolean isPresent() {
        return value != null;
    }

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

    public T orElse(T other) {
        return value != null ? value : other;
    }

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Optional)) {
            return false;
        }

        Optional<?> other = (Optional<?>) obj;
        return Objects.equals(value, other.value);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }

    @Override
    public String toString() {
        return value != null
            ? String.format("Optional[%s]", value)
            : "Optional.empty";
    }
}

Stream

stream的操作符大致分成两种：中间操作符和终止操作符。

中间操作符

filter，map，flatMap，distinct，sorted，peek，limit，skip。

终止操作符

forEach，reduce，toArray，collect，min，max，count，

findFirst，findAny，noneMatch，allMatch，anyMatch。

实例：

// ["Hello", "World"]
List<String> chars = words.stream()
        .flatMap(word -> Arrays.stream(word.split("")))
        .skip(2)
        .peek(System.out::println)
        .collect(toList());
// [1, 2, 3]
list.stream().reduce((a, b) -> a > b ? a : b);
list.stream().max(Integer::compareTo);

Date

时间处理方法，优点是好用、线程安全，实例如下：

LocalDateTime now = LocalDateTime.now();
LocalDate today = now.toLocalDate();
LocalDate tomorrow = today.plusDays(1);
LocalDate nextMonth = today.plusMonths(1);
LocalDate firstDayOfMonth = today.withDayOfMonth(1);
LocalDate lastDayOfMonth = firstDayOfMonth.with(TemporalAdjusters.lastDayOfMonth());
LocalDate firstDayOfYear = today.withDayOfYear(1);
LocalDate lastDayOfYear = firstDayOfYear.with(TemporalAdjusters.lastDayOfYear());
LocalDateTime eight = now.withHour(8);
String format = eight.format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"));
Timestamp timestamp = Timestamp.valueOf(eight);
long days = lastDayOfYear.toEpochDay() - firstDayOfYear.toEpochDay();