Java8 Stream简述及基本操作

Java8 Stream API

Java中的Stream（流）被定义为支持聚合操作的源的一系列元素序列。这里的源指的是向Stream提供数据的Collections或Arrays.

Stream保持数据在源中的顺序。这种聚合操作或批量操作允许我们更轻松而清晰的对stream元素作出常见的操作。

在开始之前，了解Java 8 Streams的设计方式是绝大多数stream操作只返回streams是很重要的。这帮助我们创建了stream操作链。这被称作为pipe-lining（管道链）。

1. Java Stream

• Not a data structure(非数据结构)
• Designed for lambdas(为lambda)设计
• Do not support indexed access(不支持索引访问)
• Can easily be outputted as arrays or lists(很容易输出为arrays或list)
• Lazy access supported(支持延迟加载)
• Parallelizable(并行)

2. Different ways to create streams

2.1 Stream.of(val1,val2,val3…)

public class StreamBuilders
{
     public static void main(String[] args)
     {
         Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9);
         stream.forEach(p -> System.out.println(p));
     }
}

2.2 Stream.of(arrayOfElements)

public class StreamBuilders
{
     public static void main(String[] args)
     {
         Stream<Integer> stream = Stream.of( new Integer[]{1,2,3,4,5,6,7,8,9} );
         stream.forEach(p -> System.out.println(p));
     }
}

2.3 List.stream()

public class StreamBuilders
{
     public static void main(String[] args)
     {
         List<Integer> list = new ArrayList<Integer>();
 
         for(int i = 1; i< 10; i++){
             list.add(i);
         }
 
         Stream<Integer> stream = list.stream();
         stream.forEach(p -> System.out.println(p));
     }
}

2.4 Stream.generate() or Stream.iterate()

public class StreamBuilders
{
     public static void main(String[] args)
     {
         Stream<Date> stream = Stream.generate(() -> { return new Date(); });
         stream.forEach(p -> System.out.println(p));
     }
}

2.5 String chars or String tokens

public class StreamBuilders
{
     public static void main(String[] args)
     {
        IntStream stream = "12345_abcdefg".chars();
        stream.forEach(p -> System.out.println(p));
         
        //OR
         
        Stream<String> stream = Stream.of("A$B$C".split("\\$"));
        stream.forEach(p -> System.out.println(p));
     }
}

3. Convert streams to collections

3.1 Convert Stream to List- Stream.collect(Collectors.toList())

public class StreamBuilders {
     public static void main(String[] args){
         List<Integer> list = new ArrayList<Integer>();
         for(int i = 1; i< 10; i++){
             list.add(i);
         }
         Stream<Integer> stream = list.stream();
         List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0).collect(Collectors.toList());
         System.out.print(evenNumbersList);
     }
}

3.2 Convert Stream to array -Stream.toArray(EntryType[]::new)

public class StreamBuilders {
     public static void main(String[] args){
         List<Integer> list = new ArrayList<Integer>();
         for(int i = 1; i< 10; i++){
             list.add(i);
         }
         Stream<Integer> stream = list.stream();
         Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
         System.out.print(evenNumbersArr);
     }
}

还有许多其他的方式可以将stream收集到set,map或多个方法中，只要通过Collectors类并且记住他们他们.

4. Core stream operations

首先先建立一个字符串集合,我们将在这个列表上建立一个示例.

List<String> memberNames = new ArrayList<>();
memberNames.add("Amitabh");
memberNames.add("Shekhar");
memberNames.add("Aman");
memberNames.add("Rahul");
memberNames.add("Shahrukh");
memberNames.add("Salman");
memberNames.add("Yana");
memberNames.add("Lokesh");

这些核心方法分为以下两部分:

4.1 Intermediate operations(中间操作)

Intermediate operations 返回stream本身,因此可以在一行中链式调用多个方法.

4.1.1 Stream.filter()

Filter 接收一个predicate来过滤stream(流)中所有元素,这是一个中间操作,它允许我们对结果调用另一个stream操作.(比如forEach)

memberNames.stream().filter((s)>s.startsWith("A"))
    				.forEach(System.out::println);

输出为:

Amitabh
Aman

4.1.2Stream.map()

Intermediate operation通过给定的函数可以将stream中的每个元素转换为另一个对象.下面的示例将每个字符串转换为大写.也可以使用map将对象转换为另一种类型.

memberNames.stream().filter((s)->s.startsWith("A"))
			        .map(String::toUpperCase)
			        .forEach(System.out::println);

输出:

AMITABH
AMAN

4.1.3 Stream.sorted()

Sorted是一个返回已排序stream视图的中间操作,该排序规则,除非传递一个自定义比较器,否则元素自然排序.

memberNames.stream().sorted()
					.map(String::toUpperCase)
			        .forEach(System.out::println);

输出结果:

AMAN
AMITABH
LOKESH
RAHUL
SALMAN
SHAHRUKH
SHEKHAR
YANA

4.2 Terminal operations(结束操作)

Terminal operations返回特定类型的结果,而非是stream

4.2.1 Stream.forEach()

这个方法帮助遍历stream中的所有元素,并且对其执行某些操作.这种操作通过lambda表达式参数传递.

memberNames.forEach(System.out::println);

4.2.2 Stream.collect()

collect()方法用于从stream中接收元素并且存储到collection中.

	List<String> memNamesInUpper=memberNames.stream().sorted()
									.map(String::toUpperCase)
									.collect(Collectors.toList());
	System.out.println(memNamesInUpper);

输出结果:

[AMAN, AMITABH, LOKESH, RAHUL, SALMAN, SHAHRUKH, SHEKHAR, YANA]

4.2.3 Stream.match()

各种matching(匹配)操作被用来检查某个predicate(断言)是否与stream匹配.所有这些操作都是终端操作,并返回一个boolean值.

boolean matchedResult = memberNames.stream().anyMatch((s) -> s.startsWith("A"));
System.out.println(matchedResult);

matchedResult = memberNames.stream().allMatch((s) -> s.startsWith("A"));
System.out.println(matchedResult);

matchedResult = memberNames.stream().noneMatch((s) -> s.startsWith("A"));
System.out.println(matchedResult);

输出结果:

true

false

false

4.2.4 Stream.count()

Count是一个返回stream中元素数量的结果操作,返回值为long型.

long total=memberNames.stream()
			.filter((s)->s.startsWith("A"))
			.count();
System.out.println(total);

输出结果:

2

4.2.5 Stream.reduce()

该terminal operation使用给定函数对stream中元素执行缩减,这个结果是一个包含缩减后的值的Optional.

Optional<String> reduced=memberNames.stream()
						.reduce((s1,s2)->s1+"#"+s2);
reduced.ifPresent(System.out::println);

输出为:

Amitabh#Shekhar#Aman#Rahul#Shahrukh#Salman#Yana#Lokesh

5. Stream short-circuit operations(流短路操作)

尽管stream操作是在满足一个predicate的集合中的所有元素上执行的,但在迭代过程中每当遇到匹配元素时,通常都希望结束这个操作.在外部迭代中,你将使用if-else语句块,而在内部迭代中,也可以使用特定方法达到这个目的.

5.1 Stream.anyMatch()

当predicate满足条件,则返回true,它将不再处理更多元素.

boolean metched=memberNames.stream()
    			.anyMatch((s)->s.startWith("A"));
System.out.println(metched);

输出结果:

true

5.2 Stream.findFirst()

该方法返回stream中的第一个元素并且不再处理任何其他的元素.

String firstMatchedName=memberNames.stream()
    					.filter((s)->s.startWith("L"))
    					.findFirst().get();
System.out.println(firstMatchedName);

输出结果:

Lokesh

6. Parallelism in Java Stream(并行性)

通过再Java7中加入Fork/Join框架,我们可以更高效的再引用程序中实现并行操作.但实现这个框架本身是一项复杂的任务,如果出现错误,这就是复杂多线程出现Bug的一个源头.随着Java内部迭代的引入,使得并行操作有了更易操作的可能性.

为实现parallelism,只需要创建一个parallel stream(并行流),而不是sequential stream .可以发现,这是很简单的,在上述的多个示例中,如果你要 在并行内核中使用多个线程执行特定任务,只需要调用parallelStream()而不是stream()

	List<Integer> list = new ArrayList<>();
	for (int i = 1; i < 10; i++)
		list.add(i);
	// creating a parallel stream
	Stream<Integer> stream = list.parallelStream();
	Integer[] evenNumbersArr = stream.filter(i -> i % 2 == 0)
        								.toArray(Integer[]::new);
	System.out.println(Arrays.toString(evenNumbersArr));

输出结果:

[2,4,6,8]

7. Other Stream Operations

Intermediate Operations

• filter()
• map()
• flatMap()
• distinct()
• sorted()
• peek()
• limit()
• skip()

Terminal Operations

• forEach()
• forEachOrdered()
• toArray()
• reduce()
• collect()
• min()
• max()
• count()
• anyMatch()
• allMatch()
• noneMatch()
• findFirst()
• findAny()