深入理解Java8新特性之Stream API的创建方式和中间操作步骤
1.什么是streamapi？
java8中有两大最为重要的改变。第一个是 lambda 表达式；另外一个则是 m stream api (java.util.stream.*) 。
stream 是 java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
使用stream api 对集合数据进行操作，就类似于使用 sql 执行的数据库查询。也可以使用 stream api 来并行执行操作。简而言之，stream api 提供了一种高效且易于使用的处理数据的方式。
流 (stream) 到底是什么 呢 ？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“ 集合讲的是 数据 ， 流讲的是 计算 ！”
注意 ：
- stream 自己不会存储元素。
- stream 不会改变源对象。相反，他们会返回一个持有结果的新stream。
- stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
2.stream api操作的三个步骤
- 创建stream：一个数据源（如：集合、数组），获取一个流。
- 中间操作：一个中间操作链，对数据源的数据进行处理。
- 终止操作( ( 终端操作) )：一个终止操作，执行中间操作链，并产生结果。
2.1 创建stream
在java8 中， collection 接口被扩展，提供了两个获取流的方法 ：
- default stream<e> stream() : 返回一个顺序流
- default stream<e> parallelstream() : 返回一个并行流
java8 中的 arrays 的静态方法 stream() 可以获取数组流：
- static <t> stream<t> stream(t[] array): 返回一个流重载形式 ， 能够处理对应基本类型的数组 ：
- public static intstream stream(int[] array)
- public static longstream stream(long[] array)
- public static doublestream stream(double[] array)
可以使用静态方法 stream.of()，通过显示值创建一个流。它可以接收任意数量的参数。
- public static<t> stream<t> of(t... values) : 返回一个流
可以使用静态方法 stream.iterate() 和 stream.generate()，创建无限流。
- 迭代 public static<t> stream<t> iterate(final t seed, final unaryoperator<t> f)
- 生成 public static<t> stream<t> generate(supplier<t> s)
//创建stream
@test
public void test1() {
//1.collection 提供了两个方法 stream() 与 parallelstream()
list<string> list = new arraylist<>();
stream<string> stream1 = list.stream();
//2. 通过 arrays 中的 stream() 获取一个数组流
string[] strings = new string[10];
stream<string> stream2 = arrays.stream(strings);
//3. 通过 stream 类中静态方法 of()
stream<string> stream3 = stream.of("abc","666","???");
//4. 创建无限流
//迭代
stream<integer> stream4 = stream.iterate(0, (x) -> x + 2);
stream4.limit(5).foreach(system.out::println);
//生成
stream.generate(() -> math.random())
.limit(5)
.foreach(system.out::println);
}
2.2 中间操作
多个 中间操作可以连接起来形成一个 流 水 线，除非流水线上触发终止操作，否则 中 间操作 不 会执行 任 何 的 处 理！
而在 终止操作时一次性全部处理 ， 称 为 “ 惰 性 求 值 ”。 常用的中间操作大体上可以分为三类：①筛选与切片；②映射；③排序
2.2.1 中间操作之筛选与切片
下面通过一些代码案例来应用一下。 首先，我们准备一个employee类，以及一个list集合。
package com.szh.java8;
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
/**
*
*/
@data
@noargsconstructor
@allargsconstructor
public class employee {
private integer id;
private string name;
private integer age;
private double salary;
public employee(integer id) {
this.id = id;
}
public employee(integer id,string name) {
this.id = id;
this.name = name;
}
}
list<employee> employees = arrays.aslist(
new employee(1001,"张三",26,6666.66),
new employee(1002,"李四",50,1111.11),
new employee(1003,"王五",18,9999.99),
new employee(1004,"赵六",35,8888.88),
new employee(1005,"田七",44,3333.33),
new employee(1005,"田七",44,3333.33),
new employee(1005,"田七",44,3333.33)
);
筛选年龄小于35岁的员工信息。 这里每次都是先 println 打印结果，然后进行比较，满足则输出。
//内部迭代，在 stream api 内部完成
@test
public void test2() {
//所有的中间操作不会做任何的处理
stream<employee> stream = employees.stream()
.filter((e) -> {
system.out.println("测试中间操作");
return e.getage() <= 35;
});
//只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
stream.foreach(system.out::println);
}
筛选薪资大于5000的员工信息，但是只保留前两条。
@test
public void test3() {
employees.stream()
.filter((e) -> {
system.out.println("短路....");
return e.getsalary() > 5000;
})
.limit(2)
.foreach(system.out::println);
}
筛选薪资大于5000的员工信息，但是扔掉前两条。
@test
public void test4() {
employees.stream()
.filter((e) -> e.getsalary() > 5000)
.skip(2)
.foreach(system.out::println);
}
对集合中的所有员工信息做去重处理。
@test
public void test5() {
employees.stream()
.distinct()
.foreach(system.out::println);
}
2.2.2 中间操作之映射
这里仍然是借助上面案例中的employee类、list集合完成。
首先对自定义的list集合中的所有字符串进行大写转换，同时对员工集合进行 name 字段的映射处理。
@test
public void test1() {
list<string> list = arrays.aslist("aaa","bbb","ccc","ddd","eee");
list.stream()
.map((str) -> str.touppercase())
.foreach(system.out::println);
system.out.println("--------------------------------------");
employees.stream()
.map(employee::getname)
.foreach(system.out::println);
}
对list集合中的每个字符串中的每个字符进行遍历输出。（①使用map；②使用flatmap）
这两种方式主要区别就在获取到stream流之后，流中的泛型不一样了。
我们使用map了话，它会将strlist集合中元素以 "aaa"、"bbb"、"ccc" 这样的形式返回，此时stream流的泛型就仍然是一个stream流（在这个stream流中才是我们想要的数据），也就是我们第一次对stream流进行遍历之后，拿到的是一个又一个的character字符数组，然后还需要再对这个字符数组进行二次遍历（也就是代码上半部分中那两个 foreach）。
如果我们使用flatmap了话，它会将strlist集合中元素以 "a'、"b"、"c"、"d" 这样的形式返回，所以此时stream流的泛型就只是一个character字符数组，那么一次遍历就可以取出数据了（也就是代码下半部分的那个foreach）。
@test
public void test2() {
list<string> strlist = arrays.aslist("aaa","bbb","ccc","ddd","eee");
stream<stream<character>> stream1 = strlist.stream()
.map(mytest6::filtercharacter);
stream1.foreach((sm) -> {
sm.foreach(system.out::println);
});
system.out.println("----------------------------------------");
stream<character> stream2 = strlist.stream()
.flatmap(mytest6::filtercharacter);
stream2.foreach(system.out::println);
}
private static stream<character> filtercharacter(string str) {
list<character> list = new arraylist<>();
for (character character : str.tochararray()) {
list.add(character);
}
return list.stream();
}
2.2.3 中间操作之排序
对list集合中的字符串进行自然排序。对员工集合中的员工信息进行定制化排序（先按照年龄排序，年龄一样再按照姓名排序）。
@test
public void test3() {
list<string> strlist = arrays.aslist("ccc","aaa","bbb","eee","ddd");
strlist.stream()
.sorted()
.foreach(system.out::println);
system.out.println("----------------------------------------");
employees.stream()
.sorted((e1,e2) -> {
if (e1.getage().equals(e2.getage())) {
return e1.getname().compareto(e2.getname());
} else {
return e1.getage().compareto(e2.getage());
}
})
.foreach(system.out::println);
}
以上就是深入理解java8新特性之stream api的创建方式和中间操作步骤的详细内容，更多关于java stream api的资料请关注其它相关文章！