JDK与Java8
# 讲⼀下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");
}
}