[Java] Lambda表达式

定义

• 正常情况下，使用一个接口或抽象类，需要创建一个子类
• 匿名类：实例化抽象类或接口后紧跟类定义（没有名字），从而使代码更加精简
• 只有重写接口方法的一句话有用，其余的都可由编译器推断
• Lambda方法：匿名方法，即把方法作为参数进行传递
• Lambda表达式：应用在单一抽象方法接口（Single Abstract Method SAM）环境下的一种简化定义形式
• 使用Lambda表达式必须具有接口，且接口中有且只有一个抽象方法
• 使用Lambda表达式必须具有上下文推断，即方法的参数或局部变量类型必须为Lambda对应的接口类型，才可使用Lambda作为该接口的实例
• Lambda表达式的内容不要超过三行
• 有且只有一个抽象方法的接口，称为函数式接口
• 实例化函数式接口主要是为了使用方法，即接口的实例化对象是只有函数的对象，故称函数对象
• 演变过程（情景：找出满足要求的Hero）
  • 普通方法：定义判断方法，在for循环遍历中进行条件判断，筛选数据
  • 匿名类方法：定义接口，提供判断方法，通过匿名类实现，原判断方法接收判断对象和判断方法对象
  • Lambda表达式：简化匿名类的定义，只保留方法参数和方法体，中间加->
• 基本语法
  • (参数) -> {方法体}
  • 只有一个参数，可以去掉()
  • 只有一行方法，可以去掉{}　

匿名类

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
   
import charactor.Hero;
   
public class TestLambda {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
        System.out.println("使用匿名类的方式，筛选出 hp>100 && damange<50的英雄");
        HeroChecker checker = new HeroChecker() {
            @Override
            public boolean test(Hero h) {
                return (h.hp>100 && h.damage<50);
            }
        };
           
        filter(heros,checker);
    }
   
    private static void filter(List<Hero> heros,HeroChecker checker) {
        for (Hero hero : heros) {
            if(checker.test(hero))
                System.out.print(hero);
        }
    }
}

接口

package lambda;
 
import charactor.Hero;
 
public interface HeroChecker {
    public boolean test(Hero h);
}

Lambda表达式

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
 
public class TestLamdba {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
        System.out.println("使用Lamdba的方式，筛选出 hp>100 && damange<50的英雄");
        filter(heros,h->h.hp>100 && h.damage<50);
    }
 
    private static void filter(List<Hero> heros,HeroChecker checker) {
        for (Hero hero : heros) {
            if(checker.test(hero))
                System.out.print(hero);
        }
    }
 
}

方法引用

• 对象的引用传递可以实现不同的栈操作同一块堆内存空间
• 技术早期阶段，希望针对于方法可以实现引用机制，在Spring框架中有相关功能
• JDK 1.8后，方法也支持引用操作，相当于为方法定义了别名
• 不再自己覆写接口，而是引用其他类中现成的方法实现接口，可节约代码量
• 简化Lambda表达式在一些重复操作上的执行
• 需要一个函数式接口，并设置好参数
• 引用静态方法
  • 类名称 :: static 方法 ;
  • filter(heros, TestLambda::testHero);
• 引用对象方法
  • 实例化对象 :: 普通方法 ;
  • filter(heros, testLambda::testHero);
• 引用容器中的对象的方法
  • 特定类 :: 普通方法
  • filter(heros, Hero::matched);
• 引用构造器
  • 类名称 :: new
  • 接口中的方法返回一个对象：public interface Supplier<T> {T get();}
  • 设计一个方法以这个接口为参数：public static List getList(Supplier<List> s){return s.get();}
  • 调用这个方法，有三种方式
    • 匿名类：Supplier<List> s = new Supplier<List>() {public List get() {return new ArrayList();}}; List list1 = getList(s);
    • Lambda表达式：List list2 = getList(()->new ArrayList());
    • 引用构造器：List list1 = getList(ArrayList::new);

@FunctionalInterface
interface IMessage<P,R>{
    public R zhuanhuan(P p);
}

public class MethodReference_Demo {
    public static void main(String[] args) {
        IMessage<Integer,String> msg = String::valueOf;
        String str = msg.zhuanhuan(1000);
        //以上两句等价于
        //String str = String.valueOf(1000);
        System.out.println(str.replace("0", "9"));
    }
}

 内建函数式接口

• 任何语言推出了一项技术之后，都会在语言本身围绕这个技术点进行大量的结构性完善
• 函数式接口可分为四类，定义函数式接口时，直接使用内置的四种类型即可
• 功能型接口（Function<T,R>）：接收一个参数，返回一个结果
• 消费型接口（Consumer<T>）：负责接收数据，且不返回结果
• 供给型接口（Supplier<T>）：不接受参数，但可返回结果
• 断言型接口（Predicate<T>）：进行判断操作

聚合操作

• 快速的数据处理的操作，工作在类集上
• Lambda表达式、方法引用、四个函数式接口
• Collection的父接口Iterable接口中定义的方法
  • default void forEach(Consumer<? super T> action)：对Iterable的每个元素执行给定的操作
  • Consumer<? super T> action：消费型函数接口，能接收参数，但没有返回值
  • foreach()只能只能实现输出，主要使用Iterator迭代
• Stream可利用Collection接口提供的方法
  • 并行数据流计算：default Stream<E> parallelStream()
  • 数据流计算：default Stream<E> stream()
  • 性能高：流计算比Iterator迭代的性能快100倍左右
  • 语法简单
• 聚合操作遍历数据
  • List<Hero> heros = new ArrayList<Hero>();
  • heros.stream().filter(h -> h.hp > 100 && h.damage < 50).forEach(h -> System.out.println(h.name));
• Stream和管道
  • Stream是一系列元素，管道指聚合操作
• 管道源
  • List<Hero> heros.stream()
• 中间操作
  • 每个中间操作返回一个Stream，不会进行真正遍历
  • filter：匹配
  • distinct：去重
  • sorted：排序
  • sorted(Comparator<T>)：指定排序
  • limit：取出的最大数据量
  • skip：跳过多少数据量
• 结束操作
  • 不返回Stream，执行中间操作的行为
  • forEach()：遍历每个元素
  • toArray()：转换为数组
  • min(Comparator<T>)：取最小元素
  • max(Comparator<T>)：取最大元素
  • count()：总数
  • findFirst()：第一个元素

forEach()

import java.util.ArrayList;
import java.util.List;

public class Stream_Demo {
    public static void main(String[] args) throws Exception{
        List<String> all = new ArrayList<String>();
        all.add("Hello");
        all.add("World");
        all.add("Good");
        all.forEach(System.out::println);
    }
}

判断包含“j”的单词个数

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class Stream_Demo {
    public static void main(String[] args) throws Exception{
        List<String> all = new ArrayList<String>();
        Collections.addAll(all,"Java","JavaScript","Ruby","Python");
        Stream<String> stream = all.stream();
        System.out.println(stream.filter((ele)->ele.toLowerCase().contains("j")).count());
    }
}

取出包含“j”的单词

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Stream_Demo {
    public static void main(String[] args) throws Exception{
        List<String> all = new ArrayList<String>();
        Collections.addAll(all,"Java","JavaScript","Ruby","Python");
        Stream<String> stream = all.stream();
        List<String> subList = stream.filter((ele)->ele.toLowerCase().contains("j")).collect(Collectors.toList());
        System.out.println(subList);
    }
}

取出1个包含“j”的单词，跳过1个元素

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Stream_Demo {
    public static void main(String[] args) throws Exception{
        List<String> all = new ArrayList<String>();
        Collections.addAll(all,"Java","JavaScript","Ruby","Python");
        Stream<String> stream = all.stream();
        List<String> subList = stream.filter((ele)->ele.toLowerCase().contains("j")).skip(1).limit(1).collect(Collectors.toList());
        System.out.println(subList);
    }
}

 

MapReduce

• Google提出的分布式数据处理模型
  • Map：对数据进行先期处理，可能需要计算、转型等
  • Reduce：数据的统计计算，针对处理好的数据内容进行统计操作

数据分析

import java.util.ArrayList;
import java.util.DoubleSummaryStatistics;
import java.util.List;

class Order{
    private String name;
    private double price;
    private int amount;
    public Order(String name, double price, int amount) {
        this.name = name;
        this.price = price;
        this.amount = amount;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
    public int getAmount() {
        return amount;
    }    
}

public class MapReduce_Demo {
    public static void main(String[] args) throws Exception{
        List<Order> all = new ArrayList<>();
        all.add(new Order("PagePig",19.8,200));
        all.add(new Order("BigPig",0.8,100));
        all.add(new Order("WaWaPig",32000,10));
        all.add(new Order("Java",100,200));
        DoubleSummaryStatistics statistics = all.stream().filter((ele)->ele.getName().contains("Pig")).mapToDouble((orderObject)->orderObject.getPrice()*orderObject.getAmount()).summaryStatistics();
        System.out.println("购买数量 "+statistics.getCount());
        System.out.println("总花销 "+statistics.getSum());
        System.out.println("最高价格 "+statistics.getMax());
        System.out.println("最低价格 "+statistics.getMin());
        System.out.println("平均价格 "+statistics.getAverage());
    }
}