【Java寒假打卡】Java基础-流Stream
初体验
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.List;
public class test6 {
public static void main(String[] args) {
// 集合的批量添加
ArrayList<String> list1 = new ArrayList<>(List.of("张三","张大宝","张伟"));
// 将f开头的字符串 添加到集合当中
ArrayList<String> list2 = new ArrayList<>();
// 增强for循环
for(String i:list1){
// 看该字符串是不是f开头
if(i.startsWith("张"))
{
list2.add(i);
}
}
// 使用Stream流
list1.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s-> System.out.println(s));
}
}
Stream流三类方法
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.stream.Stream;
public class test7 {
public static void main(String[] args) {
method1();// 单列集合
method2();// 双列集合
method3();// 数组
}
private static void method3(){
int[] arr = {1,2,3,4,5};
Arrays.stream(arr).forEach(s-> System.out.println(s));
}
private static void method2(){
// 双列集合
HashMap<String,Integer> hm = new HashMap<>();
hm.put("张三",23);
hm.put("李四",23);
hm.put("王五",112);
// 双列集合不能直接获取Stream流
// 先获取所有的键 然后再把这个Set集合中所有的键 都放到Stream流
hm.keySet().stream().forEach(s-> System.out.println(s));
// entrySet集合 先获取到所有的键值对 对象
// 再把这个Set集合中所有的键值对对象放到Stream流中
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
private static void method1(){
ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Stream<String> stream = list.stream();// 单列集合获取Stream流
stream.forEach(s-> System.out.println(s));
list.stream().forEach(s-> System.out.println(s));
}
}
中间方法filter
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.function.Predicate;
public class test8 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("张一鸣");
// 过滤 使用匿名內部类实现 实现Predicate接口进行实现 只接受张
list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
boolean result = s.startsWith("张");
return result;
}
}).forEach(s-> System.out.println(s));
// 使用lambda表达式进行实现
list.stream().filter((String s)->{
boolean result = s.startsWith("张");// 保留以张开头的字符串
return result;
}).forEach(s-> System.out.println(s));
// 简化
list.stream().filter(s->s.startsWith("张"));
}
}
常用中间方法
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.stream.Stream;
public class test9 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张伟");
list.add("张大炮");
list.add("谢广坤");
// 截取指定参数个数的数据
list.stream().limit(2).forEach(s-> System.out.println(s));// 只输出前两个集合元素
// 跳过前两个元素输出
list.stream().skip(2).forEach(s-> System.out.println(s));
ArrayList<String> list1 = new ArrayList<>();
list1.add("张三");
list1.add("张伟");
list1.add("张大炮");
list1.add("谢广坤");
Stream<String> stream1 = list.stream();// 获取第一个流
Stream<String> stream2 = list.stream();// 获取第二个流
Stream<String> stream3 = Stream.concat(stream1,stream2);// 合并两个流
stream3.forEach(s-> System.out.println(s));
// 去除流中重复的数据
list.stream().distinct().forEach(s-> System.out.println(s));
}
}
Stream流中常见的终结操作
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class test9 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张伟");
list.add("张大炮");
list.add("谢广坤");
// 在forEach方法的底层 会循环获取流中的每一个数据 并循环调用accept方法 将每一个数据传递给accept方法
// 匿名內部类:实现Consumer String 泛型接口
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// 使用lambda表达式进行简化
list.stream().forEach((String s)->{
System.out.println(s);
});
// lambda表达式只有一个参数的时候 可以进一步进行简化
list.stream().forEach(s-> System.out.println(s));
// 打印流中元素的个数
long count = list.stream().count();
System.out.println(count);
}
}
注意:Stream流的操作是没有办法直接修改集合中的数据
输出集合中的所有偶数
package com.hfut.edu.test8;
import java.util.ArrayList;
public class test10 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add(i + 1);
}
// 使用lambda表达式进行过滤
list.stream().filter((Integer i)->{
return i % 2 == 0;// 只保留偶数
}).forEach(s-> System.out.println(s));
// 使用简化之后的lambda表达式进行过滤
list.stream().filter(number->number % 2 == 0).forEach(s-> System.out.println(s));
}
}
Stream流中收集操作toList和toSet
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class test10 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add(i + 1);
}
// filter负责过滤数据
// collect负责收集数据 调用静态方法
List<Integer> collect = list.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());
System.out.println(collect);
Set<Integer> collect1 = list.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());// 不可重复的集合
System.out.println(collect1);
}
}
Stream流的收集方法toMap
package com.hfut.edu.test8;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
public class test11 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");
Map<String,Integer> m = list.stream().filter(s->{
String[] split = s.split(",");// 使用,进行分割
int age = Integer.parseInt(split[1]);// 将年龄字符串转换成整数
return age >= 24;
}).collect(Collectors.toMap(
// 第一个lambda表达式就是如何获取到Map中的键
// 第二个lambda表达式就是获取Map中的值
(String s)->{
return s.split(",")[0];// 获取键
},
(String s)->{
// 首先分割 然后去除第二个元素字符串 使用Integer.parseInt将字符串转换成整数
return Integer.parseInt(s.split(",")[1]);
}
));
System.out.println(m);
}
}