集合处理数据的弊端

当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就是

public static void main(String[] args) {
  // 定义一个List集合
  List<String> list = Arrays.asList("张三","张三丰","成龙","周星驰");
  // 1.获取所有 姓张的信息
  List<String> list1 = new ArrayList<>();
  for (String s : list) {
    if(s.startsWith("张")){
      list1.add(s);
    }
  }
  // 2.获取名称长度为3的用户
  List<String> list2 = new ArrayList<>();
  for (String s : list1) {
    if(s.length() == 3){
      list2.add(s);
    }
  }
  // 3. 输出所有的用户信息
  for (String s : list2) {
    System.out.println(s);
  }
}

上面的代码总是一次次的循环，或许需要一种更加高效的处理方式，这时可以通过JDK8中提供的Stream API来解决这个问题。

public static void main(String[] args) {
  // 定义一个List集合
  List<String> list = Arrays.asList("张三","张三丰","成龙","周星驰");
  // 1.获取所有 姓张的信息
  // 2.获取名称长度为3的用户
  // 3. 输出所有的用户信息
  list.stream()
    .filter(s->s.startsWith("张"))
    .filter(s->s.length() == 3)
    .forEach(s->{
      System.out.println(s);
    });
  System.out.println("----------");
  list.stream()
    .filter(s->s.startsWith("张"))
    .filter(s->s.length() == 3)
    .forEach(System.out::println);
}

如果使用Stream来实现，会显得更加简便，并且可读性也很好。

Stream思想

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工

处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

Stream流的获取方式

根据Collection获取

首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实

现都可以通过steam方法来获取Stream流。

public static void main(String[] args) {
  List<String> list = new ArrayList<>();
  list.stream();
  Set<String> set = new HashSet<>();
  set.stream();
  Vector vector = new Vector();
  vector.stream();
}

而Map比较特殊，如果想要使用，需要根据Map来获取对应的Key和Value的集合

public static void main(String[] args) {
  Map<String,Object> map = new HashMap<>();
  Stream<String> stream = map.keySet().stream(); // key
  Stream<Object> stream1 = map.values().stream(); // value
}

通过Stream的of方法

在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所有Stream接口中提供了静态方法of

public static void main(String[] args) {
  Stream<String> a1 = Stream.of("a1", "a2", "a3");
  String[] arr1 = {"aa","bb","cc"};
  Stream<String> arr11 = Stream.of(arr1);
  Integer[] arr2 = {1,2,3,4};
  Stream<Integer> arr21 = Stream.of(arr2);
  arr21.forEach(System.out::println);
  // 注意：基本数据类型的数组是不行的
  int[] arr3 = {1,2,3,4};
  Stream.of(arr3).forEach(System.out::println);
}

Stream常用方法介绍

Stream流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用

非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用

Stream注意事项(重要)

Stream只能操作一次
Stream方法返回的是新的流
Stream不调用终结方法，中间的操作不会执行

foreach

forEach用来遍历流中的数据的

void forEach(Consumer<? super T> action);

该方法接受一个Consumer接口，会将每一个流元素交给函数处理

public static void main(String[] args) {
  Stream.of("a1", "a2", "a3").forEach(System.out::println);;
}

count

Stream流中的count方法用来统计其中的元素个数的。该方法返回一个long值，代表元素的个数。

public static void main(String[] args) {
  long count = Stream.of("a1", "a2", "a3").count();
  System.out.println(count);
}

filter

filter方法的作用是用来过滤数据的。返回符合条件的数据

可以通过filter方法将一个流转换成另一个子集流

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个Predicate函数式接口参数作为筛选条件

public static void main(String[] args) {
  Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
  .filter((s)->s.contains("a"))
  .forEach(System.out::println);
}

输出：

a1
a2
a3
aa

limit

limit方法可以对流进行截取处理，支取前n个数据

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

public static void main(String[] args) {
  Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
  .limit(3)
  .forEach(System.out::println);
}

输出：

a1
a2
a3

skip

如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流：

public static void main(String[] args) {
  Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
  .skip(3)
  .forEach(System.out::println);
}

输出：

bb
cc
aa
dd

map

如果我们需要将流中的元素映射到另一个流中，可以使用map方法：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的数据

public static void main(String[] args) {
  Stream.of("1", "2", "3","4","5","6","7")
  //.map(msg->Integer.parseInt(msg))
  .map(Integer::parseInt)
  .forEach(System.out::println);
}

sorted

如果需要将数据排序，可以使用sorted方法：

在使用的时候可以根据自然规则排序，也可以通过比较强来指定对应的排序规则

public static void main(String[] args) {
  Stream.of("1", "3", "2","4","0","9","7")
  //.map(msg->Integer.parseInt(msg))
  .map(Integer::parseInt)
  //.sorted() // 根据数据的自然顺序排序
  .sorted((o1,o2)->o2-o1) // 根据比较强指定排序规则
  .forEach(System.out::println);
}

distinct

如果要去掉重复数据，可以使用distinct方法：

public static void main(String[] args) {
  Stream.of("1", "3", "3","4","0","1","7")
  //.map(msg->Integer.parseInt(msg))
  .map(Integer::parseInt)
  //.sorted() // 根据数据的自然顺序排序
  .sorted((o1,o2)->o2-o1) // 根据比较强指定排序规则
  .distinct() // 去掉重复的记录
  .forEach(System.out::println);
  System.out.println("--------");
  Stream.of(
  new Person("张三",18)
  ,new Person("李四",22)
  ,new Person("张三",18)
  ).distinct()
  .forEach(System.out::println);
}

Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，我们是需要

重写hashCode和equals方法来移除重复元素。

match

如果需要判断数据是否匹配指定的条件，可以使用match相关的方法

boolean anyMatch(Predicate<? super T> predicate); // 元素是否有任意一个满足条件
boolean allMatch(Predicate<? super T> predicate); // 元素是否都满足条件
boolean noneMatch(Predicate<? super T> predicate); // 元素是否都不满足条件

public static void main(String[] args) {
  boolean b = Stream.of("1", "3", "3", "4", "5", "1", "7")
  .map(Integer::parseInt)
  //.allMatch(s -> s > 0)
  //.anyMatch(s -> s >4)
  .noneMatch(s -> s > 4);
  System.out.println(b);
}

注意match是一个终结方法

find

如果我们需要找到某些数据，可以使用find方法来实现

public static void main(String[] args) {
  Optional<String> first = Stream.of("1", "3", "3", "4", "5", "1","7").findFirst();
  System.out.println(first.get());
  Optional<String> any = Stream.of("1", "3", "3", "4", "5", "1","7").findAny();
  System.out.println(any.get());
}

max和min

如果我们想要获取最大值和最小值，那么可以使用max和min方法

Optional<T> min(Comparator<? super T> comparator);
Optional<T> max(Comparator<? super T> comparator);

public static void main(String[] args) {
  Optional<Integer> max = Stream.of("1", "3", "3", "4", "5", "1", "7")
  .map(Integer::parseInt)
  .max((o1,o2)->o1-o2);
  System.out.println(max.get());
  Optional<Integer> min = Stream.of("1", "3", "3", "4", "5", "1", "7")
  .map(Integer::parseInt)
  .min((o1,o2)->o1-o2);
  System.out.println(min.get());
}

终结方法

concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

public static void main(String[] args) {
  Stream<String> stream1 = Stream.of("a","b","c");
  Stream<String> stream2 = Stream.of("x", "y", "z");
  // 通过concat方法将两个流合并为一个新的流
  Stream.concat(stream1,stream2).forEach(System.out::println);
}

重学JDK8新特性之Stream（下）:https://developer.aliyun.com/article/1413213

重学JDK8新特性之Stream（上）