一、lambda表达式
1、lambda定义
Lambda表达式需要函数式接口的支持,格式:()→ {}
常见格式
格式1:无参无返回值
//使用Lambda替代runnable接口中无参无返回的run方法
@Test
public void demoOne(){
Runnable r =()->System.out.println("==========");
r.run();
}
格式2:一参无返回值
//使用Lambda替代Consumer接口中有一个参数无返回值的accept方法
@Test
public void demoOne() {
Consumer<String> c = (e) -> System.out.println(e);
c.accept("============");
}
当然对已一个参数的情况,箭头操作符右边的括号可以省略,等价的代码
@Test
public void demoOne() {
Consumer<String> c = e -> System.out.println(e);
c.accept("============");
}
格式3:多个参数有返回值
//使用Lambda替代比较器接口有两个参数并且返回值的
@Test
public void demoOne() {
Comparator<Integer> comparator = (x,y)->{
return Integer.compare(x, y);
};
}
当然当Lambda体只有一条语句,可以省略右边的大括号以及return,等级代码
@Test
public void demoOne() {
Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
}
格式4:多个参数有返回值,并且Lambda体多条语句
@Test
public void demoOne() {
Comparator<Integer> comparator = (x, y) -> {
System.out.println("=============");
return Integer.compare(x, y);
};
}
格式5:参数列表的数据类型可写可不写。Lambda会通过上下文进行类型推断,建议没必要写
@Test
public void demoOne() {
Comparator<Integer> comparator = (Integer x, Integer y) -> {
System.out.println("=============");
return Integer.compare(x, y);
};
}
2、lambda改写函数式接口三种使用场景
2.1、作为参数传递 Lambda 表达式
foreach语法就是函数式接口作为参数
2.2、函数式接口作为方法返回值
public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<>();
array.add("a");
array.add("ccccc");
array.add("bb");
array.add("ddd");
System.out.println("排序前" + array);
Collections.sort(array, getComparator());
System.out.println("排序后" + array);
}
private static Comparator<String> getComparator() {
/* 使用匿名内部类
Comparator<String> comp = new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length()-s2.length();
}
};
return comp;
*/
//使用lambda表达式
return (s1, s2) -> s1.length() - s2.length();
}
}
2.3、函数式接口作为匿名内部类
Runnable r = ()->{System.out.println("My Runnable")};
二、Java中双冒号(::)运算操作符
1、定义
双冒号运算操作符是类方法的句柄,lambda表达式的一种简写,这种简写的学名叫eta-conversion或者叫η-conversion。
英文格式双冒号::,读:double colon,双冒号(::)运算符在Java 8中被用作方法引用(method reference),方法引用是与lambda表达式相关的一个重要特性。它提供了一种执行方法的方法,为此,方法引用需要由兼容的函数式接口组成的目标类型上下文。
使用lambda表达式会创建匿名函数, 但有时候需要使用一个lambda表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!
2、使用场景
2.1、引用静态方法
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
public class Colon{
@Test
public void test(){
List<String> list = Arrays.asList("a","b","c");
//静态方法引用 ClassName::methodName
list.forEach(Colon::print);
//上一行等价于
//list.forEach((x)->Colon.print(x));
}
//静态方法
public static void print(String s){
System.out.println(s);
}
}
2.2、引用特定对象实例方法
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
public class Colon{
@Test
public void test(){
List<String> list = Arrays.asList("a","b","c");
//实例方法引用 instanceRef::methodName
list.forEach(new Colon()::print);
//上一行等价于
//list.forEach((x)->new Colon().print(x));
}
//实例方法
public void print(String s){
System.out.println(s);
}
}
2.3、引用特定类型的任意对象的实例方法
import org.junit.Test;
import java.util.Arrays;
public class Colon{
@Test
public void test(){
String[] arr = { "Barbara", "James", "Mary", "John",
"Patricia", "Robert", "Michael", "Linda" };
//引用String类型的任意对象的compareToIgnoreCase方法实现忽略大小写排序
Arrays.sort(arr, String::compareToIgnoreCase);
//上一行等价于
//Arrays.sort(arr, (a,b)->a.compareToIgnoreCase(b));
//输出
for(String s:arr){
System.out.println(s);
}
}
}
2.4、引用超类(父类)实例方法
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
public class Colon extends BaseColon{
@Test
public void test(){
List<String> list = Arrays.asList("a","b","c");
//实例方法引用 instanceRef::methodName
list.forEach(super::print);
}
}
class BaseColon{
//实例方法
public void print(String s){
System.out.println(s);
}
}
2.5、引用类构造方法
一般我们需要声明接口,该接口作为对象的生成器,通过 类名::new 的方式来实例化对象,然后调用方法返回对象。
//注意:该类无需实现接口
public class Colon{
private String name;
private int age;
//无参构造
public Colon() {
}
//有参构造
public Colon(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
//无参构造引用
ColonNoParam cnp = Colon::new;
Colon c1 = cnp.createColon();
System.out.println(c1);
//有参构造引用
ColonWithParam cwp = Colon::new;
Colon c2 = cwp.createColon("小明",20);
System.out.println(c2);
}
//生成toString方法打印查看
@Override
public String toString() {
return "Colon{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
interface ColonNoParam{
//无参方法提供对象
Colon createColon();
}
interface ColonWithParam{
//有参方法提供对象(数据类型要与Colon有参构造函数对应)
Colon createColon(String s,int i);
}
2.6、引用数组构造方法
我们可以借助jdk自带的java.util.function.Function类实现对数组构造函数的引用。
import java.util.function.Function;
public class Colon{
public static void main(String[] args) {
Function<Integer,Colon[]> function = Colon[]::new;
//调用apply方法创建数组,这里的5是数组的长度
Colon[] arr = function.apply(5);
//循环输出-初始都为null
for(Colon c:arr){
System.out.println(c);
}
}
}