Lambda

案例1

lambda替换匿名类

// Java 8之前：
new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Before Java8, too much code for too little to do");
    }
}).start();

//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

案例2

lambda对list进行迭代

// Java 8之前：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
for (String feature : features) {
    System.out.println(feature);
}

// Java 8之后：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
features.forEach(n -> System.out.println(n));
 
// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
// 看起来像C++的作用域解析运算符
features.forEach(System.out::println);

案例3

lambda表达式内可以使用方法引用，仅当该方法不修改lambda表达式提供的参数。本例中的lambda表达式可以换为方法引用，因为这仅是一个参数相同的简单方法调用。

list.forEach(n -> System.out.println(n)); 
list.forEach(System.out::println);  // 使用方法引用

案例4

stream的filter

// 创建一个字符串列表，每个字符串长度大于2
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

案例5

stream的map，对列表的每个元素应用函数

// 将字符串换成大写并用逗号链接起来
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
System.out.println(G7Countries);

Stream

中间操作符

1. map(mapToInt,mapToLong,mapToDouble) 转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。
2. flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平 变成 2，3，4 也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。
3. limit 限流操作，比如数据流中有10个 我只要出前3个就可以使用。
4. distint 去重操作，对重复元素去重，底层使用了equals方法。
5. filter 过滤操作，把不想要的数据过滤。
6. peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。
7. skip 跳过操作，跳过某些元素。
8. sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

终止操作符

1. collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。
2. count 统计操作，统计最终的数据个数。
3. findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。
4. noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素 返回值为bool 值。
5. min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。
6. reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce
7. forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。
8. toArray 数组操作，将数据流的元素转换成数组。

public class TestStream {
    List<String> stringList = ImmutableList.of("Paul","Dean","Lily","Hanny","Danel","Zoo","YoYo","Lina","T");

    @Test
    public void mapTest(){
        stringList.stream().filter(a -> a.length() > 4)//过滤字符串长度超过4的iterm
                .map(String::toUpperCase) //对过滤出的字符串进行大写
                .forEach(System.out::println); //遍历打印
    }


}

结果：
HANNY
DANEL

@Test
    public void flatMapTest(){
        Stream.of("a-b-c-d","e-f-i-g-h")
                .flatMap(e->Stream.of(e.split("-"))) //重组stream
                .forEach(System.out::println);
    }

@Test
    public void limitTest(){
        Stream.of(1,2,3,4,5,6)
                .limit(3) //限制三个
                .forEach(e->System.out.println(e)); //将输出 前三个 1，2，3
    }

 @Test
    public void distinctTest(){
        Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)
                .distinct() //去重
                .forEach(e->System.out.println(e));
    }

@Test
    public void peekTest(){
        Stream.of(new StudentDTO(1,"Paul",22,true),
                new StudentDTO(2,"Dean",33,false),
                new StudentDTO(3,"Lily",25,false))
                //对对象进行提前消费
                .peek(s -> s.setName(s.getName().concat("_").concat(s.getId().toString())))
                .forEach(System.out::println);
    }

@Test
    public void skipTest(){
        stringList.stream()
                .skip(3) //跳过前3个数据
                .forEach(System.out::println);
    }

@Test
    public void sortIntDefaultTest(){
        Stream.of(2,1,3,6,4,9,6,8,0)
                .sorted()
                .forEach(e->System.out.println(e));
    }

    @Test
    public void sortCustomTest(){
        Stream.of(new StudentDTO(1,"Paul",22,true),
                new StudentDTO(2,"Dean",33,false),
                new StudentDTO(3,"Lily",25,false))
                .sorted((e1,e2)->e1.getAge() >= e2.getAge() ? 1 : -1)
                .forEach(System.out::println);
    }

@Test
    public void collectTest(){
        List<String> result = stringList.stream()
                .filter(e -> e.length() > 2)
                .collect(Collectors.toList());
        result.forEach(System.out::println);
    }

@Test
    public void reduceTest(){
        int sum = Stream.of(0,9,8,4,5,6,-1)
                //reduce 是一个规约操作，所有的元素归约成一个，比如对所有元素求和，乘啊等
                .reduce(0,(e1,e2)->e1+e2);
        System.out.println(sum);
    }

@Test
    public void forEachOrderedTest(){
        Stream.of(0,2,6,5,4,9,8,-1)
                .parallel()
                //适用用于并行流的情况下进行迭代，能保证迭代的有序性
                .forEachOrdered(e->{
                    System.out.println(Thread.currentThread().getName()+": "+e);});
    }

ForkJoinPool.commonPool-worker-3: 2
ForkJoinPool.commonPool-worker-3: 6
ForkJoinPool.commonPool-worker-3: 5
ForkJoinPool.commonPool-worker-3: 4
ForkJoinPool.commonPool-worker-3: 9
ForkJoinPool.commonPool-worker-3: 8
ForkJoinPool.commonPool-worker-3: -1