Java8新特新之Stream流常用操作API

何为流？
JDK8给我们提供了一新概念—Stream流流遵守了“做什么而非做什么的原则”，在流的示例中，我们描述了需要做什么：获取长单词，并对他们计数。
流表面上看起来和集合很相似，都可以让我们转换获取数据。但是，他们之间存在显著的差异：

1、流并不存储其元素。
2、流的操作不会修改数据源，例如，filter方法不会改变原来的元素，而是会生成一个新的Stream流
3、流的操作是尽可能惰性执行，这意味着直至需要结果时，操作才会执行

操作流时的典型流程：
1、创建一个流
2、指定将初始流转化成其他流的中间操作，可能包含多个步骤
3、终止操作，从而产生结果。从此以后，这个流就不能再使用了

下面对Stream流常用API总结

1、filter（过滤，接收predicate函数接口，产生包含满足predicate的所有元素，内置consumer消费型接口）
基本格式：Stream<T> filter(Predicate<? super T> predicate)

/**
 *测试Stream<T> filter(Predicate<? super T> predicate)过滤 
 *在集合中找出姓张的人
 * @author 16003
 *
 */
public class Stream_filter {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		List<String> list2 = new ArrayList<>();	
		Collections.addAll(list, "张三丰","张无忌","姜子牙","张飞","奥特曼");
		//方法一，用Lamda表达式的函数式接口
		list2 = fun(list, str->{
			return str.startsWith("张");
			});
		System.out.println(list2);
		
		//方法二，用Stream流的filter方法过滤	
		Stream<String> stream3 = list.stream().filter(str->{return str.startsWith("张");});
		stream3.forEach(str->System.out.println(str));
		
	}
	
	//方法一,用lamda表达式的函数式接口
	public static List<String> fun(List<String> list,Predicate<String>cate){
		List<String> list1 = new ArrayList<>();
		for(String str:list) {
			if(cate.test(str)==true) {
				list1.add(str);
			}
		}
		return list1;
	}
}

2、limit（截断，截断前N个元素并返回一个新Stream流）
基本格式：Stream<T> limit(long maxSize)

/**
 * 测试Stream中limit方法 取前几个元素
 * @author 16003
 *
 */
public class Stream_limit {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		Collections.addAll(list, "红鲤鱼","绿鲤鱼","黄鲤鱼","驴");
		Stream<String> stream = list.stream().limit(3);
		stream.forEach(str->System.out.println(str));
	}
}

3、map（映射，对元素进行映射，返回映射后的新Stream流，内置Function<T ,R>接口）
基本格式：<R> Stream<R> map(Function<? super T,? extends R> mapper)

/**
 * 测试Stream中的map<Function<T t> mapper>方法
 * @author 16003
 *
 */
public class Stream_map {
	public static void main(String[] args) {
		//将字符串转换成Integer
		Stream<String> stream = Stream.of("1","2","3","4");
		Stream<Integer> stream1 = stream.map((String str)->{
			return Integer.parseInt(str);
		});
		
		stream1.forEach(str->System.out.println(str.getClass().getSimpleName()));
		
		
	}
}

4、skip（跳过，跳过前N个元素，并返回一个新的Stream流）
基本格式：Stream<T> skip(long n)

/**
 * 测试Stream中skip方法 跳过前几个元素
 * @author 16003
 *
 */
public class Stream_skip {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		Collections.addAll(list, 1,2,3,4,5,6,7,8,9);
		//跳过前三个元素
		Stream<Integer> stream = list.stream().skip(3);
		stream.forEach(str->System.out.println(str));
	}
}

5、count（返回此流中元素的数量）
基本格式：long count()

/**
 * 测试Stream中count方法 返回流中元素个数
 * @author 16003
 *
 */
public class Stream_count {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<>();
		Collections.addAll(list, 1,2,3,4,5,6,7,8,9,0);
		Stream<Integer> stream = list.stream();
		long cnt = stream.count();
		System.out.println(cnt);
	}
}

6、forEach（对此流的每个元素执行操作）
基本格式：void forEach(Consumer<? super T> action)

/**
 * Stream中Foreach方法 遍历
 * @author 16003
 *
 */
public class Stream_foreach {
	public static void main(String[] args) {
		Stream<String> stream = Stream.of("张三","李四","王五");
		stream.forEach(name -> System.out.println(name));
	}
}

其他API查看帮助文档：JDK8中文在线帮助文档

Java8新特新之Stream流常用操作API

猜你喜欢