Stream API

• 筛选：filter（Class:isXXX()）
• 排序

//按年龄升序
.sorted(Comparator.comparing(Student::getAge))
//按年龄降序
.sorted(Comparator.comparing(Student::getAge).reversed())

public void sortUserInfoList(List<UserInfo> userInfoList){
       userInfoList.sort((user1, user2) -> {
           Long userId1 = user1.getUserId();
           Long userId2 = user2.getUserId();
           return userId1.compareTo(userId2);
       });
 }

• 消重：distinct（）
• 截短：limit（2）
• 跳过：skip（2）
• 映射：map(Class:getXXX())--eg. map(String:length)

word = ["Hello","World"]
map(word->word.split("")) ~~~~~{[H,e,l,l,o],[W,o,r,l,d]} 
//降维扁平化
flatMap(word->word.split(""))~~~~~{H,e,l,l,o,W,o,r,l,d} 

• 收集元素：collect()

//集合转list
.collect(Collectors.toList())
//集合转set
.collect(Collectors.toSet())
//集合转map
.collect(Collectors.toMap(a->a,b->b))

• 至少一个匹配：anyMatch(Class:isXXX())
• 所有全部匹配：allMatch(Class:isXXX())
• 没有任何匹配：noneMatch(Class:isXXX())

//没有值相等时返回true
boolean cc = strs.stream().noneMatch(str -> str.equals("a"));

• 返回任意元素：findAny()
• 返回第一元素：findFirst()

IntStream | DoubleStream | LongStream：数值流

• 产生一个数值流

//构建IntStream,使用builder并单个添加元素
  IntStream intStream = IntStream.builder().add(1).build();

//无限流 和limit连用
  intStream = IntStream.generate(()-> (int) (Math.random()*10000));
  intStream = intStream.limit(5);

//迭代无限流 和limit连用
  intStream = IntStream.iterate(2,n->n*3);
  intStream = intStream.limit(5);

//of方法把一组值变成流
  intStream = IntStream.of(1,2,3);

//两个数之间的整数流 左闭右开
  intStream = IntStream.range(1,5);

//两个数之间的整数流 全闭 跳过前2个
  intStream = IntStream.rangeClosed(1,5).skip(2);

//将两个流合并为一个
  IntStream otherIntStream = IntStream.of(1,2,3);
  intStream = IntStream.concat(intStream,otherIntStream);

• 遍历

//循环遍历
intStream.forEach(System.out::println);

//升序遍历
intStream.sorted().forEach(System.out::println);

//降序 先要用boxed方法转成包装类型
intStream.boxed().sorted(Comparator.reverseOrder()).forEach(System.out::println);

//peek操作流返回值仍为IntStream,只有关闭流时才会执行
System.out.println(intStream.peek(System.out::println).sum());

• 转化

//流转数组
int[] array = intStream.toArray();
System.out.println(array);

//转double流,long流同理
DoubleStream doubleStream = intStream.asDoubleStream();
doubleStream.forEach(System.out::println);

//映射为double流
DoubleStream doubleStream =intStream.mapToDouble(i->i);
doubleStream.forEach(System.out::println);

• 计算

//计数
long count = intStream.count();
System.out.println(count);

//求和
int sum = intStream.sum();
System.out.println(sum);

//规约
int reduce = intStream.reduce(0,(a,b)->a+b);
System.out.println(reduce);

并行流

• 流的顺序化和并行化:sequential()/parallel()，同时出现多种时以最后一次为准

//iterator得到的流串行效率高
LongStream.iterate(1L,i -> i+1).limit(10000000L).parallel().reduce(0L,Long:sum)

//range得到得流并行效率高
LongStream.range(0L, 100000000L).parallel().reduce(0L,Long::sum);

lambda

• 作用：简化匿名类。
• 举例：

//实现Runnable接口
new Thread(()-> System.out.println("hello,world!")).start();

//实现Comparator接口
Collections.sort(list,(a,b)->a.charAt(0)>b.charAt(0)?1:-1);

• 常用的接口：

//Predicate<T>，对参数进行预测，返回true|false
String name = "zhoupei";
Predicate<String> predicate = s -> name.equals(s);
list.stream().filter(predicate);

//Consumer<T>，对参数执行无返回值的回调
private static void execute(Consumer consumer){
  String name = "zhoupei";
  System.out.println("执行任务");
  consumer.accept(name);
}
execute(s-> System.out.println("回调打印我的名字:" + s));

//Function<T,R>，对参数执行有返回值的回调
Function<Integer,Integer> function = i-> 1*5;
System.out.println(function.apply(3));

方法引用

//调用类的静态方法
ClassName::staticMethod

//引用对象的方法
String:length

//调用已经存在的外部对象的方法
Transaction::getValue

实践案例

• forEach双层循环

List<String> list1 = new ArrayList<String>(){{
    add("lisi");
    add("wangwu");
}};
List<String> list2 = new ArrayList<String>(){{
    add("zhangsan");
    add("lisi");
    add("wangwu");
}};
list1.forEach(s1->list2.forEach(s2->{
    if (s1.equals(s2)){
      System.out.println(s2);
    }
}));

Optional

• ofNullable，创建一个可以为空的Optional对象

Optional<String> optional = Optional.ofNullable("hello world");

• ifPresent，如果Optional对象不为空才执行逻辑

optional.ifPresent(s -> System.out.println(true));

• orElse，创建一个有默认值的对象(orElse里的内容一定会执行)

String string = Optional.ofNullable("hello world").orElse("default");

• orElseGet，创建一个有默认值的对象(如果前面不为空，orElseGet里的内容不会执行)

String string = Optional.ofNullable("hello world").orElseGet(()->"default");

• 校验数据 filter + isPresent

boolean exists = optional.filter(predicate1.and(predicate2)).isPresent();

• 校验数据 ifPresent

optional.filter(predicate1.and(predicate2)).ifPresent(s-> System.out.println(true));

• 实战：去掉hello world中间的空格，然后校验长度|判断是否相等

Predicate<String> predicate3 = s->"helloworld".equals(s);
optional.map(s -> s.replace(" ",""))
    .filter(predicate1.and(predicate2).and(predicate3))
    .ifPresent(s-> System.out.println(true));

--各种复合：比较器复合、谓词复合、函数复合（待充电）