Java Clousures and lambda记录

Java8lambda语法

L2.1

import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_1 {

    public static<V>Function<V,V> identifyFunction() {
        return  value -> value;
    }
}

接收一个参数value，然后返回该参数就这么简单。

其等价于

L2.2

import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_2 {


    public static<V>Function<V,V> identifyFunction() {
        return  new Function<V, V>() {
            @Override
            public V apply(V v) {
                return v;
            }
        };
    }
}

value -> value;其实就是接口的具体实现，只不过简写了。

有的开发人员可能会使用返回Object来避免类型问题。

L2.3

public static<V>Function<V,V> identifyFunction() {
  Object funObject =  value -> value;
  return funObject;
}

上面这样干是无法编译通过的。

于是可能会尝试使用泛型

L2.4

public static<V>Function<V,V> identifyFunction() {
  Function<?,?> function = value -> value;//它倒是能工作
  return function;//它无法知道类型，返回类型错误
}

行，指定一个具体的。

L2.5

public static<V>Function<V,V> identifyFunction() {
  Function<Number,Number> function = value -> value;
  return function;// 这里的返回类型一样不符合
}

lambda是闭包

lambda是一个数学概念，探讨了可以计算和不能计算的内容，特别是来自称为lambda演算的结构。 lambda演算将函数应用程序视为计算中的主要动作，因此它可以最抽象地处理函数，而无需考虑函数本身可以表示或计算的内容。函数本身是lambda演算中的相关值。

闭包是lambda后续的创新。

没有值绑定的变量-》open
有值绑定的变量-》closed

闭包是关闭某些变量的lambda，它通过封闭变量环境来实现这一点。

L2.6

/**
 * 邱道长
 * 2020/2/24
 */

interface Greeter{
    String createGreeting(String whom);
}
public class L2_6 {

    public static void main(String[] args) {
        final  String greeting = "hello";
        Greeter greeter = new Greeter() {
            @Override
            public String createGreeting(String whom) {

                return greeting + whom + "!";
            }
        };
        greetWorld(greeter);
    }

    private static void greetWorld(Greeter greeter) {
        System.out.println(greeter.createGreeting("World"));
    }
}

L2.7

import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_7 {

    public static void main(String[] args) {
        String greeting = "hello";
        Function<String,String> greeter = whom-> greeting + whom + "!";
        greetWorld(greeter);
    }

    private static void greetWorld(Function<String, String> greeter) {
        System.out.println(greeter.apply("world"));;
    }
}

无参与多参lambda

L2.8

import java.util.function.Supplier;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_8 {
    public static void main(String[] args) {
        Supplier<Number> function = () -> 1;

    }
}

返回1，无参数。提供值，不需要提供其它输入。

L2.9

import java.util.function.BiFunction;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_9 {

    public static void main(String[] args) {
        BiFunction<String,String,String> concat = (a,b)-> a+b;
    }
}

部分函数应用与动词

L2.10

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_10 {

    public static void main(String[] args) {
        BiFunction<String,String,String> concat = (a,b)-> a+b;
        greetFolks(whom -> concat.apply("hello",whom));
    }

    public static void greetFolks(Function<String,String> greeter){
        for(String name: Arrays.asList("alice","bob","cathy"))
            System.out.println(greeter.apply(name));

    }
}

L2.11

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_11 {

    public static void main(String[] args) {
        BiFunction<String,String,String> concat = (a,b)-> a+b;
        greetFolks(applyPartial(concat,"hello,"));
    }


    public static <T,U,V> Function<U,V> applyPartial(
            BiFunction<T,U,V> bif,  T firstArgument) {
        return u -> bif.apply(firstArgument,u);
    }

    public static void greetFolks(Function<String,String> greeter){
        for(String name: Arrays.asList("alice","bob","cathy"))
            System.out.println(greeter.apply(name));

    }
}

lambda无返回值

L2.13

import java.util.Arrays;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_13 {

    public static void main(String[] args) {
//        greetFolks();
//        concat();
    }
    public static void greetFolks() {
        Consumer<String> doGreet = name -> System.out.println("hello ," + name);
        for(String name: Arrays.asList("alice","bob","cathy")) {
            doGreet.accept(name);
        }
    }

    public static void concat() {
        BiConsumer<String,String> printConcat = (left,right) ->
                System.out.println(left + right);
        for(String name: Arrays.asList("alice","bob","cathy")) {
            printConcat.accept("good bye," ,name);
        }
    }
}

lambda复杂主体

import java.io.*;
import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_14 {

    public static void main(String[] args) {
        Function<File,Byte> firstByte = file -> {

            try (InputStream in = new FileInputStream(file)) {
                return (byte)in.read();
            } catch (IOException e) {
                throw new RuntimeException("could not read file : " + file,e);
            }
        };

        for(String filename:args) {
            File file = new File(filename);
            int byte1 = firstByte.apply(file);
            System.out.println(filename + "\t=\t" + byte1);
        }
    }
}

lambda显式指定类型

import java.nio.charset.Charset;
import java.util.function.Function;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_15 {

    public static void main(String[] args) {

        // 冲突，不知道调用哪个
//        transform(args[0],str->str.toUpperCase());
        // 添加参数声明，它就知道是哪个了
        transform(args[0],(String str)->str.toUpperCase());
    }

    public static String transform(String str, Function<String,String> transformer) {
        System.out.println(1);
        return transformer.apply(str);
    }

    public static CharSequence transform(
            CharSequence str,
            Function<CharSequence, CharSequence> transformer) {
        System.out.println(2);
        return transformer.apply(str);
    }
}

lambda作为操作符

import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.UnaryOperator;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_16 {

    public static void main(String[] args) {
        UnaryOperator<String> upperCase = str -> str.toUpperCase();
        BinaryOperator<String> concat = (left,right) -> left + right;//省略了return
    }
}

lambda作为谓词

仅仅返回true或者false。

import java.util.function.BinaryOperator;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_17 {

    public static void main(String[] args) {
        Predicate<String> notNullOrEmpty  = s -> s != null && !s.equals("");
    }

}

lambda作为原始参数(基本数据类型)

import java.util.Random;
import java.util.function.*;

/**
 * 邱道长
 * 2020/2/24
 */
public class L2_18 {

    public static void main(String[] args) {
        IntFunction<String> intToString = i -> Integer.toString(i);
        ToIntFunction<String> parseInt = i -> Integer.valueOf(i);
        IntPredicate isEven = i -> i % 2 == 0;
        ToIntBiFunction<String,String> maxLength = (left,right) ->
                Math.max(left.length(),right.length());
        IntConsumer printInt = i -> System.out.println(Integer.toString(i));
        ObjIntConsumer<String> printParsedIntWithRadix = (str,radix) ->
                System.out.println(Integer.parseInt(str,radix));

        IntSupplier randomInt = () -> new Random().nextInt();
        IntUnaryOperator negateInt = i -> -i;
        IntBinaryOperator multiplyInt = (x,y) -> x*y;

        IntToDoubleFunction intAsDouble = i -> Integer.valueOf(i).doubleValue();

        DoubleToIntFunction doubleAsInt = i -> Double.valueOf(i).intValue();

        IntToLongFunction intAsLong = i -> Integer.valueOf(i).longValue();
        LongToIntFunction longAsInt = i -> Long.valueOf(i).intValue();


    }
}

理解Java8中 lambda