Java8【有与无】【F1】Lambda表达式（高效的并行操作）

1.背景

语言层面上，让代码在多核 CPU 上高效处理批量数据的并行类库。

2.定义

函数式编程：使用不可变值和函数，函数对一个值进行处理，映射成另一个值。它是对行为进行抽象，相对于面向对象的编程方式，它具有更高的性能/效率，线程更安全。

Lambda表达式： 一种紧凑的、传递行为的方式，高效并行，简化开发

Lambda表达式能够方便、快捷地创建出这种函数式接口的实例

操作符  参数 -> 要执行的代码

 

2.1.函数式接口说明【知道的可以忽略】

函数式接口： 只能含有一个抽象方法的接口，也称为SAM接口，即Single Abstract Method interfaces。

主要用在Lambda表达式和方法引用

//该注解为函数式接口
//该注解用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错
@FunctionalInterface
public interface Runnable

//定义了一个函数式接口
@FunctionalInterface
interface GreetingService 
{
   void sayMessage(String message);
}


//使用Lambda表达式来表示该接口的一个实现,类似于匿名类的实现
GreetingService greetService1 = 
      message -> System.out.println("Hello " + message);

//函数式接口里可以包含默认方法
//因为默认方法不是抽象方法，其有一个默认实现，所以是符合函数式接口的定义的
//编译器不会报错
@FunctionalInterface
interface GreetingService
{
   void sayMessage(String message);

   default void doSomeMoreWork1()
   {
      // Method body
   }

   default void doSomeMoreWork2()
   {
      // Method body
   }
}

 

//函数式接口里是可以包含静态方法
//因为静态方法不能是抽象方法，是一个已经实现了的方法，所以是符合函数式接口的定义的
@FunctionalInterface
interface GreetingService 
{
   void sayMessage(String message);
   static void printHello()
   {
       System.out.println("Hello");
   }
}

//函数式接口里是可以包含Object里的public方法
//这些方法对于函数式接口来说，不被当成是抽象方法（虽然它们是抽象方法）
//因为任何一个函数式接口的实现，默认都继承Object类，包含来自java.lang.Object里对这些抽象方法的实现
@FunctionalInterface
interface GreetingService  
{
   void sayMessage(String message);
        
   @Override
   boolean equals(Object obj);
}

 

//JDK中的函数式接口举例
java.lang.Runnable,
java.awt.event.ActionListener, 
java.util.Comparator,
java.util.concurrent.Callable
java.util.function包下的接口，如Consumer、Predicate、Supplier等

3.使用方式

• 无参数，无返回值
• 有一个参数，并且无返回值
• 有一个参数，并且有返回值
• 多个参数的情况

//无参数，无返回值
Runnable r = () -> System.out.println("Thread start...");
new Thread(r).start();

//有一个参数，并且无返回值
//accept：接收参数
Consumer<Integer> consumer = (x) -> System.out.println(x);
// 等价 Consumer<Integer> consumer = x -> System.out.println(x);
consumer.accept(6);

//有一个参数，并且有返回值
//function<T, R> T 入参  R  出参
Function<String, Integer> f = s -> {
    int result = Integer.parseInt(s);
    return result;
};
// 等价 Function<String, Integer> f = s -> Integer.parseInt(s);
Integer num = f.apply("1111");

//多参数
//BiFunction<T, U, R> T, U 入参  R 出参
BiFunction<Integer, Integer, String> b = (x,y) -> x+y+"";//类型推断
// 等价 BiFunction<Integer, Integer, String> b = (Integer x, Integer y) -> x+y+"";
String str = b.apply(1, 2);

/** 对比 **/
/** 遍历Map **/
Map<String, Integer> items = new HashMap<>();
for (Map.Entry<String, Integer> entry : items.entrySet()) {
    System.out.println("Item : " + entry.getKey() + " Count : " + entry.getValue());
}


// 等价

items.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));
// 或
items.forEach((k,v)->{
    System.out.println("Item : " + k + " Count : " + v);
    if("E".equals(k)){
        System.out.println("Hello E");
    }
});

/** 遍历List **/
List<String> items = new ArrayList<>();
for(String item : items){
    System.out.println(item);
}


// 等价

items.forEach(item->System.out.println(item));
// 或
items.forEach(item->{
    if("C".equals(item)){
        System.out.println(item);
    }
});