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

浅浅的花香味﹌ 2023-07-24 09:05 5阅读 0赞

**何为流？  
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中文在线帮助文档][JDK8]

[JDK8]: http://www.matools.com/api/java8