http://java.amitph.com/2014/01/understanding-java-8-streams-api.html

Since past few versions, Java has started giving importance to concurrency. Java 8 goes one more step ahead and has developed a Streams API which lets us think about parallelism. Nowadays, because of the tremendous amount of development on the hardware front, multicore CPUs are becoming more and more general. In order to leverage the hardware capabilities Java had introduced Fork Join Framework. Java 8 Streams API supports many parallel operations to process the data, while completely abstracting out the low level multithreading logic and letting the developer fully concentrate on the data and the operations to be performed on the data.

Most of us know, parallel processing is all about dividing a larger task into smaller sub tasks (forking), then processing the sub tasks in parallel and then combining the results together to get the final output (joining). Java 8 Streams API provides a similar mechanism to work with Java Collections. The Java 8 Streams concept is based on converting Collections to a Stream, processing the elements in parallel and then gathering the resulting elements into a Collection.

Collections vs Streams:

Collections are in-memory data structures which hold elements within it. Each element in the collection is computed before it actually becomes a part of that collection. On the other hand Streams are fixed data structures which computes the elements on-demand basis.

The Java 8 Streams can be seen as lazily constructed Collections, where the values are computed when user demands for it. Actual Collections behave absolutely opposite to it and they are set of eagerly computed values (no matter if the user demands for a particular value or not).

Deeper Look at Streams:
The Stream interface is defined in java.util.stream package. Starting from Java 8, the java collections will start having methods that return Stream. This is possible because of another cool feature of Java 8, which is default methods. Streams can be defiled as a sequence of elements from a source that supports aggregate operations.

The source here refers to a Collection, IO Operation or Arrays who provides data to a Stream. Stream keeps the order of the data as it is in the source.
Just like functional programming languages, Streams support Aggregate Operations. The common aggregate operations are filter, map, reduce, find, match, sort. These operations can be executed in series or in parallel.

The Streams also support Pipelining and Internal Iterations. The Java 8 Streams are designed in such a way that most of its stream operations returns Streams only. This help us creating chain of various stream operations. This is called as pipelining. The pipelined operations looks similar to a sql query.

In Java, we traditionally use for loops or iterators to iterate through the collections. These kind of iterations are called asexternal iterations and they are clearly visible in the code. Java 8 Stream operations has methods like foreach, map, filter, etc. which internally iterates through the elements. The code is completely unaware of the iteration logic in the background. These kind of iterations are called as internal iterations.

List<String> names =newArrayList<>();
for(Student student : students){
if(student.getName().startsWith("A")){
names.add(student.getName());
}
}

There is nothing special about this code. This is a traditional Java external iterations example. Now, have a look at the below code. This line is doing exactly the same thing but we can't see any iteration logic here and hence it is called asinternal iterations.
List<string> names = students.stream().map(Student::getName).filter(name->name.startsWith("A"))
.collect(Collectors.toList());

Operations on Streams:
There are variety of operations defined in the Streams interface. Have a look at the below example. Here we are iterating through list of students, and selecting names of first 10 students whose names start with "A".

List<String> names = students.stream()
.map(Student::getName)
.filter(name->name.startsWith("A"))
.limit(10)
.collect(Collectors.toList());

In the above code there are few operations like map, filter, limit, and collect. We can categories these operations into Intermediate operations and Terminal Operations.

The intermediate operations return streams and hence can be connected together to form a pipeline of operations. In above example map, filter, and limit are such intermediate operations.

The terminal operations, as the name suggests reside at the end of such a pipeline and their task is to close the stream in some meaningful way. Terminal operations collect the results of various stream operations in the form of anything like lists, integers or simply nothing. If we have to print the name of students whose name starts with "A", the foreach operation will be our terminal operation that will print all the names from the filtered stream and will return nothing.

The most interesting part to know about the intermediate operations is that they are lazy. The intermediate operations will not be invoked until the terminal operation is invoked. This is very important when we are processing larger data streams. The process only on demand principle drastically improves the performance. The laziness of theintermediate operations help to invoke these operation in one pass. Now, if you are not clear with single pass, please wait until we dive into more details about Java 8 Streams during our subsequent discussions.

Numerical Ranges:

Most of the times we need to perform certain operation on the numerical ranges. To help in such scenarios Java 8 Streams API has come up with three useful interfaces IntStream, DobuleStream, and LongStream.

IntStream.rangeClosed(1,10).forEach(num ->System.out.print(num));
// ->12345678910
IntStream.range(1,10).forEach(num ->System.out.print(num));
// ->123456789

All of the above mentioned interfaces support range and rangeClosed methods. range method is exclusive whilerangeClosed is inclusive.
Both of these methods return stream of numbers and hence can be used as intermediate operations in a pipeline.

Building Streams:

By now, we have had a quick overview of what is Java 8 Stream and how useful it is. We have seen Java Collections can generate streams of the data contained within them, we have also seen how to get streams of numerical ranges. But creating Streams is not limited to this, there are many other ways by which streams can be generated.

Using the 'Of' method we can created stream of hardcoded values. Suppose we want stream of hardcoded Strings, just pass all of the Strings to the 'of' method.

Suppose we want to create a stream of all the elements in an array, we can do so by calling stream method on Arrays. Arrays is a traditional utility class which now has a support for stream methods.

//Creating Stream of hardcoded Strings and printing each String
Stream.of("This","is","Java8","Stream").forEach(System.out::println);
//Creating stream of arrays
String[] stringArray =newString[]{"Streams","can","be","created","from","arrays"};
Arrays.stream(stringArray).forEach(System.out::println);
//Creating BufferedReader for a file
BufferedReader reader =Files.newBufferedReader(Paths.get("File.txt"),StandardCharsets.UTF_8);
//BufferedReader's lines methods returns a stream of all lines
reader.lines().forEach(System.out::println);

Recently added NIO API as well as the traditional IO API have been updated to support the streams. This provides very useful abstraction of directly creating streams of lines being read from a file.

Java 8 Streams is a completely new to Java and it is a very large concept, and it is difficult to cover it completely on this platform. That doesn't mean our discussion on streams ends here. Till now we have seen what are the Java 8 Streams, how the existing APIs have been updated to support Streams, brief about various methods on streams, and how to build streams.

We will keep this discussion alive in subsequent posts. We are yet to look more inside streams, various intermediate stream operations, and ways of collecting computed data with the help of various terminal operations. Thanks!

Understanding Java 8 Streams API---reference的更多相关文章

  1. Java 8 Streams API 详解

    流式编程作为Java 8的亮点之一,是继Java 5之后对集合的再一次升级,可以说Java 8几大特性中,Streams API 是作为Java 函数式的主角来设计的,夸张的说,有了Streams A ...

  2. [转]深入理解Java 8 Lambda(类库篇——Streams API,Collectors和并行)

    以下内容转自: 作者:Lucida 微博:@peng_gong 豆瓣:@figure9 原文链接:http://zh.lucida.me/blog/java-8-lambdas-insideout-l ...

  3. Java 9 揭秘(18. Streams API 更新)

    Tips 做一个终身学习的人. 在本章中,主要介绍以下内容: 在Stream接口中添加了更加便利的方法来处理流 在Collectors类中添加了新的收集器(collectors) JDK 9中,在St ...

  4. 深入理解Java 8 Lambda(类库篇——Streams API,Collectors和并行)

    转载:http://zh.lucida.me/blog/java-8-lambdas-inside-out-library-features/ 关于 深入理解 Java 8 Lambda(语言篇——l ...

  5. Java 8 集合之流式(Streams)操作, Streams API 详解

    因为当时公司的业务需要对集合进行各种各样的业务逻辑操作,为了提高性能,就用到了这个东西,因为以往我们以前用集合都是需要去遍历(串行),所以效率和性能都不是特别的好,而Streams就可以使用并行的方式 ...

  6. Java 8 中的 Streams API 详解

    为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX 对 ...

  7. Java 8中的 Streams API 详解

    为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX 对 ...

  8. (转)Java 8 中的 Streams API 详解

    为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX 对 ...

  9. Java 8 Stream API Example Tutorial

    Stream API Overview Before we look into Java 8 Stream API Examples, let’s see why it was required. S ...

随机推荐

  1. 关于使用idea的一些小技巧

    1:idea与git同步以后查看修改变化: file --setting--versioncontorller

  2. 基于任务的异步编程模式(TAP)

    异步编程是C#5.0的一个重要改进,提供两个关键字:async和await.使用异步编程,方法的调用是在后台运行(通常在线程或任务的帮助下),但不会阻塞调用线程.异步模式分为3种:异步模式.基于事件的 ...

  3. [Win32::Console]Perl终端版生命游戏

    环境,WinXP/Win7  Perl 5.16 默认循环1000次,按ESC提前退出 use strict; use Term::ReadKey; use Win32::Console; use T ...

  4. property特性

    什么是property property是一种特殊属性,访问他时会执行一段功能然后返回值 class People: def __init__(self,name,weight,height): se ...

  5. 类4(可变数据成员/基于const的重载)

    可变数据成员: 有时我们希望能修改某个类的数据成员,即使是在一个 const 成员函数内.可以通过在变量的声明中加入 mutable 关键字来声明一个可变数据成员.mutable 是为突破 const ...

  6. CPU 的工作原理

    内部架构 CPU 的根本任务就是执行指令,对计算机来说最终都是一串由 0 和 1 组成的序列.CPU 从逻辑上可以划分成 3 个模块,分别是控制单元.运算单元和存储单元 .其内部架构如下: [1]控制 ...

  7. 如何删除/mnt/cdrom?|如何删除只读文件系统(Read-only files ystem)? failed !bh ? 挂载光盘?挂载usb?

    root权限下 : 首先用umount /mnt/文件夹 卸载文件系统,必要时可以用umount -f(可能丢失数据)然后rm -rf /mnt/cdrom mkdir /mnt/cdrom moun ...

  8. Python3之sys模块

    一.简介 sys模块用于提供对python解释器的相关操作. 二.常用函数 sys.argv 命令行参数List,第一个元素是程序本身路径 sys.modules 返回系统导入的模块字段,key是模块 ...

  9. 《条目十六》如何将vector和string的数据传给遗留的API

    <条目十六>如何将vector和string的数据传给遗留的API 优秀的代码是可以延续的,所以并非所有的代码都是重构的,而且有时候重构会对整个系统影响较大,投入巨大,得不偿失.然而,也不 ...

  10. bdd相关整理介绍

    BDD介绍 什么是BDD Behavior-driven development In software engineering, behavior-driven development (BDD) ...