Java8新特性之Lambda表达式，函数式接口，方法引用和default关键字

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

@FunctionalInterface
public interface MyNumber<T> {
    T getValue(T t);
}
复制代码

public static void main(String[] args) {
        //Lambda的写法
        System.out.println(toUpperString(str -> str.toUpperCase(), "abc")); //ABC
        //匿名内部类的写法
        System.out.println(toUpperString(new MyNumber<String>() {
            @Override
            public String getValue(String s) {
                return s;
            }
        }, "abc"));
    }
    public static String toUpperString(MyNumber<String> mn, String str) {
        return mn.getValue(str);
    }
复制代码

public static void main(String[] args) {
        //Lambda的写法
        System.out.println(toUpperString1(str -> str.toUpperCase(), "abc")); //ABC
        //匿名内部类的写法
        System.out.println(toUpperString1(new MyNumber<String>() {
            @Override
            public String getValue(String s) {
                return s;
            }
        }, "abc"));
        //使用内置的函数式接口的lambda写法
        System.out.println(toUpperString(str->str.toUpperCase(),"abc"));
    }
    //内置的函数接口
    public static String toUpperString(Function<String,String> mn, String str) {
        return mn.apply(str);
    }
    //定义的函数接口
    public static String toUpperString1(MyNumber<String> mn, String str) {
        return mn.getValue(str);
    }
复制代码

//例如：此时Consumer参数类型和返回值和println方法一致
        //对象::实例方法名
        //为什么这样用，因为 ConSumer这个函数接口就是传入参数，返回为void ,并且printl 方法就是这样的
        /**我们看下面的源码 和那个函数接口一样
         *     public void println(String x) {
         *         synchronized (this) {
         *             print(x);
         *             newLine();
         *         }
         *     }
         */
        PrintStream printStream=System.out;
        Consumer<String> con= printStream::println;
        con.accept("haha");
        /类::静态方法名
    Comparator<Integer> com=Integer::compare;
    Comparator<Integer> com1=(x,y)->Integer.compare(x,y);
复制代码

Function<Integer,MyClass> fun= n->new MyClass(1);
        Function<Integer,MyClass> fun1=MyClass::new ;
        MyClass apply = fun1.apply(1);
复制代码

public interface NewCharacter {
    public void test1();
    public default void test2(){
        System.out.println("我是新特性1");
    }
}
复制代码

public class NewCharacterImpl implements NewCharacter{
    @Override
    public void test1() {
    }
    public static void main(String[] args) {
        NewCharacter nca = new NewCharacterImpl();
        nca.test2();
    }
}
复制代码