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());
	}
}

 

你可能感兴趣的:(streamAPI练习)