Lambda 表达式

枚举

优点：将常量组织起来统一进行管理
场景：错误状态码，消息类型，颜色的划分，状态机等

常用方法：

方法名称	描述
values()	以数组形式返回枚举类型的所有成员
ordinal()	获取枚举成员的索引位置
valueOf()	将普通字符串转换为枚举实例
compareTo()	比较两个枚举成员在定义时的顺序

public enum demoEnum {

    RED("red",1),BLACK("black",4),GREEN("green",3),WHITE("white",2);

    public String color;
    public int ordinal;

    demoEnum(String color,int ordinal){
        //super();
        this.color = color;
        this.ordinal = ordinal;
    }
    //默认是私有的
    demoEnum(){
    }

    public static void main(String[] args) {
        //把字符串变成对应的枚举对象
        demoEnum test = demoEnum.valueOf("RED");
        System.out.println(test);

        System.out.println(RED.compareTo(GREEN));//默认索引比较
        System.out.println(BLACK.compareTo(RED));
    }

    public static void main3(String[] args) {
        demoEnum[] demoEnums = demoEnum.values();
        for (int i = 0; i < demoEnums.length; i++) {
            System.out.println(demoEnums[i] + " -> " + demoEnums[i].ordinal());
        }
    }

    public static void main2(String[] args) {
        demoEnum test = demoEnum.BLACK;
        switch (test) {
            case RED:
                System.out.println("red");
                break;
            case BLACK:
                System.out.println("black");
                break;
            case WHITE:
                System.out.println("WHITE");
                break;
            case GREEN:
                System.out.println("black");
                break;
            default:
                break;
        }
    }

    /*public static void main(String[] args) {
        System.out.println(demoEnum.RED);
        System.out.println(RED);
    }*/

}

优点：

1. 枚举常量更简单安全
2. 枚举具有内置方法 ，代码更优雅

缺点：

1. 不可继承，无法扩展

不能通过反射获得枚举的实例对象

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class testEnum {
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classEnum = Class.forName("demoEnum");

            Constructor<?> con = classEnum.getDeclaredConstructor(String.class,int.class);

            con.setAccessible(true);

            Object obj = con.newInstance("绿色",6,"green","9");
            demoEnum d1 = (demoEnum) obj;
            System.out.println("获得枚举的私有构造函数："+d1);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //不能通过反射获得枚举的实例对象
        reflectPrivateConstructor();
    }

}

Lambda 表达式

Lambda 表达式只针对有一个抽象方法的接口实现，它允许通过表达式来代替功能接口， 提供了一个正常的参数列表和一个使用这些参数的主体 ( body，可以是一个表达式或一个代码块)
Lambda 表达式可以看作是一个匿名函数

([数据类型 参数名,数据类型 参数名, ... ]) -> {表达式主体}

// 1. 不需要参数,返回值为 
2 () -> 2 
// 2. 接收一个参数(数字类型),返回其2倍的值 
x -> 2 * x 
// 3. 接受2个参数(数字),并返回他们的和 
(x, y) -> x + y 
// 4. 接收2个int型整数,返回他们的乘积 
(int x, int y) -> x * y 
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值
(String s) -> System.out.print(s)

使用：

@FunctionalInterface
interface TestLam1{
    void test();
}

@FunctionalInterface
interface TestLam2{
    void test(int a);
}

@FunctionalInterface
interface TestLam3{
    void test(int a,int b);
}

@FunctionalInterface
interface TestLam4{
    int test();
}

@FunctionalInterface
interface TestLam5{
    int test(int a);
}

@FunctionalInterface
interface TestLam6{
    int test(int a,int b);
}

public class lambdaDemo {

    public static void main(String[] args) {
        TestLam1 t1 = ()->System.out.println("Lambda");
        t1.test();

        TestLam2 t2 = (a)-> System.out.println(a);
        t2.test(1);

        TestLam3 t3 = (a,b)-> System.out.println(a+b);
        t3.test(1,2);

        TestLam4 t4 = ()->{return 10;};
        int ret1 = t4.test();
        System.out.println(ret1);

        TestLam5 t5 = (a)->{return a*2;};
        int ret2 = t5.test(5);
        System.out.println(ret2);

        TestLam6 t6 = (a,b)->{return a+b;};
        int ret3 = t6.test(1,2);
        System.out.println(ret3);
    }

    public static void main1(String[] args) {
        TestLam1 t1 = new TestLam1() {
            @Override
            public void test() {
                System.out.println("Lambda");
            }
        };
        t1.test();
    }

}

优点：

1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java 引入 Lambda，改善了集合操作

缺点：

1. 代码可读性变差
2. 在非并行计算中，很多计算未必有传统的 for 性能要高
3. 不容易进行调试