Java 8 新特性(一) - Lambada表达式

---

Java 8 新特性(一) - Lambada表达式

---

Lambda表达式简介

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

Lambda基础语法

Java 1.8 中引入了一个新的操作符 -> ,称为箭头操作符或者Lambda操作符,该操作符将Lambda表达式拆分成两部分:

左侧: Lambda 表达式的参数列表,对应的就是接口的参数列表

右侧: Lambda 表达式中所需要执行的功能,即Lambda体,是对接口方法实现的功能

函数式接口

概念 一个接口中只有一个抽象方法,可以使用@FunctionalInterface注解修饰(检查是否是函数式接口)

Lambda表达式需要函数式接口的支持

Lambda的几种变化形式

注意 Lambda表达的参数列表的数据类型可以不写,因为JVM编译器会通过上下文推断出数据类型,即便是类型不一样的几个参数,在使用Lambda表达式的时候,保持类型和接口中定义的类型顺序一致就可以

• 无参数,无返回值

() -> 接口实现的功能

举例

@Test
public void test1() {
    //以Runnable为例,以前创建Runnable对象需要在局部内部类中重写接口方法
    Runnable r1= new Runnable() {
        @Override
        public void run() {
            System.out.println("test1");
        }
    };
    r1.run();
    
	//使用Lambda表达式
    Runnable r2 = () -> System.out.println("test2");
    r2.run();
}

• 有一个参数,无返回值,方法体只有一条语句

(参数名x) -> 方法体  //参数名可以自定义

只有一个参数,可以直接省略小括号

参数名x -> 方法体

举例

@Test
public void test2() {
    Consumer<String> consumer = (x) -> System.out.println(x);
    /*
    可以不写小括号
    Consumer<String> consumer = x -> System.out.println(x);
    */
    consumer.accept("test2");
}

• 有2个以上的参数,有返回值,并且Lambda体中有多条语句

(参数名x,参数名y,...) -> {
    多条语句的方法体;
    return语句;
}

举例

@Test
public void test3() {
    Comparator<Integer> comparator=(x,y) ->{
        System.out.println("test3.1");
        return Integer.compare(x, y);
    };

}

• 有2个以上的参数,有返回值,并且Lambda体中只有一条语句

return和大括号都可一省略不写

(参数名x,参数名y,...) -> 方法体;

举例

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

Lambda表达式举例

• 整数运算器

1. 先创建一个函数式接口

@FunctionalInterface
interface operation{
    public Integer operate(Integer i);
}

1. 测试,计算一个数的乘方

//首先定义一个方法
public Integer operation(Integer num, Operation operation) {
    return operation.operate(num);
}

//测试函数
@Test
public void operationTest() {
    Integer num = operation(100, (x) -> x * x);
    System.out.println(num);
}

• 大小写转换器

将输入的小写字符串转换成大写

1. 定义一个函数式接口

@FunctionalInterface
interface IStrHandler{
    public String toUpper(String str);
}

2.定义传参方法并测试

//定义一个方法用于传参
public String strHandler(String str, IStrHandler iStrHandler) {
    return iStrHandler.toUpper(str);
}

//测试
@Test
public void strHandlerTest() {
    String upper = strHandler("abcdefg", (str) -> str.toUpperCase());
    System.out.println(upper);
}

Java常用的内置函数式接口

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象进行操作,包含方法 void accept(T t)
Supplier 供给型接口	无	T	返回类型为T的对象,包含方法T get()
Function<T,R> 函数型接口	T	R	对类型为T的对象进行操作,并返回结果,结果是R类型的对象,包含方法R apply(T t)
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束,并返回boolean值,包含方法boolean test(T t)

• Consumer 消费型接口

说明 该接口只有一个没有返回值的方法

举例 打印消费的金额

//定义一个传参的方法
public void consume(double money, Consumer<Double> consumer) {
    consumer.accept(money);
}

//测试方法
@Test
public void consumerTest() {
    consume(1000,(m) -> System.out.println("消费了"+m+"元!"));
}

• Supplier 供给型接口

说明 该接口定义的方法返回一个与操作对象的类型一致的返回值

举例 产生指定个数的整数,并放入集合中

//定义一个方法,每次都从Supplier.get()中返回一个数,并添加到List中
public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        Integer n = supplier.get();
        list.add(n);
    }
    return list;
}

//测试
@Test
public void supplierTest() {
    List<Integer> numList=getNumList(10, () -> (int)(Math.random() * 100));
    System.out.println(numList);
}

• Function<T,R> 函数型接口

说明 该接口定义的方法返回一个与操作对象的类型不一致的返回值

举例 返回字符串的长度

//定义一个方法,返回字符串的长度
public Integer strHandler(String str, Function<String,Integer> function) {
    return function.apply(str);
}

//测试
@Test
public void strHandlerTest() {
    int len=strHandler("abcdefg", (str) -> str.length());
    System.out.println(len);
}

• Predicate 断定型接口

说明 判断用,返回boolean值

举例 将满足条件的字符串放入集合中

//定义一个方法,过滤满足一定条件的字符串
public List<String> filterStr(List<String> list, Predicate<String> predicate) {
    List<String> stringList = new ArrayList<>();
    for (String str : list) {
        if (predicate.test(str)) {
            stringList.add(str);
        }
    }
    return stringList;
}

//测试,过滤出长度>5的字符串
@Test
public void predicateTest() {
    List<String> list= Arrays.asList("abc","abcdefg","higklm","opqrstu","vwxyz");
    List<String> filterList = filterStr(list, (str) -> str.length() > 5);
    System.out.println(filterList);
}