Java8新特性

1、Lambda表达式

1.1、Lambda表达式简介

        Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样传递）可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java 的语言表达能力得到提升

1.2、Lambda基础语法

        Java8 中引入了一个新的操作符“->”，该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分：

• 左侧：Lambda 的参数列表
• 右侧：Lambda 表达式中所需要执行的功能，即 Lambda 体

语法格式一：无参数，无返回值

@Test
public void test1(){
	// 原来的代码
	Runnable r = new Runnable(){
		@Override
		public void run(){
			System.out.println("Hello World");
		}
	};
	r.run();
	// 使用Lambda
	Runnable r1 = () -> System.out.println("Hello Lambda");
	r1.run();
}

语法格式二：有一个参数，并且无返回值

@Test
public void test2(){
	Consumer<String> con = (x) -> System.out.println(x);
	con.accept("Hello Lambda");
}

语法格式三：若只有一个参数，小括号可以省略不写

@Test
public void test2(){
	Consumer<String> con = x -> System.out.println(x);
	con.accept("Hello Lambda");
}

语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

@Test
public void test3(){
	Comparator<Integer> com = (x, y) -> {
		System.out.println("函数式接口");
		return Integer.compare(x, y);
	}
}

语法格式五：若 Lambda 体中只有一条语句，return 和大括号都可以不写

@Test
public void test4(){
	Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
}

2、函数式接口

2.1、函数式接口简介

Lambda 表达式需要函数式接口的支持
函数式接口：接口中只有一个接口，可以使用注解 @FunctionInterface 修饰，可以检查是否是函数式接口

2.2、四大内置核心函数式接口

• Consumer：消费型接口 – void accept(T t)；

// Consumer 消费性接口
@Test
public void test1(){
	happy(1000, (m) -> System.out.println("每次消费" + m + "元"));
}
public void happy(double money, Consumer<Double> con){
	con.accept(money);
}

• Supplier：供给型接口 – T get()；

// Supplier：供给型接口
// 需求：产生指定个数的整数，并放入集合中
@Test
public void test2(){
	List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
	for(Integer num : numList){
		System.out.println(num);
	}
}
public List<Integer> getNumList(int num,Supplier<Integer> sup){
	List<Integer> list = new ArrayList<>();
	for (int i = 0; i < num; i++){
		Integer n = sup.get();
		list.add(n);
	}
	return list;
}

• Function：函数型接口 – R apply(T t)；

// Function：函数型接口
// 需求：用于处理字符串
public void test3(){
	String newStr = strHandler(" Hello Lambda", (str) -> str.trim());
	System.out.println(newStr);
}
public String strHandler(String str, Function<String, String> fun){
	return fun.apply(str);
}

• Predicate：断言型接口 – boolean test(T t)；

// Predicate：断言型接口
// 需求：将满足条件的字符串放入集合中
@Test
public void test4(){
	List<String> list = Arrays.asList("Hello", "World", "hh");
	List<String> strList = filterStr(list, (s) -> s.length() > 3);
	for (String str : strList ){
		System.out.println(str);
	}
}
public List<String> filterStr(List<String> list, Predicate<String> pre){
	List<String> strList = new ArrayList<>();
	for (String str : list){
		if (pre.test(str)){
			strList.add(str);
		}
	}
}

3、方法引用与构造器引用

方法引用：若 Lambda 体中的内容有方法已经实现，我们可以使用"方法引用"（可以理解为方法引用是 Lambda 表达式的另外一种表现形式）
主要有三种语法形式：

• 对象::实例方法名

@Test
public void test1(){
	Consumer<String> con = (x) -> System.out.println(x);
	// 写法1
	PrintStream ps = System.out;
	Consumer<String> con1 = ps::println;
    // 写法2
	Consumer<String> con1 = System.out::println;
}
@Test2
public void test2{
	Employee emp = new Employee();
	// 原来
	Supplier<String> sup = () -> emp.getName();
	String str = sup.get();
	System.out.println(str);
	// 现在
	Supplier<Integer> sup2 = emp::getAge;
	Integer num = sup2.get();
	System.out.println(num);
}

• 类::静态方法名

@Test
public void test3(){
    // 原来
	Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
	// 使用方法引用
	Comparator<Integer> com1 = Integer::compare;
}

• 类::实例方法名

@Test
public void test4(){
	// 原来
	BitPredicate<String, String> bp = (x, y) -> x.equals(y);
	// 使用方法引用
	BitPredicate<String, String> bp1 = String::equals;
}

注意：

1. Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中的抽象方法的函数列表和返回值类型保持一致
2. 若 Lambda 参数列表中的第一个参数是实例方法的调用这，第二个参数是实例方法的参数时，可以使用 ClassName::method

4、Stream API

5、接口中的默认方法与静态方法

6、新时间日期API

7、其他新特性

转载请标明出处，原文地址：https://dragon.blog.csdn.net 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。