lambda表达式

本质：

将接口实例对象，当作属性传

演变过程

内部类 -> 匿名内部类 -> 函数式接口 -> 创建线程的三种方式 -> Stream的使用

内部类

普通内部类：Sub类，定义在类中的类，如：
定义：

public class FunctionalTest {
    public class Sub {
        private int a;
        private String b;
        public int getA() {
            return a;
        }
    }
}
使用：
public class Test {
    public static void main(String[] args) {
        FunctionalTest functionalTest = new FunctionalTest();
        FunctionalTest.Sub sub1 = functionalTest.new Sub();
        sub1.getA();
    }
}       

静态内部类，使用static修饰的内部类，如：Sub

FunctionalTest.Sub sub = new FunctionalTest.Sub();

方法内部类：定义在方法内部。

匿名内部类

  内部类的简化，直接在使用的方法中，直接在new出来对象放在参数中。

public interface Calculate {
    int sum(int a, int b);
}

public class FunctionalTest {
    int toSum(Calculate calculate, int a, int b) {
        return calculate.sum(a, b);
    }
}

public class Test {
    public static void main(String[] args) {
        FunctionalTest functionalTest = new FunctionalTest();
        functionalTest.toSum((a, b)-> a+b, 1, 2);//匿名内部类的使用
    }
}

函数式接口

简单地说，就是只有一个抽象方法的接口，不包括从object类中继承的方法，和default，static修饰的方法。
如：使用@FunctionalInterface修饰

@FunctionalInterface
public interface Calculate {
    int sum(int a, int b);
    default int value(int A){
        return A;
    }
    static String getName(){
        return "A";
    }
}

创建线程的三种方式

1，继承Thread类，重写run()方法。
ThreadByThread threadByThread = new ThreadByThread();
threadByThread.setName("ThreadByThread");
threadByThread.start();
2，实现runnable接口，重写run()方法
Thread threadByRunnable = new Thread(new ThreadByRunnable());
//Thread threadByRunnable = new Thread(() -> System.out.println(Thread.currentThread().getName()));
threadByRunnable.setName("ThreadByRunnable");
threadByRunnable.start();
3，实现callable接口，重写call()方法，这个是有返回值，
FutureTask<String> stringFutureTask = new FutureTask<>(new ThreadByCallable());
//FutureTask<String> stringFutureTask = new FutureTask<>(() -> "return String");
Thread threadByCallable = new Thread(stringFutureTask);
threadByCallable.setName("ThreadByCallable");
threadByCallable.start();
try {
    String s = stringFutureTask.get();
    System.out.println(s);
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

Stream的使用

  贴心准备的函数式接口：下面这些接口，可以作为方法的参数。
Consumer<? super T> Consumer<T>  消费型：接收一个参数T，不返回结果
Supplier<? extends T> Supplier<T>  供给型：不接收参数，返回T对象创建的工厂
Predicate<? super T> Predicate<T>  断言型：接收参数T，返回一个Boolean类型的结果
Function<? super T, ? extends U> Function<T, R> 功能型：接收参数对象T，返回结果对象R
  应用：
    String分割成数组
String s = "aa,bb,cc,dd,ee,ff,gg";
String[] split = s.split(",");
Arrays.stream(split).forEach(a-> System.out.println(a));
    map的遍历
Map<Integer, String> map = Collections.emptyMap();
map.forEach((k, v)->System.out.println(k+"->"+v));