理解和运用Java中的Lambda（上）

// java.lang.Runnable
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}  
// java.util.function.Supplier
@FunctionalInterface
public interface Supplier<T> {
    T get();
}
复制代码

@FunctionalInterface
public interface CustomFunctionalInterface {
    // 可以缩写为void process();  接口方法定义的时候，默认使用public abstract修饰
    public abstract void process();
}
复制代码

public interface DefaultMethod {
    default void defaultVoidMethod() {
    }
    default String sayHello(String name) {
        return String.format("%s say hello!", name);
    }
    static void main(String[] args) throws Exception {
        class Impl implements DefaultMethod {
        }
        DefaultMethod defaultMethod = new Impl();
        System.out.println(defaultMethod.sayHello("throwable"));  // throwable say hello!
    }
}
复制代码

@FunctionalInterface
public interface CustomFunctionalInterface {
    public abstract void process();
    default void defaultVoidMethod() {
    }
    default String sayHello(String name) {
        return String.format("%s say hello!", name);
    }
}
复制代码

// 封闭类
class OuterClass {
    ...
    // 静态嵌套类
    static class StaticNestedClass {
        ...
    }
    // 内部类
    class InnerClass {
        ...
    }
}
复制代码

public class OuterClass {
    int x = 1;
    static class StaticNestedClass {
    }
    class InnerClass {
        // 内部类可以访问封闭类的属性
        int y = x;
    }
    public static void main(String[] args) throws Exception {
        OuterClass outerClass = new OuterClass();
        // 必须这样实例化内部类 - 声明的语法相对奇特
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        // 静态嵌套类可以一般实例化,形式为:封闭类.静态嵌套类
        OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();
        // 如果main方法在封闭类内,可以直接使用静态嵌套类进行实例化
        StaticNestedClass x = new StaticNestedClass();
    }
}
复制代码

public class OuterClass {
    static int y = 1;
    {    
        // 本地类A
        class A{
            int z = y;
        }
        A a = new A();
    }
    static {
        // 本地类B
        class B{
            int z = y;
        }
        B b = new B();
    }
    private void method(){
        // 本地类C
        class C{
            int z = y;
        }
        C c = new C();
    }
}
复制代码

public class OuterClass {
    interface In {
        void method(String value);
    }
    public void sayHello(){
        // 本地类 - 类声明
        class LocalClass{
        }
        // 匿名类 - 是一个表达式
        In in = new In() {
            @Override
            public void method(String value) {
            }
        };
    }
}
复制代码

JButton button = new JButton();
button.addActionListener(new AbstractAction() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮事件被触发...");
    }
});
复制代码

Nested Classes
  - Static Nested Classes
  - None Nested Classes
    - Local Classes
    - Anonymous Classes
    - Other Inner Classes
复制代码

// en_US
InterfaceType interfaceObject = [Method Argument List] -> Method Body
// zh_CN
接口类型 接口实例 = [方法参数列表] -> 方法体
复制代码

// Function - 具体
java.util.function.Function<String, Integer> functionY = (String string) -> {
    return Integer.parseInt(string);
};
// Function - 简化
java.util.function.Function<String, Integer> functionX = string -> Integer.parseInt(string);
// Runnable - 具体
Runnable runnableX = () -> {
    System.out.println("Hello World!");
};
// Runnable - 简化
Runnable runnableY = () -> System.out.println("Hello World!");
// 整数1-100的和 - 具体
int reduceX = IntStream.range(1, 101).reduce(0, (int addend, int augend) -> {
    return addend + augend;
});
// 整数1-100的和 - 简化
int reduceY = IntStream.range(1, 101).reduce(0, Integer::sum);
复制代码

// club.throwable.Runnable
@FunctionalInterface
public interface Runnable {
    void run();
    static void main(String[] args) throws Exception {
        java.lang.Runnable langRunnable = () -> {};
        club.throwable.Runnable customRunnable = () -> {};
        langRunnable.run();
        customRunnable.run();
    }
}
复制代码

// 显式类型
Function<String, String> functionX = (String x) -> x;
// 隐式类型
Function<String, Integer> functionY = x -> Integer.parseInt(x);
复制代码

// 编译不通过
Object runnableX = () -> {};
// 编译通过 - Cast
Object runnableY = (Runnable) () -> {};
// 静态方法入参类型是函数式接口
public static void function(java.util.function.Function function) {
}
function((Function<String, Long>) (x) -> Long.parseLong(x));
复制代码

public class LambdaThis {
    int x = 1;
    public void method() {
        Runnable runnable = () -> {
            int y = this.x;
            y++;
            System.out.println(y);
        };
        runnable.run();
    }
    public static void main(String[] args) throws Exception {
        LambdaThis lambdaThis = new LambdaThis();
        lambdaThis.method();   // 2
    }
}
复制代码

public class LambdaScope {
    public void method() {
        int x = 1;
        Runnable runnable = () -> {
            // 编译不通过 - Lambda方法体外部已经定义了同名变量
            int x = 2;
        };
        runnable.run();
    }
}
复制代码

public class LambdaValue {
    public void method() {
        (final) int x = 1;
        Runnable runnable = () -> {
            // 编译不通过 - 外部值类型使用了final
            x ++;
        };
        runnable.run();
    }
}
public class LambdaValue {
    public void method() {
        (final) IntHolder holder = new IntHolder();
        Runnable runnable = () -> {
            // 编译通过 - 使用了引用类型
            holder.x++;
        };
        runnable.run();
    }
    private static class IntHolder {
        int x = 1;
    }
}
复制代码

// 静态方法引用
public class StaticMethodRef {
    public static void main(String[] args) throws Exception {
        Function<String, Integer> function = StaticMethodRef::staticMethod;
        Integer result = function.apply("10086");
        System.out.println(result);  // 10086
    }
    public static Integer staticMethod(String value) {
        return Integer.parseInt(value);
    }
}
// 指定对象实例方法引用
public class ParticularInstanceRef {
    public Integer refMethod(String value) {
        return Integer.parseInt(value);
    }
    public static void main(String[] args) throws Exception{
        ParticularInstanceRef ref = new ParticularInstanceRef();
        Function<String, Integer> function = ref::refMethod;
        Integer result = function.apply("10086");
        System.out.println(result);  // 10086
    }
}
// 特定类型任意对象方法引用
String[] stringArray = {"C", "a", "B"};
Arrays.sort(stringArray, String::compareToIgnoreCase);
System.out.println(Arrays.toString(stringArray)); // [a, B, C]
// 超类方法引用
public class SupperRef {
    public static void main(String[] args) throws Exception {
        Sub sub = new Sub();
        System.out.println(sub.refMethod("10086")); // 10086
    }
    private static class Supper {
        private Integer supperRefMethod(String value) {
            return Integer.parseInt(value);
        }
    }
    private static class Sub extends Supper {
        private Integer refMethod(String value) {
            Function<String, Integer> function = super::supperRefMethod;
            return function.apply(value);
        }
    }
}
// 构造器方法引用
public class ConstructorRef {
    public static void main(String[] args) throws Exception {
        Function<String, Person> function = Person::new;
        Person person = function.apply("doge");
        System.out.println(person.getName()); // doge
    }
    private static class Person {
        private final String name;
        public Person(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    }
}
// 数组构造器方法引用
Function<Integer, Integer[]> function = Integer[]::new;
Integer[] array = function.apply(10);
System.out.println(array.length); // 10
复制代码