streamAPI练习
Stream 不是集合元素，他不是数据结构，不会保存数据，它是有关算法和计算的。它更新一个高级的Iterator，
不会像以往的迭代器一样，它是隐式在内部进行遍历，是单向的，不可往复，数据只能遍历一次，遍历之后就没了，
就和流水从面前流过一样，一去而不复返。
而和迭代器不同的时，Stream可以并行化操作，迭代器只能命令式的，串行化操作。
顾名思义，当使用串行化方式去遍历时，每个item读完后再读下一次item。
而使用并行去遍历时，数据会被分成多个段，其中每个都是不同的线程中处理，然后将结果输出。
Stream的并行操作依赖与java7中引入的Fork/join框架来拆分任务和加速处理过程。
Stream的一大特点，数据源本身是可以无限的
一: 初入Stream
创建测试实体类
package bean;
public class userBean {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "userBean [name=" + name + ", age=" + age + "]";
}
public userBean(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public userBean() {
super();
}
}
对于流的操作，就像一条流水线，我们接收到原产品(源数据)，在流的过程中，我们对产品进行包装，筛选出不符合的产品，然后将其放入Collector容器中
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import bean.userBean;
/**
* 当流没有终止操作时，中间操作的语句不打印出来
* 多个中间操作可以连接起来形成一个流水线，除非流水线触发终止操作，否则中间操作不会执行任何的处理。
* 而在终止操作时一次性全部处理，称为"惰性求值或延迟加载"
* @Description:
* @author wulongwei
* @date 2018年9月12日 上午9:50:48
*/
public class streamAPI02 {
public static void main(String[] args) {
List user=Arrays.asList(
new userBean("wulongwei", 23),
new userBean("jack", 23),
new userBean("mkyong", 46));
//中间操作
Streamstr=user.stream().filter(x->{
System.out.println("中间操作");
return x.getAge()>23;
});
//终止操作
str.forEach(System.out::println);
}
}
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import bean.userBean;
/**
* forEach 该方法用于对Stream中的每个元素进行迭代操作
* map 该方法用于将每个元素映射到对应的结界上
* filter 该方法用于过滤满足条件的元素
* limit 该方法用于减少Stream的大小，相当于SQL中的分页
* skip(n)--调过元素，返回一个扔掉前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补
* 注意：当满足limit的条件后，之后的数据不再处理(limit(2)..找到了两个数据时，直接返回，不在处理后面的数据)
*
* sorted 该方法用于对Stream排序
* 1.自然排序(Comparable)
* 2.定制排序(Comparator)
* @Description:
* @author wulongwei
* @date 2018年9月11日 上午10:57:44
*/
public class demo01 {
public static void main(String[] args) {
List user=Arrays.asList(
new userBean("wulongwei", 23),
new userBean("jack", 23),
new userBean("mkyong", 46));
//forEach 使用forEach输出十个随机数
Random random=new Random();
random.ints().limit(10).forEach(System.out::println);
//skip(n)--调过元素，返回一个扔掉前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补
user.stream().filter(x->x.getAge()>20).skip(2).forEach(System.out::println);
//map 使用map输出某个数的平方 （去重后的）
List numbers=Arrays.asList(1,9,9,6,1,1,0,6);
List squarersList=numbers.stream().map(i->i*i).distinct().collect(Collectors.toList());
squarersList.forEach(System.out::println);
//filter 使用filter 过滤，计算出空字符串的数量
List strings=Arrays.asList(""," 1","aa"," ","w w");
long count=strings.stream().filter(string -> string.isEmpty()).count();
System.out.println(count);
//定制排序
user.stream().sorted((e1,e2)->{
if(e1.getAge()==e2.getAge()) {
return e1.getName().compareTo(e2.getName());
}else {
return e1.getAge().compareTo(e2.getAge());
}
}).forEach(System.out::println);;
}
}
streamAPI多条件筛选数据
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import bean.userBean;
/**
* @Description:
* @author wulongwei
* @date 2018年9月11日 上午10:49:40
*/
public class demo03 {
public static void main(String[] args) {
List user = Arrays.asList(
new userBean("wulongwei", 23),
new userBean("jack", 23),
new userBean("mkyong", 46));
// 单个条件
// 返回年龄是23岁的对象
List result = user.stream().filter(x -> 23 == x.getAge()).collect(Collectors.toList());
System.out.println(result);
// 返回名字叫jack的对象，如果没找到返回null
userBean result2 = user.stream().filter(x -> "jack".equals(x.getName())).findAny().orElse(null);
System.out.println(result2);
/**
* 多个条件
*/
userBean result3 = user.stream().filter(x -> "jack".equals(x.getName()) && 23 == x.getAge()).findAny()
.orElse(null);
System.out.println(result3);
userBean result4 = user.stream().filter(x -> {
if ("jack".equals(x.getName()) && 23 == x.getAge()) {
return true;
} else {
return false;
}
}).findAny().orElse(null);
System.out.println(result4);
/**
* map
*/
String name = user.stream().filter(x -> "jack".equals(x.getName())).map(userBean::getName).findAny().orElse("");
System.out.println(name);
//将用户名保存入一个集合并打印
List collect = user.stream().map(userBean::getName).collect(Collectors.toList());
collect.forEach(System.out::println);
Map map = user.stream().collect(Collectors.toMap(userBean::getName, userBean::getAge));
System.out.println(map);
}
}
并行处理 ParallelStream是Stream用于并行处理的一种替代方案
ParallelStream其实就是一个并行执行的流，它默认通过ForkJoinPool，提高你的多线程任务的速度
Collector 用于合并Stream的元素处理结果。它可以用于返回一个字符串列表，简单来说就是一种容器，接受处理完的数据
package stream;
/**
* 并行处理 ParallelStream是Stream用于并行处理的一种替代方案
* ParallelStream其实就是一个并行执行的流，它默认通过ForkJoinPool，提高你的多线程任务的速度
* Collector 用于合并Stream的元素处理结果。它可以用于返回一个字符串列表
* @Description:
* @author wulongwei
* @date 2018年9月11日 上午11:19:10
*/
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;
public class demo2 {
public static void main(String[] args) {
//ParallelStream 计算空字符的数量
List strings=Arrays.asList("","spring "," ajax","rb ac","mysql");
long count=strings.parallelStream().filter(x->x.isEmpty()).count();
System.out.println(count);
System.out.println("*********************************************");
//Collector
List filtered=strings.stream().filter(x-> !x.isEmpty()).collect(Collectors.toList());
filtered.forEach(System.out::println);
//Collector
System.out.println("*********************************************");
String mergedString=strings.stream().filter(x->!x.isEmpty()).collect(Collectors.joining(", "));
System.out.println(mergedString);
//统计工具
Listnumbers=Arrays.asList(1,2,2,1,4,2,3,5,7,6);
IntSummaryStatistics stats=numbers.stream().sorted().mapToInt((x) ->x).summaryStatistics();
System.out.println(stats.getMax());
System.out.println(stats.getMin());
System.out.println(stats.getSum());
System.out.println(stats.getAverage());
}
}