6-3 lambda 表达式

package interfacepage;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Stream;

import javax.swing.Timer;

import tools.ArrayTools;

public class LambdaTetsO {

    /**
     * 函数式接口
     * 
     * 定义：只有一个抽象方法的接口，需要这个这个接口的对象时，可以使用lambda表达式。这种接口成为函数式接口。
     * 
     * 方法引用
     * 
     * 构造器引用
     * 
     * 变量作用域
     * 
     * 
     * 处理lambda表达式
     * 
     * 再谈comparator
     * 
     * 
     */
    
    public static void main(String[] args) {
        
    /*    //函数式接口
        
        *//**
         * 在底层会调用Compare类的某个对象，执行compare方法时会调用 lambda表达式
         *//*
        String[]  word = {"a","b"};
        Arrays.sort(word, (first,second) -> {
            return first.length() - second.length();
            });
        
        *//**
         * lambda表达式可以转换成接口，这让labmbda表达式很有吸引力（可读性更高）
         *//*
        new Timer(1000, event -> {
            System.out.println("aaa");
        });*/
        
        
        //方法引用，将方法传递到构造器
        Timer t  =  new Timer(1000,System.out::println);
//        t.start();
        //等价于lambda表达式 x -> System.out.println(x);
        Timer t2 =  new Timer(1000,x -> System.out.println(x));
//        t2.start();
        /*String[]  word = {"a","C","b","E","f"};
        Arrays.sort(word, String::compareToIgnoreCase);
        System.out.println(new ArrayTools<>().toString(word));*/
        
        
        /**
         * 用 :: 分割方法名  对象/类名
         * 
         * 形式：
         * object:instanceMethod
         * Class:staticMethod
         * Class:instanceMethod
         * 
         * 
         * 方法引用中可以使用 this,spuer 关键字
         */
        
        
        //构造器引用
        /**
         * 方法名为new
         * 
         * 
         */
        //////??????????
//        LambdaTetsO[] newLambdaTetsO =  new Stream().toArray(LambdaTetsO[]::new);
        
        
        //变量作用域
        /**
         *在lambda表达式中访问外围的方法或者类中的变量
         *
         *  会隔断时间之后才会执行lanbda表达式，会有安全问题。所以参数必须必须是不可变的。
         */
        
        message("200", 1000);
    }
    
/*    interface compa extends Comparator<String>{
        @Override
        default int compare(String o1, String o2) {
            return o1.length() - o2.length();
        }
    }*/
    
    
    //变量作用域
    public static void message(String text,int delay){
        
        ActionListener listener = event -> {
//            text = "33";
            System.out.println("listener"+text);
        };
        new Timer(delay, listener).start();
    }
    
    
    
    class Greeter {
        
        public  void greet(){
            System.out.println("Greeter");
        }
    }
    
    class GreeterSub extends  Greeter{
        //////////????????
//        @Override
        public void greet() {
//            super.greet();
//            Timer t = new Timer(1000, super::greet);
//            t.start();
        }
    }
    
}

 

package interfacepage;

public class DealLambda {

    public static void main(String[] args) {
        
//        repeat(10, () -> { System.out.println("hello");});
//        repeat(10, () -> System.out.println("hello"));
        
        
        
//        repeat(10, x-> { System.out.println("hello"+x);});
        repeat(10, System.out::println);//方法引用
    }
    
    /**
     * lanbda表达式的核心是延迟处理
     * 
     * 接受labmda表达式需要函数式接口
     * 
     * 最好使用已经存在的函数式接口
     * 
     * 
     * 
     * 任何接口都默认函数式接口，@FunctionalInterface标记告诉编译器这是个函数式接口
     */

    
    /*public static void repeat(int n,Runnable acton){
        for (int i = 0; i < n; i++) {
            System.out.println("i->>>>"+i); 
            acton.run();
        }
    }*/
    
    @FunctionalInterface
    interface intConsumer{
        void accept( int i);
    }
    
    public static void repeat(int n,intConsumer acton){
        for (int i = 0; i < n; i++) {
            System.out.println("i->>>>"+i); 
            acton.accept(i);
        }
    }
}