JAVA基础-Stream流(java进阶笔记)_java基础 stream(1)

文章目录

• 一、初识Stream流
• 二、 Stream流概述
• 三、Stream流的使用步骤
• • 1. 获取Stream流
    • • 1.1 单列集合
        • 1.2 双列集合
        • 1.3 数组
        • 1.4 零散数据
    • 2. Stream流的中间方法
    • 3. Stream流的终结方法
    • • collect方法：
• 四、 练习
• • 1. 数据过滤
    • 2. 数据操作 - 按年龄筛选
    • 3. 数据操作 - 演员信息要求筛选

java进阶所有笔记可以看这个哥们的

一、初识Stream流

通过下面代码，显然我们清晰的看到使用Stream流更为方便，而使用普通的集合遍历就有些复杂。

public class Test01 {
	public static void main(String[] args) {
		ArrayList<String> list1 = new ArrayList<>();
		list1.add("张无忌");
		list1.add("周正若");
		list1.add("赵斌");
		list1.add("张强");
		list1.add("张三丰");
 
		// Stream流
		list1.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3)
				.forEach(name -> System.out.println(name));
		// 张无忌
		// 张三丰
 
		// 1.把所有“张”姓开头元素存储到新集合
		ArrayList<String> list2 = new ArrayList<>();
		for (String name : list1) {
			if (name.startsWith("张")) {
				list2.add(name);
			}
		}
		System.out.println(list2); // [张无忌, 张强, 张三丰]
 
		// 2.把所有“张”姓开头且长度为3的元素存储到新集合
		ArrayList<String> list3 = new ArrayList<>();
		for (String name : list2) {
			if (name.length() == 3) {
				list3.add(name);
			}
		}
		System.out.println(list3); // [张无忌, 张三丰]
	}
}

二、 Stream流概述

例如上面的小例子，Stream流的思想如下：

Stream流的作用就是:

三、Stream流的使用步骤

结合了Lambda表达式，简化集合、数字的操作。

1. 先得到一条Stream流（流水线），并把数据放上去。
2. 使用中间方法对流水线上的数据进行操作。
3. 使用终结方法对流水线上的数据进行操作。

过滤、转换	中间方法	方法调用完毕之后，还可以调用其他方法
统计、打印	终结方法	最后一步，调用完毕之后，不能调用其他方法

1. 获取Stream流

获取方式	方法名	说明
单列集合	default Stream stream()	Collection中的默认方法
双列集合	无	无法直接使用stream流，需要通过keySet()或者entrySet()变成单列集合
数组	public static Stream stream(T[ ] array)	Arrays工具类中的静态方法
一堆零散数据	public static Stream of(T… values)	stream接口中的静态方法

1.1 单列集合

public class StreamTest {
	public static void main(String[] args) {
		//单列集合获取Stream流
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "a","b","c","d","e");
		//获取到一个流水线，并把集合中的数据方法流水线上
		//Stream<String> stream1 = list.stream();
		//使用终结方法打印流水线上数据
		//stream1.forEach( s ->System.out.println(s) );
		
		list.stream().forEach(s -> System.out.println(s));
	}
}

1.2 双列集合

public class StreamTest {
	public static void main(String[] args) {
		
		//双列集合获取Stream流 
		//1. 创建双列集合
		HashMap<String, Integer> hm = new HashMap<>();
		//2. 添加数据
		hm.put("aaa", 111);
		hm.put("bbb", 222);
		hm.put("ccc", 333);
		//3.1 获取Stream流方法一： keySet()
		//键
		 hm.keySet().stream().forEach(s -> System.out.println(s));
		//3.2 获取Stream流方法二：entrySet()
		 //键值对
		hm.entrySet().stream().forEach(s -> System.out.println(s));	 
	}
}

1.3 数组

Stream接口中静态方法of的细节：

• 方法的形参是一个可变参数，可以传递一堆零散数据，也可以传递数组。
• 但是数组必须是引用数据类型。
• 如果传递的是基本数据类型，是会把整个数组相当做一个元素，放到一个stream流当中。

public class StreamTest {
	public static void main(String[] args) {
		
		//数组获取Stream流 
		//1.创建基本数据类型数组
		int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
		//获取stream
		Arrays.stream(arr1).forEach(s -> System.out.println(s));
		
		//2.创建引用数据类型数组
		String[] arr2 = {"a","b","c"};
		//获取stream
		Arrays.stream(arr2).forEach(s -> System.out.println(s));
		
		//方式是错误的!!!
		//Stream接口中静态方法of的细节
		//方法的形参是一个可变参数，可以传递一堆零散数据，也可以传递数组
		//但是数组必须是引用数据类型
		//如果传递的是基本数据类型，是会把整个数组相当做一个元素，放到一个stream流当中
		Stream.of(arr2).forEach(s -> System.out.println(s));
		Stream.of(arr1).forEach(s -> System.out.println(s)); //[I@1b28cdfa
	}
}

1.4 零散数据

细节： 一堆零散数据需要是相同的数据类型。

public class StreamTest {
	public static void main(String[] args) {
		//零散数据获取Stream流 
		
		//基本数据类型
		Stream.of(1,2,3,4,5).forEach(s -> System.out.println(s));
		
		//引用数据类型
		Stream.of("a","b","c","d","e").forEach(s -> System.out.println(s));
	}
}

2. Stream流的中间方法

方法名称	说明
Stream filter ( Predicate<? super T> predicate )	过滤
Stream filter ( Predicate<? super T> predicate )	获取前几个元素
Stream skip ( long n )	跳过前几个元素
Stream distinct ( )	元素去重,依赖(hashCode和equals方法)
static Stream concat ( Stream a , Stream b )	合并a和b两个流为一个流
Stream map ( Function<T ,R> mapper )	转换流中的数据类型

注意一：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程。
注意二：修改Stream流中的数据，不会影响原来集合或者数组中的数据。

public class StreamTest01 {
	public static void main(String[] args) {
		//1.过滤:把开头的留下，其余数据过滤不要
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "张三","李四","王五","赵六","张七");
		
		ArrayList<String> list2 = new ArrayList<>();
		Collections.addAll(list2, "张三","李四","王五","赵六","张三");
		
		ArrayList<String> list3 = new ArrayList<>();
		Collections.addAll(list3, "孙七","钱八");
		
		ArrayList<String> list4 = new ArrayList<>();
		Collections.addAll(list2, "张三-23","李四-24","王五-25");
		
		list.stream().filter(new Predicate<String>() {
			//匿名内部类太麻烦 需要缩写
			@Override
			public boolean test(String s) {
				//如果返回值为true,表示当前数据留下
				//如果返回值为false,表示当前数据舍弃
				return s.startsWith("张");
				
			}
		}).forEach(s -> System.out.println(s)); //张三 张七
		
		list.stream()
		    .filter(s -> s.startsWith("张"))
		    .forEach(s -> System.out.println(s));
		
		//2. 获取前几个元素 
		list.stream()
		    .limit(3)
		    .forEach(s -> System.out.println(s));  //张三 李四 王五
		//3. 跳过
		list.stream()
		    .skip(4)
		    .forEach(s -> System.out.println(s));  //张七
		
		//4.去重
		list2.stream()
		     .distinct()
		     .forEach(s -> System.out.println(s)); //张三 李四 王五 赵六
		
		//5. 合并
		Stream.concat(list2.stream(), list3.stream())
		      .forEach(s -> System.out.println(s));
		
		//6.转换数据类型
		//只能获取集合里面的年龄并打印
		//第一个类型：流中原本的数据类型
		//第二个类型：将要转变成为的数据类型
		list4.stream().map(new Function<String,Integer>() {
			@Override
			//apply: 依次表示流中的每一盒数据
			//返回值：表示转化之前的数据
			public Integer apply(String s) {
				String[] arr = s.split("-");
				String ageString = arr[1];
				int age = Integer.parseInt(ageString);
				return age;
			}
		}).forEach(s -> System.out.println(s));
		
		list.stream()
		    .map(s ->Integer.parseInt(s.split("-")[1]))
		    .forEach(s -> System.out.println(s));
	}
}

3. Stream流的终结方法

方法名称	说明
void forEach ( Consumer action )	遍历
long count ( )	统计
toArray ( )	收集流中的数据，放到数组中
collect ( Collector collector )	收集流中的数据，放到集合中

public class StreamTest02 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "张三", "李四", "王五", "赵六");
 
		// 遍历
 
		// Consumer的泛型：表示流中的数据类型
		// accept方法的形参s：依次表示流中的每一个数据
		//
		list.stream().forEach(new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
#### 最后

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**
就答题情况而言，第一问100%都可以回答正确，第二问大概只有50%正确率，第三问能回答正确的就不多了，第四问再正确就非常非常少了。其实此题并没有太多刁钻匪夷所思的用法，都是一些可能会遇到的场景，而大多数人但凡有1年到2年的工作经验都应该完全正确才对。
只能说有一些人太急躁太轻视了，希望大家通过此文了解js一些特性。

并祝愿大家在新的一年找工作面试中胆大心细，发挥出最好的水平，找到一份理想的工作。