Java Stream数据处理

介绍

Stream是JDK8引入的一个类型，类似Iterator迭代器，帮助开发者以流的方式处理数据。

Stream的操作分为“转换操作”和“聚合操作”，转换操作返回一个新的Stream，实现链式操作，聚合操作返回最终值并销毁Stream。

Stream通过”转换操作“构建了一个管道，每一个元素处理完毕后立刻向后传递；单独写”转换操作“是不会执行的，只有添加了“聚合操作”，整个管道才会执行。

Stream支持并行处理，类似大数据中map-reduce的模式。

Stream通常与Lamba表达式结合使用，以链式操作进行表达。

创建Stream

• Collection.stream()
• Collection.parallelStream()
• Arrays.stream(T[] array)
• Stream.of(T... values)

普通流

public class Basic10 {
  private static List<Integer> integerList = Arrays.asList(1,2,3,4,5);
  private static String[] stringArray = {"a", "b", "c"};
  private static int[] intArray = {1,2,3,4,5};
  private static long[] longArray = {100L, 200L, 300L};
  private static double[] doubleArray = {1.1, 1.2, 1.3};

  public static void main(String[] args) {
    // 面向对象类型
    Stream<Integer> integerStream = integerList.stream();
    Stream<Integer> integerStream1 = integerList.parallelStream();
    Stream<String> stringStream = Arrays.stream(stringArray);
    Stream<String> stringStream1 = Stream.of("a", "b", "c");

    // 面向基本类型
    IntStream intStream = Arrays.stream(intArray);
    LongStream longStream = Arrays.stream(longArray);
    DoubleStream doubleStream = Arrays.stream(doubleArray);
  }
}

并行流

/**
 * parallel, parallelStream
 * 并行处理，无法保证顺序
 */
public class Basic9 {
  private static List<Integer> integerList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

  public static void main(String[] args) {
    System.out.println(integerList.stream().parallel().map(x -> x * x).collect(Collectors.toList()));
    System.out.println(integerList.parallelStream().map(x -> x * x).collect(Collectors.toList()));
  }
}

转换操作

map和flatMap

• map:进行数据的一对一映射和转换
• flatMap:将元素转换分别为Stream然后合并为一个Stream

/**
 * map和flatMap
 */
public class Basic {
  private static List<String> list = Arrays.asList("hello", "word");
  private static List<Integer> nums = Arrays.asList(1,2,3,4,5);
  private static List<List<Integer>> listNums = Arrays.asList(
    Arrays.asList(1,2,3),
    Arrays.asList(4,5,6)
  );
  public static void main(String[] args) {
    // 转换大写 [HELLO, WORD]
    		System.out.println(Basic.list.stream().map(String::toUpperCase).collect(Collectors.toList()));
    // 求平方  [1, 4, 9, 16, 25]
    System.out.println(Basic.nums.stream().map(x -> x * x).collect(Collectors.toList()));
    // 展开合并 [1, 2, 3, 4, 5, 6]
    System.out.println(Basic.listNums.stream().flatMap(Collection::stream).collect(Collectors.toList()));
  }
}

filter

根据条件过滤元素

/**
 * filter
 */
public class Basic2 {
  private static Integer[] nums = {1, 2, 3, 4, 5};
  private static String[] strings = {"hello", "word"};

  public static void main(String[] args) {
    // 过滤偶数 [2, 4]
    System.out.println(Arrays.stream(nums).filter(x -> x % 2 == 0).collect(Collectors.toList()));
    // 过滤字符串 [word]
    System.out.println(Stream.of(strings).filter(x -> x.length() == 4).collect(Collectors.toList()));
  }
}

peek

对每一个元素执行相同操作，同forEach

/**
 * peek
 */
public class Basic3 {
  private static String[] strings = {"hello", "world"};

  public static void main(String[] args) {
    // peek是一个转换操作，功能和forEach一致，但会返回Stream
    // hello,HELLO,world,WORD 
    // Stream转换操作:每一个元素完成后立刻往后送，不是等待全部元素转换完成一起往后送
 						Arrays.stream(strings).peek(System.out::println).map(String::toUpperCase).peek(System.out::println).count();
  }
}

skip和limit

• skip：忽略前n个元素
• limit：截取前n个元素

/**
 * skip, limit
 */
public class Basic5 {
  private static Stream<Integer> integerStream = Stream.of(1,2,3,4,5);

  public static void main(String[] args) {
    // 忽略前两个，然后从后面的元素中截取前两个进行计算 [3,4]
    System.out.println(integerStream.skip(2).limit(2).collect(Collectors.toList()));
  }
}

sorted

对元素进行排序

/**
 * sorted
 */
public class Basic6 {
  private static Stream<Integer> integerStream = Stream.of(1,3,2,4,5);
  private static Stream<String> stringStream = Stream.of("b", "a", "d", "c");
  private static Stream<Person> personStream = Stream.of(new Person("John"), new Person("Diana"));

  public static void main(String[] args) {
    // 对Comparable对象进行排序 [1, 2, 3, 4, 5] [a, b, c, d]
    System.out.println(integerStream.sorted().collect(Collectors.toList()));
    System.out.println(stringStream.sorted().collect(Collectors.toList()));
    // 对非Comparable对象进行排序 [Basic6.Person(name=Diana), Basic6.Person(name=John)]
    System.out.println(personStream.sorted(Comparator.comparing(p -> p.name)).collect(Collectors.toList()));
  }

  @Data
  private static class Person {
    private final String name;
  }
}

distinct

/**
 * distinct
 * 通过equals方法
 */
public class Basic7 {
  private static Stream<String> stringStream = Stream.of("a", "a", "b", "B", "c");

  public static void main(String[] args) {
    // 去重 [a, b, B, c]
    System.out.println(stringStream.distinct().collect(Collectors.toList()));
  }
}

聚合操作

forEach

对每一个元素执行相同操作

/**
 * forEach
 */
public class Basic3 {
  private static String[] strings = {"hello", "world"};

  public static void main(String[] args) {
    // forEach是一个聚合操作，不再返回Stream
    // hello world
    Arrays.stream(strings).forEach(System.out::println);
  }
}

reduce

对元素进行叠加聚合，通常提供一个初始值，后续元素向初始值叠加

/**
 * reduce
 */
public class Basic4 {
  private static List<Integer> nums = Arrays.asList(1,2,3,4,5);
  private static List<String> strings = Arrays.asList("a", "b", "c");

  public static void main(String[] args) {
    // 求和 15
    System.out.println(nums.stream().reduce(0, Integer::sum));
    // 拼接字符串 abc
    System.out.println(strings.stream().reduce("", String::concat));
    // 最小值 1
    System.out.println(nums.stream().reduce(Integer.MAX_VALUE, Integer::min));
    // 最大值 5
    System.out.println(nums.stream().reduce(Integer.MIN_VALUE, Integer::max));
  }
}

allMatch,anyMatch,noneMatch

根据条件进行匹配判断，返回布尔值

/**
 * allMatch, anyMatch, noneMatch
 */
public class Basic8 {
  private static List<Integer> integerList = Arrays.asList(1,2,3,4,5);

  public static void main(String[] args) {
    System.out.println("全部是偶数吗? " + integerList.stream().allMatch(x -> x % 2 == 0));
    System.out.println("存在偶数吗？" + integerList.stream().anyMatch(x -> x % 2 == 0));
    System.out.println("全都不是偶数吗？" + integerList.stream().noneMatch(x -> x % 2 == 0));
  }
}

collect

将Stream转换为Collection

/**
 * collect
 */
public class Basic1 {
  private static List<Integer> integerList = Arrays.asList(1,2,3,4,5);

  public static void main(String[] args) {
    List<Integer> resList = integerList.stream().map(x -> x * x).collect(Collectors.toList());
    Map<String, Integer> resMap = integerList.stream().map(x -> x * x).collect(Collectors.toMap(Object::toString, x -> x));
    Set<Integer> resSet = integerList.stream().map(x -> x * x).collect(Collectors.toSet());
    // [1, 4, 9, 16, 25]
    System.out.println(resList);
    // {1=1, 25=25, 4=4, 16=16, 9=9}
    System.out.println(resMap);
    // [16, 1, 4, 9, 25]
    System.out.println(resSet);
  }
}

toArray

将Stream转换为Array

public class Basic11 {
  private static List<Integer> integerList = Arrays.asList(1,2,3,4,5);
  private static int[] intArray = {1,2,3,4,5};

  public static void main(String[] args) {
    // 对象类型返回Object[]
    Object[] resArray = integerList.stream().map(x -> x * x).toArray();
    // 基本类型返回相同的基本类型数组
    int[] resArray1 = Arrays.stream(intArray).map(x -> x * x).toArray();
  }
}