Jdk8 中的“lambda”表达式

lambda表达式

lambda的优化

JDK8中可以使用以下简略写法

new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程
Arrays.sort(array,(a,b)->a.getAge()-b.getAge())    //排序

Lambda的格式

标准格式:
(参数类型 参数名称) -> { 代码语句 }

省略格式:
(a,b)->{代码}

Lambda的前提条件

• 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。如Runnable和Comparator //函数式接口
• 使用Lambda必须具有接口作为方法参数。

函数式接口

定义

函数式接口：有且仅有一个抽象方法的接口。

格式

修饰符 interface 接口名称 {
     public abstract 返回值类型 方法名称(可选参数信息); // 其他非抽象方法内容 
}

自定义函数式接口

@FunctionalInterface    //可写可不写,类似于@Override
public interface MyFunctionalInterface { void myMethod(); } //定义一个接口

public class Demo07FunctionalInterface { // 使用自定义的函数式接口作为方法参数 
    private static void doSomething(MyFunctionalInterface inter) {         
        inter.myMethod(); // 调用自定义的函数式接口方法 
    }
    
    public static void main(String[] args) { // 调用使用函数式接口的方法 
        doSomething(() -> System.out.println("Lambda执行啦！")); 
    } 
}

常用函数式接口

Consumer接口

Consumer<T>接口是消费一个数据,抽象方法accept,基本使用如下:

//给你一个字符串,请按照大写的方式进行消费 
import java.util.function.Consumer; 
public class Demo08Consumer {
     public static void main(String[] args) {
          String str = "Hello World"; 
          //1.lambda表达式标准格式 
          fun(str,(String s)->{ System.out.println(s.toUpperCase());});             
          //2.lambda表达式简化格式
          fun(str,s-> System.out.println(s.toUpperCase())); 
     }
          /* 定义方法,使用Consumer接口作为参数 fun方法: 
          消费一个String类型的变量 */ 
     public static void fun(String s,Consumer<String> con) {
        con.accept(s); 
     } 
}

Predicate接口

Predicate<T>是接收一个数据,得到boolean结果,抽象方法test

//1.练习:判断字符串长度是否大于5 
//2.练习:判断字符串是否包含"H" 
public class Demo09Predicate {
     private static void method(Predicate<String> predicate,String str) {
         boolean veryLong = predicate.test(str);
         System.out.println("字符串很长吗：" + veryLong); 
     }
     
     public static void main(String[] args) {
         method(s -> s.length() > 5, "HelloWorld"); 
     } 
}

Stream流

Stream更优雅更简单,如下

list.stream() 
    .filter(s -> s.startsWith("张")) 
    .filter(s -> s.length() == 3) 
    .forEach(s -> System.out.println(s));

Stream类似流水线,我们首先要拼好一个模型步骤方案,再去执行它

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

获取流的方式

• 方式一:根据Collection获取流

import java.util.*; 
import java.util.stream.Stream; 
/* 
    获取Stream流的方式 
    1.Collection中 方法 Stream stream() 
    2.Stream接口 中静态方法 
        of(T...t) 向Stream中添加多个数据 
    */ 
    public class Demo13GetStream { 
        public static void main(String[] args) {
            List<String> list = new ArrayList<>(); 
            Stream<String> stream1 = list.stream(); 
            Set<String> set = new HashSet<>(); 
            Stream<String> stream2 = set.stream(); 
         } 
     }

• 方式二:根据数组获取流

import java.util.stream.Stream; 
public class Demo14GetStream { 
    public static void main(String[] args) { 
        String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };         
        Stream<String> stream = Stream.of(array); 
    } 
}

常用方法

最后，希望这篇文章能够带给你帮助

喜欢的话也记得可以点个关注哦~

我是小架，我们下篇文章见！