讲⼀下JDK1.8的新特性

题⽬描述

讲⼀下JDK1.8的新特性

解题思路

⾯试官问题可以从⼏个⽅⾯来回答：JDK1.8新特性

JDK1.8的新特性

1.default关键字

在java⾥⾯，我们通常都是认为接⼝⾥⾯是只能有抽象⽅法，不能有任何⽅法的实现的，那么在jdk1.8⾥⾯打破了这个规定，引⼊了新的关键字default，通过使⽤default修饰⽅法，可以让我们在接⼝⾥⾯定义具体的⽅法实现，如下。

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

2.Lambda表达式

Lambda表达式是jdk1.8⾥⾯的⼀个重要的更新，这意味着java也开始承认了函数式编程，并且尝试引⼊其中。

⾸先，什么是函数式编程，引⽤廖雪峰先⽣的教程⾥⾯的解释就是说：函数式编程就是⼀种抽象程度很⾼的编程范式，纯粹的函数式编程语⾔编写的函数没有变量，因此，任意⼀个函数，只要输⼊是确定的，输出就是确定的，这种纯函数我们称之为没有副作⽤。⽽允许使⽤变量的程序设计语⾔，由于函数内部的变量状态不确定，同样的输⼊，可能得到不同的输出，因此，这种函数是有副作⽤的。函数式编程的⼀个特点就是，允许把函数本身作为参数传⼊另⼀个函数，还允许返回⼀个函数！

简单的来说就是，函数也是⼀等公⺠了，在java⾥⾯⼀等公⺠有变量，对象，那么函数式编程语⾔⾥⾯函数也可以跟变量，对象⼀样使⽤了，也就是说函数既可以作为参数，也可以作为返回值了，看⼀下下⾯这个例⼦。

// 这是常规的Collections的排序的写法，需要对接⼝⽅法重写
public void test1(){
  List<String> list =Arrays.asList("aaa","fsa","ser","eere");
  Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
      return o2.compareTo(o1);
    }
  });
  for (String string : list) {
    System.out.println(string);
  }
}
// 这是带参数类型的Lambda的写法
public void testLamda1(){
    List<String> list =Arrays.asList("aaa","fsa","ser","eere");
    Collections.sort(list, (Comparator<? super String>) (String a,String
    b)->{
      return b.compareTo(a);
    }
  );
  for (String string : list) {
    System.out.println(string);
  }
}
// 这是不带参数的lambda的写法
public void testLamda2(){
  List<String> list =Arrays.asList("aaa","fsa","ser","eere");
  Collections.sort(list, (a,b)->b.compareTo(a));
  for (String string : list) {
    System.out.println(string);
  }
}

可以看到不带参数的写法⼀句话就搞定了排序的问题，所以引⼊lambda表达式的⼀个最直观的作⽤就是⼤⼤的简化了代码的开发，像其他⼀些编程语⾔Scala，Python等都是⽀持函数式的写法的。当然，不是所有的接⼝都可以通过这种⽅法来调⽤，只有函数式接⼝才⾏，jdk1.8⾥⾯定义了好多个函数式接⼝，我们也可以⾃⼰定义⼀个来调⽤，下⾯说⼀下什么是函数式接⼝。

3.函数式接⼝

定义：“函数式接⼝”是指仅仅只包含⼀个抽象⽅法的接⼝，每⼀个该类型的lambda表达式都会被匹配到这个抽象⽅法。jdk1.8提供了⼀个@FunctionalInterface注解来定义函数式接⼝，如果我们定义的接⼝不符合函数式的规范便会报错。

@FunctionalInterface
public interface MyLamda {
  public void test1(String y);
    // 这⾥如果继续加⼀个抽象⽅法便会报错
    // public void test1();
    // default⽅法可以任意定义
    default String test2(){
      return "123";
    }
    default String test3(){
      return "123";
    }
    // static⽅法也可以定义
    static void test4(){
    System.out.println("234");
  }
}
// 接⼝的调⽤
MyLamda m = y -> System.out.println("ss"+y);

4.⽅法与构造函数引⽤

jdk1.8提供了另外⼀种调⽤⽅式::，当 你 需 要使⽤ ⽅ 法 引⽤时 ， ⽬ 标引⽤ 放 在 分隔符::前 ，⽅法的 名 称放在 后 ⾯ ，即 ClassName :: methodName 。例如 ， Apple::getWeight 就是引⽤了Apple类中定义的⽅法getWeight。请记住，不需要括号，因为你没有实际调⽤这个⽅法。⽅法引⽤就是Lambda表达式 (Apple a) -> a.getWeight() 的快捷写法，如下示例。

// 先定义⼀个函数式接⼝
@FunctionalInterface
  public interface TestConverT<T, F> {
  F convert(T t);
}
// 调⽤⽅式
public void test(){
  TestConverT<String, Integer> t = Integer::valueOf;
  Integer i = t.convert("111");
  System.out.println(i);
}

此外，对于构造⽅法也可以这么调⽤。

//实体类User和它的构造⽅法
public class User {
  private String name;
  private String sex;
  public User(String name, String sex) {
    super();
    this.name = name;
    this.sex = sex;
  }
}
//User⼯⼚
public interface UserFactory {
  User get(String name, String sex);
}
//测试类
UserFactory uf = User::new;
User u = uf.get("ww", "man");

5.局部变量限制

Lambda表达式也允许使⽤⾃由变量（不是参数，⽽是在外层作⽤域中定义的变量），就像匿名类⼀样。 它们被称作捕获Lambda。 Lambda可以没有限制地捕获（也就是在其主体中引⽤）实例变量和静态变量。但局部变量必须显式声明为final，或事实上是final。

为什么局部变量有这些限制？

• （1）实例变量和局部变量背后的实现有⼀个关键不同。实例变量都存储在堆中，⽽局部变量则保存在栈上。如果Lambda可以直接访问局部变量，⽽且Lambda是在⼀个线程中使⽤的，则使⽤Lambda的线程，可能会在分配该变量的线程将这个变量收回之后，去访问该变量。因此， Java在访问⾃由局部变量时，实际上是在访问它的副本，⽽不是访问原始变量。如果局部变量仅仅赋值⼀次那就没有什么区别了——因此就有了这个限制。
• （2）这⼀限制不⿎励你使⽤改变外部变量的典型命令式编程模式。

final int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2);

6.Date Api更新

1.8之前JDK⾃带的⽇期处理类⾮常不⽅便，我们处理的时候经常是使⽤的第三⽅⼯具包，⽐如

commons-lang包等。不过1.8出现之后这个改观了很多，⽐如⽇期时间的创建、⽐较、调整、格式化、时间间隔等。这些类都在java.time包下。⽐原来实⽤了很多。

6.1 LocalDate/LocalTime/LocalDateTime

LocalDate为⽇期处理类、LocalTime为时间处理类、LocalDateTime为⽇期时间处理类，⽅法都类似，具体可以看API⽂档或源码，选取⼏个代表性的⽅法做下介绍。

now相关的⽅法可以获取当前⽇期或时间，of⽅法可以创建对应的⽇期或时间，parse⽅法可以解析⽇期或时间，get⽅法可以获取⽇期或时间信息，with⽅法可以设置⽇期或时间信息，plus或minus⽅法可以增减⽇期或时间信息；

6.2 TemporalAdjusters

这个类在⽇期调整时⾮常有⽤，⽐如得到当⽉的第⼀天、最后⼀天，当年的第⼀天、最后⼀天，下⼀周或前⼀周的某天等。

6.3 DateTimeFormatter

以前⽇期格式化⼀般⽤SimpleDateFormat类，但是不怎么好⽤，现在1.8引⼊了

DateTimeFormatter类，默认定义了很多常量格式（ISO打头的），在使⽤的时候⼀般配合

LocalDate/LocalTime/LocalDateTime使⽤，⽐如想把当前⽇期格式化成yyyy-MM-dd hh:mm:ss的形式:

LocalDateTime dt = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
System.out.println(dtf.format(dt));

7.流

定义：流是Java API的新成员，它允许我们以声明性⽅式处理数据集合（通过查询语句来表达，⽽不是临时编写⼀个实现）。就现在来说，我们可以把它们看成遍历数据集的⾼级迭代器。此外，流还可以透明地并⾏处理，也就是说我们不⽤写多线程代码了。

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像⼀个⾼级版本的 Iterator。原始版本的 Iterator，⽤户只能显式地⼀个⼀个遍历元素并对其执⾏某些操作；⾼级版本的 Stream，⽤户只要给出需要对其包含的元素执⾏什么操作，⽐如 “过滤掉⻓度⼤于 10 的字符串”、“获取每个字符串的⾸字⺟”等，Stream 会隐式地在内部进⾏遍历，做出相应的数据转换。

Stream 就如同⼀个迭代器（Iterator），单向，不可往复，数据只能遍历⼀次，遍历过⼀次后即⽤尽了，就好⽐流⽔从⾯前流过，⼀去不复返。⽽和迭代器⼜不同的是，Stream 可以并⾏化操作，迭代器只能命令式地、串⾏化操作。顾名思义，当使⽤串⾏⽅式去遍历时，每个 item 读完后再读下⼀个item。⽽使⽤并⾏去遍历时，数据会被分成多个段，其中每⼀个都在不同的线程中处理，然后将结果⼀起输出。Stream 的并⾏操作依赖于 Java7 中引⼊的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。

流的操作类型分为两种：

• Intermediate：⼀个流可以后⾯跟随零个或多个 intermediate 操作。其⽬的主要是打开流，做出某种程度的数据映射/过滤，然后返回⼀个新的流，交给下⼀个操作使⽤。这类操作都是惰性化的（lazy），就是说，仅仅调⽤到这类⽅法，并没有真正开始流的遍历。
• Terminal：⼀个流只能有⼀个 terminal 操作，当这个操作执⾏后，流就被使⽤“光”了，⽆法再被操作。所以这必定是流的最后⼀个操作。Terminal 操作的执⾏，才会真正开始流的遍历，并且会⽣成⼀个结果，或者⼀个 side effect。

在对于⼀个 Stream 进⾏多次转换操作 (Intermediate 操作)，每次都对 Stream 的每个元素进⾏转换，⽽且是执⾏多次，这样时间复杂度就是 N（转换次数）个 for 循环⾥把所有操作都做掉的总和吗？

其实不是这样的，转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，⼀次循环完成。我们可以这样简单的理解，Stream ⾥有个操作函数的集合，每次转换操作就是把转换函数放⼊这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执⾏所有的函数。

// 构造流的⼏种⽅式
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

8.Objects⽅法新特性

//⽐较两个对象是否相等（⾸先⽐较内存地址，然后⽐较a.equals(b)，只要符合其中之⼀返回true）
public static boolean equals(Object a, Object b);
//深度⽐较两个对象是否相等(⾸先⽐较内存地址,相同返回true;如果传⼊的是数组，则⽐较数组内的对应下标值是否相同)
public static boolean deepEquals(Object a, Object b);
//返回对象的hashCode，若传⼊的为null，返回0
public static int hashCode(Object o);
//返回传⼊可变参数的所有值的hashCode的总和（这⾥说总和有点牵强，具体参考Arrays.hashCode()⽅法）
public static int hash(Object... values);
//返回对象的String表示，若传⼊null，返回null字符串
public static String toString(Object o)
//返回对象的String表示，若传⼊null，返回默认值nullDefault
public static String toString(Object o, String nullDefault)
//使⽤指定的⽐较器c ⽐较参数a和参数b的⼤⼩（相等返回0，a⼤于b返回整数，a⼩于b返回负数）
public static <T> int compare(T a, T b, Comparator<? super T> c)
//如果传⼊的obj为null抛出NullPointerException,否者返回obj
public static <T> T requireNonNull(T obj)
//如果传⼊的obj为null抛出NullPointerException并可以指定错误信息message,否者返回obj
public static <T> T requireNonNull(T obj, String message)


// -----------------------------以下是jdk8新增⽅法---------------------------
//判断传⼊的obj是否为null，是返回true,否者返回false
public static boolean isNull(Object obj)
//判断传⼊的obj是否不为null，不为空返回true,为空返回false （和isNull()⽅法相反）
public static boolean nonNull(Object obj)
//如果传⼊的obj为null抛出NullPointerException并且使⽤参数messageSupplier指定错误信息,否者返回obj
public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier)

package cn.cupcat.java8;
import org.junit.Test;
import java.util.Comparator;
import java.util.Objects;




/**
 * Created by xy on 2017/12/25.
 */
public class ObjectsTest {
/**
 * 因为Objects类⽐较简单，所以只⽤这⼀个测试⽤例进⾏测试
 * */
	@Test
	public void equalsTest()
	{
		String	str1	= "hello";
		String	str2	= "hello";
        /*
         * ⼊对象
         * Objects.equals(str1, str2) ? true
         */
		boolean equals = Objects.equals( str1, str2 );
		System.out.println( "Objects.equals(str1, str2) ? " + equals );
	}




	@Test
	public void deepEqualsTest()
	{
		String	str1	= "hello";
		String	str2	= "hello";
        /*传⼊对象 */
		boolean deepEquals = Objects.deepEquals( str1, str2 );
        /* Objects.deepEquals(str1, str2) ? true */
		System.out.println( "Objects.deepEquals(str1, str2) ? " + deepEquals );
		int[] arr1	= { 1, 2 };
		int[] arr2	= { 1, 2 };
        /*传⼊数组 */
		deepEquals = Objects.deepEquals( arr1, arr2 );
        /* Objects.deepEquals(arr1, arr2) ? true */
		System.out.println( "Objects.deepEquals(arr1, arr2) ? " + deepEquals );
	}




	@Test
	public void hashCodeTest()
	{
		String str1 = "hello";
        /*传⼊对象 */
		int hashCode = Objects.hashCode( str1 );
        /* Objects.hashCode(str1) ? 99162322 */
		System.out.println( "Objects.hashCode(str1) ? " + hashCode );
        /*传⼊null */
		hashCode = Objects.hashCode( null );
        /* Objects.hashCode(null) ? 0 */
		System.out.println( "Objects.hashCode(null) ? " + hashCode );
	}




	@Test
	public void hashTest()
	{
		int a = 100;
        /*传⼊对象 */
		int hashCode = Objects.hashCode( a );
        /* Objects.hashCode(str1) ? 100 */
		System.out.println( "Objects.hashCode(str1) ? " + hashCode );
        /* 输⼊数组 */
		int[] arr	= { 100, 100 };
		hashCode	= Objects.hash( arr );
        /* Objects.hashCode(arr) ? 1555093793 */
		System.out.println( "Objects.hashCode(arr) ? " + hashCode );
	}




	@Test
	public void compareTest()
	{
		int	a	= 10;
		int	b	= 11;
		int	compare = Objects.compare( a, b, new Comparator<Integer>()
         {
      	   @Override
      	   public int compare( Integer o1, Integer o2 )
      	   {
      		   return(o1.compareTo( o2 ) );
      	   }
         } );
        /* compare = -1 */
		System.out.println( " compare = " + compare );
	}




	@Test
	public void requireNonNullTest()
	{
		String test = null;
      /*
       * java.lang.NullPointerException
       * String s = Objects.requireNonNull(test);
       * java.lang.NullPointerException: 这是空指针异常提示的信息
       * String s = Objects.requireNonNull(test, "这是空指针异常提示的信息");
       * java.lang.NullPointerException: 我是返回的异常信息
       */
		String s = Objects.requireNonNull( test, () - > "我是返回的异常信息" );
	}
}

总结

说清楚JDK1.8新特性，已经做了哪些优化。

反射相关

题⽬描述

框架中处处可⻅反射的运⽤，你对反射了解多少？

解题思路

⾯试官问题可以从⼏个⽅⾯来回答：什么是反射？反射有什么⽤？反射的⼯作原理

什么是反射

反射是⼀种能够在程序运⾏时动态访问，修改某个类中任意属性和⽅法的机制（包括private实例和⽅法）

java反射机制提供了⼀下⼏个功能：

• 在运⾏时判断任意⼀个对象所属的类
• 在运⾏时构造任意⼀个类的对象
• 在运⾏时判断任意⼀个类所具有的成员变量和⽅法
• 在运⾏时调⽤任意⼀个对象的⽅法

反射涉及到的四个核⼼类：

• java.lang.Class.java：类对象；
• java.lang.reflect.Constructor.java：类的构造器对象；
• java.lang.reflect.Method.java：类的⽅法对象；
• java.lang.reflect.Field.java：类的属性对象；

反射有什么⽤

• 操作因访问权限限制的属性和⽅法；
• 实现⾃定义注解；
• 动态加载第三⽅jar包，解决android开发中⽅法数不能超过65536个的问题；
• 按需加载类，节省编译和初始化APK的时间；

反射⼯作原理

当我们编写完⼀个Java项⽬之后，每个java⽂件都会被编译成⼀个.class⽂件，这些Class对象承载了这个类的所有信息，包括⽗类、接⼝、构造函数、⽅法、属性等，这些class⽂件在程序运⾏时会被ClassLoader加载到虚拟机中。

当⼀个类被加载以后，Java虚拟机就会在内存中⾃动产⽣⼀个Class对象。我们通过new的形式创建对象实际上就是通过这些Class来创建，只是这个过程对于我们是不透明的⽽已。

反射的⼯作原理就是借助Class.java、Constructor.java、Method.java、Field.java这四个类在程序运⾏时动态访问和修改任何类的⾏为和状态。

反射的特点

优点

• ##灵活、⾃由度⾼： 不受类的访问权限限制，想对类做啥就做啥；

缺点

• 性能问题： 通过反射访问、修改类的属性和⽅法时会远慢于直接操作，但性能问题的严重程度取决于在程序中是如何使⽤反射的。如果使⽤得很少，不是很频繁，性能将不会是什么问题；
• 安全性问题： 反射可以随意访问和修改类的所有状态和⾏为，破坏了类的封装性，如果不熟悉被反射类的实现原理，随意修改可能导致潜在的逻辑问题；
• 兼容性问题： 因为反射会涉及到直接访问类的⽅法名和实例名，不同版本的API如果有变动，反射时找不到对应的属性和⽅法时会报异常；

总结

通过反射访问⽅法⽐实例慢很多；

有⽤到反射的类不能被混淆；

反射存在性能问题，但使⽤不频繁、按需使⽤时，对程序性能影响并不⼤；

反射存在安全性问题，因为可以随意修改类的所有状态和⾏为（包括private⽅法和实例）；

使⽤反射访问Android的API时需要注意因为不同API版本导致的兼容性问题；

Lambda 表达式

Lambda简介

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

对接口的要求

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface

修饰函数式接口的，要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。

Lambda 基础语法

我们这里给出六个接口，后文的全部操作都利用这六个接口来进行阐述。

/**多参数无返回*/
@FunctionalInterfacepublic
interface NoReturnMultiParam {  
  void method(int a, int b);
}
/**无参无返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
  void method();
}
/**一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam { 
  void method(int a);
}
/**多个参数有返回值*/
@FunctionalInterface
public interface ReturnMultiParam { 
  int method(int a, int b);
}
/*** 无参有返回*/
@FunctionalInterface
public interface ReturnNoParam { 
  int method();
}
/**一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
  int method(int a);
}

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

public class Test1 { 
  public static void main(String[] args) {   
    //无参无返回   
    NoReturnNoParam noReturnNoParam = () -> {  
      System.out.println("NoReturnNoParam");  
   };   
    noReturnNoParam.method();  
    //一个参数无返回  
    NoReturnOneParam noReturnOneParam = (int a) -> {  
      System.out.println("NoReturnOneParam param:" + a);
   };   
    noReturnOneParam.method(6);  
    //多个参数无返回 
    NoReturnMultiParam noReturnMultiParam = (int a, int b) -> { 
      System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}"); 
   };   
    noReturnMultiParam.method(6, 8);  
    //无参有返回值   
    ReturnNoParam returnNoParam = () -> {  
      System.out.print("ReturnNoParam");   
      return 1;  
   }; 
    int res = returnNoParam.method(); 
    System.out.println("return:" + res); 
    //一个参数有返回值  
    ReturnOneParam returnOneParam = (int a) -> { 
      System.out.println("ReturnOneParam param:" + a); 
      return 1; 
   };  
    int res2 = returnOneParam.method(6); 
    System.out.println("return:" + res2); 
    //多个参数有返回值  
    ReturnMultiParam returnMultiParam = (int a, int b) -> {
      System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}"); 
      return 1;  
   };  
    int res3 = returnMultiParam.method(6, 8); 
    System.out.println("return:" + res3);
 }
}

Lambda 表达式常用示例

lambda 表达式引用方法

有时候我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法。

语法

方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象

public class Exe1 { 
  public static void main(String[] args) { 
    ReturnOneParam lambda1 = a -> doubleNum(a); 
    System.out.println(lambda1.method(3));   
    //lambda2 引用了已经实现的 doubleNum 方法  
    ReturnOneParam lambda2 = Exe1::doubleNum; 
    System.out.println(lambda2.method(3));  
    Exe1 exe = new Exe1();   
    //lambda4 引用了已经实现的 addTwo 方法  
    ReturnOneParam lambda4 = exe::addTwo; 
    System.out.println(lambda4.method(2));
 }
  /**  
  * 要求 
  * 1.参数数量和类型要与接口中定义的一致  
  * 2.返回值类型要与接口中定义的一致 
  */ 
  public static int doubleNum(int a) {  
    return a * 2; 
 } 
  public int addTwo(int a) { 
    return a + 2;
 }
}

• 构造方法的引用

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

interface ItemCreatorBlankConstruct { 
  Item getItem();
}
interface ItemCreatorParamContruct { 
  Item getItem(int id, String name, double price);
}
public class Exe2 { 
  public static void main(String[] args) { 
    ItemCreatorBlankConstruct creator = () -> new Item(); 
    Item item = creator.getItem(); 
    ItemCreatorBlankConstruct creator2 = Item::new;
    Item item2 = creator2.getItem();  
    ItemCreatorParamContruct creator3 = Item::new; 
    Item item3 = creator3.getItem(112, "鼠标", 135.99); 
 }
}

lambda 表达式创建线程

我们以往都是通过创建 Thread 对象，然后通过匿名内部类重写 run() 方法，一提到匿名内部类我们就应该想到可以使用 lambda 表达式来简化线程的创建过程。

Thread t = new Thread(() -> { 
  for (int i = 0; i < 10; i++) { 
    System.out.println(2 + ":" + i); 
 }
});
t.start();

遍历集合

我们可以调用集合的 public void forEach(Consumer action) 方法，通过 lambda 表达式的方式遍历集合中的元素。以下是 Consumer 接口的方法以及遍历集合的操作。Consumer 接口是 jdk 为我们提供的一个函数式接口。

@FunctionalInterface
public interface Consumer<T> {
  void accept(T t); 
  //....
}

ArrayList<Integer> list = new ArrayList<>(); 
Collections.addAll(list, 1,2,3,4,5); 
//lambda表达式 方法引用  
list.forEach(System.out::println);  
list.forEach(element -> {    
  if (element % 2 == 0) { 
    System.out.println(element);   
 } 
});

删除集合中的某个元素

我们通过 public boolean removeIf(Predicate filter) 方法来删除集合中的某个元素，Predicate 也是 jdk 为我们提供的一个函数式接口，可以简化程序的编写。

ArrayList<Item> items = new ArrayList<>();
items.add(new Item(11, "小牙刷", 12.05 )); 
items.add(new Item(5, "日本马桶盖", 999.05 ));
items.add(new Item(7, "格力空调", 888.88 ));
items.add(new Item(17, "肥皂", 2.00 ));  
items.add(new Item(9, "冰箱", 4200.00 )); 
items.removeIf(ele -> ele.getId() == 7); 
//通过 foreach 遍历，查看是否已经删除   
items.forEach(System.out::println);

集合内元素的排序

在以前我们若要为集合内的元素排序，就必须调用 sort 方法，传入比较器匿名内部类重写 compare 方法，我们现在可以使用 lambda 表达式来简化代码。

ArrayList<Item> list = new ArrayList<>(); 
list.add(new Item(13, "背心", 7.80));   
list.add(new Item(11, "半袖", 37.80)); 
list.add(new Item(14, "风衣", 139.80));  
list.add(new Item(12, "秋裤", 55.33)); 
/* 
list.sort(new Comparator<Item>() { 
  @Override  
  public int compare(Item o1, Item o2) {  
 return o1.getId() - o2.getId(); 
  } 
});
*/    
list.sort((o1, o2) -> o1.getId() - o2.getId());  
System.out.println(list);

Lambda 表达式中的闭包问题

这个问题我们在匿名内部类中也会存在，如果我们把注释放开会报错，告诉我 num 值是 final 不能被改变。这里我们虽然没有标识 num 类型为 final，但是在编译期间虚拟机会帮我们加上 final 修饰关键字。

import java.util.function.Consumer;
public class Main { 
  public static void main(String[] args) { 
    int num = 10;  
    Consumer<String> consumer = ele -> { 
      System.out.println(num); 
   };   
    //num = num + 2;  
    consumer.accept("hello");
 }
}