Stream流

jAVA8 Stream流

一、什么是Stream？

Java8 中，Collection 新增了两个流方法，分别是 Stream() 和 parallelStream()Java8 中添加了一个新的接口类 Stream，相当于高级版的 Iterator，它可以通过 Lambda 表达式对集合进行大批量数据操作，或 者各种非常便利、高效的聚合数据操作。

二、为什么要使用 Stream？

在 Java8 之前，我们通常是通过 for 循环或者 Iterator 迭代来重新排序合并数据，又或者通过重新定义 Collections.sorts 的 Comparator 方法来实现，这两种方式对于大数据量系统来说，效率并不是很理想。Stream 的聚合操作与数据库 SQL 的聚合操作 sorted、filter、map 等类似。我们在应用层就可以高效地实现类似数据库 SQL 的 聚合操作了，而在数据操作方面，Stream 不仅可以通过串行的方式实现数据操作，还可以通过并行的方式处理大批量数据，提高数据 的处理效率。

三、流的特点

1. 流本身不存储元素，并且不会改变源对象，相反，它会返回一个持有结果的新流
2. 流可以在不使用赋值或可变数据的情况下对有状态的系统建模
3. 流是一种声明式编程风格，它声明想要做什么，而非指明如何做
4. 流的迭代过称为内部迭代，你看不到迭代过程，可读性更强
5. 流是懒加载的，它会等到需要时才执行

四、流程

1、把集合转换为流stream
2、操作stream流
stream流在管道中经过中间操作(intermediate operation)处理，最后由最终操作(terminal operation)得到前面处理结果

五、中间操作符

操作	类型	返回类型	使用的类型/函数式接口	函数描述符
filter	中间	Stream	Predicate	T -> boolean,为null会报异常
distinct	中间	Stream
skip	中间	Stream	long
limit	中间	Stream	long
map	中间	Stream	Function<T, R>	T -> R
flatMap	中间	Stream	Function<T, Stream>	T -> Stream
sorted	中间	Stream	Comparator	(T, T) -> int
anyMatch	终端	boolean	Predicate	T -> boolean
noneMatch	终端	boolean	Predicate	T -> boolean
allMatch	终端	boolean	Predicate	T -> boolean
findAny	终端	Optional
findFirst	终端	Optional
forEach	终端	void	Consumer	T -> void
collect	终端	R	Collector<T, A, R>	T ->
reduce	终端	Optional	BinaryOperator	(T, T) -> T
count	终端	long

1、中间操作

filter的使用（筛选）

	//筛选出以J开头的元素并打印
    Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift")
            .stream().filter(s -> s.startsWith("J"))
            .forEach(System.out::println);

    //输出结果: Java JavaScript

distinct的使用（剔除）

 	//剔除掉重复的元素
    Arrays.asList(1,2,1,3,2,5)
            .stream().distinct()
            .forEach(System.out::println);

    //输出结果: 1 2 3 5

skip的使用（跳过）

 	//跳过第一个元素
    Arrays.asList(1,2,1,3,2,5)
            .stream().skip(1)
            .forEach(System.out::println);
            
    //输出结果: 2 1 3 2 5

limit的使用（截取）

    //截取集合前面n个元素,如果n大于集合的size,则返回全部元素 如果 n < 0 抛异常 						   	 IllegalArgumentException
    Arrays.asList(1,2,1,3,2,5)
            .stream().limit(10)
            .forEach(System.out::println);
    }

    //输出结果: 1 2 1

map的使用（）

    //将数组中的元素全部转为大写 
    Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift")
            .stream().map(String::toUpperCase)
            .forEach(System.out::println);
    }

    //输出结果: JAVA JAVASCRIPT PYTHON PHP C# GOLANG SWIFT
    
    //将流转换成特定的流
    Integer sum =  Arrays.asList(1,2,1,3,2,5)
            .stream().mapToInt(value -> value).sum();

    //输出结果: 14

flatMap的使用（）

    List<String []> objLlist = Stream.of("Hello","World")
                    .map(word ->word.split(""))
                    .distinct()
                    .collect(Collectors.toList());

    //输出结果 [Ljava.lang.String;@43556938  [Ljava.lang.String;@3d04a311

    List strList = Stream.of("Hello","World")
            .map(word ->word.split(""))
            .flatMap(Arrays::stream)
            .distinct()
            .collect(Collectors.toList());

    //输出结果 H  e  l  o  W  r  d

sorted的使用（排序）

	//自然排序
	list.stream().sorted()
    //自然序逆序元素，使用Comparator 提供的reverseOrder() 方法
    list.stream().sorted(Comparator.reverseOrder()) 
    //使用Comparator 来排序一个list
    list.stream().sorted(Comparator.comparing(Student::getAge)) 
    //把上面的元素逆序
    list.stream().sorted(Comparator.comparing(Student::getAge).reversed())     

2、终端操作

数组和集合的遍历

	//遍历集合并打印
    Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift")
            .forEach(System.out::println);
    
    //输出结果 Java JavaScript python PHP C# Golang Swift

anyMatch的使用

    //判断集合中的元素是否至少有一个满足某个条件
    boolean flag =  Arrays.asList(1,2,1,3,2,5)
            .stream().allMatch(s -> s > 3);

    //输出结果: true

noneMatch的使用

	//判断集合中的元素是否都不满足某个条件
    boolean flag =  Arrays.asList(1,2,1,3,2,5)
            .stream().noneMatch(s -> s > 3);

    //输出结果: false

allMatch的使用

    //判断集合中的元素是否都满足某个条件
    boolean flag =  Arrays.asList(1,2,1,3,2,5)
            .stream().allMatch(s -> s > 0);

    //输出结果: true

findAny的使用

    //判断集合中的元素是否都满足某个条件,有则打印一个元素
    Arrays.asList(1,2,1,3,2,5)
            .stream().filter(s -> s > 2)
            .findAny()
            .ifPresent(System.out::println);
    
    //输出结果: 3
        
    //判断集合中的元素是否都满足某个条件
    boolean flag = Arrays.asList(1,2,1,3,2,5)
            .stream()
            .filter(s -> s > 3)
            .findAny()
            .isPresent();

    //输出结果: true

findFirst的使用

    //判断集合中的元素是否都满足某个条件,有则打印第一符合的个元素
    Arrays.asList(1,2,1,3,2,5)
            .stream().filter(s -> s > 2)
            .findFirst()
            .ifPresent(System.out::println);

    //输出结果: 3

collect的使用

    //将集合中筛选出符合条件的并放入集合中返回
    List<String> list = 
            Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift")
            .stream()
            .filter(s -> s.startsWith("J"))
            .collect(Collectors.toList());
        
    //输出结果: Java JavaScript

reduce的使用

    //对numbers中的元素求和
    Arrays.asList(1, 2, 1, 3, 3, 2, 4)
            .stream()
           .reduce(0, Integer::sum); // 16
           
       //求集合中的最大值
    Arrays.asList(1,2,1,3,2,5)
            .stream()
            .reduce(Integer::max)
            .ifPresent(System.out::println);

    //输出结果: 5

count的使用

    //将集合中筛选出符合条件的并返回符合条件的个数
    Long count =
            Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift")
            .stream()
            .filter(s -> s.startsWith("J"))
            .count();

    //输出结果: 2

六、其他的Stream

还有其他的Stream比如LongStream、DouleStream等等、、、、、简单举个例子

//对一个long集合进行正序排序（注意Long是long的包装类，，，，，我说怎么。。。。）
long[] longss = {1L,2L,7L,3L};
long[] longs = LongStream.of(longss).sorted().toArray();

//这是倒叙
longss = LongStream.of(longss)
                .boxed()
                .sorted(Comparator.reverseOrder())
                .mapToLong(Long::longValue)
                .toArray();
				
/**
* 求和
*/
System.out.println("和(°——°)"+LongStream.of(longss).sum());

/**
* 求平均值
*/
System.out.println("均值(°——°)"+LongStream.of(longss).average());

/**
* 求最大值
*/
System.out.println("最大值(°——°)"+LongStream.of(longss).max());

/**
* 最小值
*/
System.out.println("最大值(°——°)"+LongStream.of(longss).min());

//DoubleStream、IntStream等等就不一一举例了