初识java8 lambda表达式(二)

1.常用的内置函数式接口

Predicate接口：输入一个参数，并返回一个Boolean值，其中内置很多用于逻辑判断的默认方法。

@Test
public void predicateTest(){
    Predicate<String> predicate=s->s.length()>0;
    boolean test=predicate.test("");
    System.out.println(test);
    Predicate<Object> pre= Objects::nonNull;
    System.out.println(pre.test(null));
}

//结果如下

false
false

Function接口：输入一个参数，返回单一结果，默认的方法（andThen）可将多个函数串在一起，形成复合Function(有输入，有输出)。

@Test
public void functionTest(){
    Function<String,Integer> toInteger=Integer::valueOf;
    Function<String,String> backToString=toInteger.andThen(String::valueOf);
    //System.out.println(toInteger.apply("123"));
    //System.out.println(backToString.apply("23"));
    Function<Integer,Integer> first=i->{
      System.out.println("first:"+i);
      return i*2;
    };
    Function<Integer,Integer> second=first.andThen(i->{
        System.out.println("second:"+i);
        return i*0;
    });
    System.out.println(second.apply(1));
}

//结果如下

first:1
second:2
0

Suppliet接口：返回一个给定类型的结果，无参数，有输出。

@Test
public void supplierTest(){
    Supplier<String> supplier=()->"this is test";
    System.out.println(supplier.get());
}

//输出结果如下

this is test

Consumer接口：对单一的输入参数上进行操作，没有返回结，有参数，无输出。

@Test
public void consumerTest(){
    Consumer<Integer> consumer=(s)->{
        System.out.println(s);
        s+=5;
        System.out.println(s);
    };
    consumer.accept(5);
}

//结果如下

5
10

2.Stream

Stream是java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用StreamAPI对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用StreamAPI来并行执行操作。提供了一种高效且易于使用的处理数据的方式。

注意：

1.Stream自己不会存储元素。

2.Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。

3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才去执行。

Stream操作的三个步骤：1.创建，2.通过中间操作，对原始Stream进行“变化”并生成新的Stream，3完成操作。

过滤器（filter）

@Test
public void streamTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    //list.stream().forEach(System.out::println);
    //list.stream().filter((s->s.startsWith("a"))).forEach(System.out::println);
    //Stream<String> a=list.stream().filter(s->s.startsWith("a"));
    //a.filter(s->s.startsWith("1")).forEach(System.out::println);
    Predicate<String> predicate = (s) -> s.startsWith("a");
    list.stream().filter(predicate).filter(s->s.endsWith("1")).forEach(System.out::println);

}

//结果如下：a1

排序（sorted）

@Test
public void sortedTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    //list.stream().filter(s->s.startsWith("a")).sorted().forEach(System.out::println);
    //list.stream().sorted().filter(s->s.startsWith("a")).forEach(System.out::println);

    list.stream().sorted((p1,p2)->p2.compareTo(p1)).filter(s->s.startsWith("a")).forEach(System.out::println);
}

//结果如下：

a3
a2
a1b
a1

映射（Map）

接收lambda，将元素转换成其他形式或提取信息，接收一个函数作为参数，该函数被作用于每个元素上，并映射形成一个新的元素。

@Test
public void mapTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    //list.stream().map(String::toUpperCase).filter(s->s.startsWith("B")).sorted((a,b)->b.compareTo(a)).forEach(System.out::println);

    Function<String,String> function=(p)->{
        return p+32;
    };
    //list.stream().map(function).forEach(System.out::println);
    //list.stream().forEach(System.out::println);
    //list.stream().forEach(s->{System.out.println(s.toUpperCase());});
    list.stream().map(String::toUpperCase).forEach(System.out::println);
}

//结果

A1B
B3
C2
A3
A2
B2
A1

以上都是三种常用的操作，下面介绍完结方法

匹配（Match）

用于判断某个predicate是否和流对象相匹配，最终返回Boolean类型结果

@Test
public void Match(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
   //匹配集合中是否含有该元素
    boolean bo=list.stream().anyMatch(s->s.startsWith("a"));
    System.out.println(bo);
    //匹配所有元素是否都含有该元素
    boolean b=list.stream().allMatch(s->s.startsWith("a"));
    System.out.println(b);
}

//结果

true
false

收集（Collect）

在对经过变换之后，将变换的Stream的元素收集，比如将这些元素存储至集合中，使用Stream的collect方法

@Test
public void collectTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    List<String> lists=  list.stream().filter(s->s.startsWith("a")).sorted((a,b)->b.compareTo(a)).collect(Collectors.toList());
    lists.forEach(System.out::println);
}

结果：

a3
a2
a1b
a1

计数（Count）

统计流元素的总数

@Test
public  void countTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    Long num =list.stream().filter(s->s.startsWith("b")).count();
    System.out.println(num);
}

结果：

2

规约（Reduce）

reduce方法允许我们用自己的方式去计算元素或者一个Stream中的元素以某种规律关联，例如

@Test
public void reduceTest(){
    List<String> list= Arrays.asList("a1b","b3","c2","a3","a2","b2","a1");
    Optional<String> optional=list.stream().filter(s->s.startsWith("a")).reduce((a, b)->{
        System.out.println(a+"|"+b);
        return a+"|"+b;
    });
}

结果:

a1b|a3
a1b|a3|a2
a1b|a3|a2|a1