Stream流
2022-05-03 本文已影响0人
开心的小哈
体验Stream
import java.util.ArrayList;
public class MyDemo {
public static void main(String[] args) {
//1.创建一个集合，存储多个字符串元素
//2.把集合中所有以张开头的元素存储到一个新集合
//3.把张开头的集合中长度为3的存储到新的集合中
//4.遍历上一步得到的集合
ArrayList<String> member = new ArrayList<>();
member.add("张曼玉");
member.add("张无忌");
member.add("张三");
member.add("离死ａｓｄｆ亡");
member.add("东北人");
//2.
ArrayList<String> zhangSt = new ArrayList<>();
for (String s:member
) {
if(s.startsWith("张")){
zhangSt.add(s);
}
}
System.out.println(zhangSt);
//3.n
ArrayList<String> lenth3 = new ArrayList<>();
for (String s:zhangSt
) {
if(s.length()>=3){
lenth3.add(s);
}
}
for (String d:lenth3
) {
System.out.println(d);
}
//上述步骤太复杂可以使用Stream流来代替
member.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
//filter传入条件的lambda
//最后使用forEach函数进行消费
}
}
Stream流生产方式
生成流
list.stream()
中间操作
filter()
终结操作
forEach()
集合中的Stream流使用
1.collection体系的集合可以使用系统默认方法stream()生成流
default Stream<E> stream()
2.map体系的集合间接的生成流
3.数组可以通过Stream接口的静态方法of(T..value)生成流
import java.util.*;
import java.util.stream.Stream;
public class MyDemo {
public static void main(String[] args) {
// 1.collection体系的集合可以使用系统默认方法stream()生成流
// default Stream<E> stream()
// 2.map体系的集合间接的生成流
// 3.数组可以通过Stream接口的静态方法of(T..value)生成流
//1.
List<String> member = new ArrayList<>();
member.add("张曼玉");
member.add("张无忌");
member.add("张三");
member.add("离死ａｓｄｆ亡");
member.add("东北人");
Stream<String> stream = member.stream();
Set<String> set = new HashSet<>();
Stream<String> stream1 = set.stream();
//2.
HashMap<String, Integer> stringIntegerHashMap = new HashMap<>();
Stream<String> stream2 = stringIntegerHashMap.keySet().stream();//得到键的stream流
Stream<Integer> stream3 = stringIntegerHashMap.values().stream();//得到值的流
Set<Map.Entry<String, Integer>> entries = stringIntegerHashMap.entrySet();//得到键值对象的流
//3.
String [] stray={"hello","java"};
Stream<String> stray1 = Stream.of(stray);
Stream<String> hello = Stream.of("hello", "java");
}
}
filter方法
import java.util.*;
import java.util.stream.Stream;
public class MyDemo {
public static void main(String[] args) {
// 1.collection体系的集合可以使用系统默认方法stream()生成流
// default Stream<E> stream()
// 2.map体系的集合间接的生成流
// 3.数组可以通过Stream接口的静态方法of(T..value)生成流
//1.
List<String> member = new ArrayList<>();
member.add("张曼玉");
member.add("张无忌");
member.add("张三");
member.add("离死ａｓｄｆ亡");
member.add("东北人");
member.stream().filter((String s)->{return s.startsWith("张");}).forEach(System.out::println);
member.stream().filter((String s)->{return s.length()==3;}).forEach(System.out::println);
member.stream().filter((String s)->{return s.length()==3;}).filter((String s)->{return s.startsWith("张");}).forEach(System.out::println);
}
}
limit方法:返回此流中的元素组成的流,截取前指定参数个数的数据
skip方法:跳过指定参数个数的数据,返回有盖流的剩余元素组成的流
import java.util.*;
import java.util.stream.Stream;
public class MyDemo {
public static void main(String[] args) {
// 1.collection体系的集合可以使用系统默认方法stream()生成流
// default Stream<E> stream()
// 2.map体系的集合间接的生成流
// 3.数组可以通过Stream接口的静态方法of(T..value)生成流
//1.
List<String> member = new ArrayList<>();
member.add("张曼玉");
member.add("张无忌");
member.add("张三");
member.add("离死ａｓｄｆ亡");
member.add("东北人");
//需求1取前三个显示
member.stream().limit(3).forEach(System.out::println);
System.out.println("--------------");
//跳过三个元素把剩下的在控制台暑促
member.stream().skip(3).forEach(System.out::println);
System.out.println("---------------");
//需求三跳过前两个把剩下的前两个输出
member.stream().skip(2).limit(2).forEach(System.out::println);
}
}
//concat 合并a和B两个流为一个流
//disinct 返回由该流的不同元素，组成的流
import java.util.ArrayList;
import java.util.stream.Stream;
public class Testjava {
//concat 合并a和B两个流为一个流
//disinct 返回由该流的不同元素，组成的流，里面运用了equse进行了判断，将重复的只取一个
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("林檎下");
mamber.add("San Zhang");
mamber.add("tangbohu");
mamber.add("shenlongshi");
mamber.add("ChengLong Yan");
mamber.add("San Zhang");
mamber.add("San Zhang");
//去前四个数组组成一个流
Stream<String> s1 = mamber.stream().limit(4);
//跳过两个数据组成一个流
Stream<String> s2 = mamber.stream().skip(2);
//合并1和2得到的流，并把结果输出控制台
// Stream.concat(s1,s2).forEach(System.out::println); //concat处理后在使用时会报错
//合并1和2得到的流，并把结果输出，要求不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);
}
}
/*
sored返回由此流的元素组成的流，根据自然顺序排序
sored返回该流的元素组成的流，根据提供的comparator进行排序
*/
import java.util.ArrayList;
import java.util.stream.Stream;
public class Testjava {
/*
sored返回由此流的元素组成的流，根据自然顺序排序
sored返回该流的元素组成的流，根据提供的comparator进行排序
*/
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("林檎下");
mamber.add("San Zhang");
mamber.add("tangbohu");
mamber.add("shenlongshi");
mamber.add("ChengLong Yan");
mamber.add("San Zhang");
mamber.add("San Ahang");
//按照字母顺序进行排序输出
// mamber.stream().sorted().forEach(System.out::println);
//按照字符串长度进行排序输出
// mamber.stream().sorted((s1,s2)->s2.length()-s1.length()).forEach(System.out::println);
mamber.stream().sorted((s1,s2)->{
int num=s1.length()-s2.length();
int num2=num==0?s1.compareTo(s2):num;//compareTo字符串排完序后再使用compareTo进行排序
return num2;
}).forEach(System.out::println);
}
}
/*
map返回由给定函数应用于此流的元素结果组成的流
mapToint返回一个intStream其中包含将给定函数应用于此流的元素的结果,然后就可以使用intStream的方法啦
*/
import java.util.ArrayList;
import java.util.stream.Stream;
public class Testjava {
/*
map返回由给定函数应用于此流的元素结果组成的流
mapToint返回一个intStream其中包含将给定函数应用于此流的元素的结果,然后就可以使用intStream的方法啦
*/
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("10");
mamber.add("20");
mamber.add("35");
mamber.add("2");
//将集合中的字符串数据转换为整数之后在控制台输出
// mamber.stream().map(Integer::parseInt).forEach(System.out::println);
//
mamber.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
int sum = mamber.stream().mapToInt(Integer::parseInt).sum();
System.out.println(sum);
//sum 是IntStream中的
}
}
/*
ForEach对此流的每个元素执行操作
count()返回此流中的元素数
*/
import java.util.ArrayList;
import java.util.stream.Stream;
public class Testjava {
/*
ForEach对此流的每个元素执行操作
count()返回此流中的元素数
*/
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("林檎下");
mamber.add("San Zhang");
mamber.add("tangbohu");
mamber.add("shenlongshi");
mamber.add("ChengLong Yan");
mamber.add("San Zhang");
mamber.add("San Ahang");
//把集合中的元素在控制台输出
mamber.stream().forEach(System.out::println);
//统计集合由几个以张开头的元素，并把统计结果在控制台输出
long san = mamber.stream().filter(s -> s.startsWith("San")).count();
System.out.println(san);
}
}
text
import java.util.ArrayList;
import java.util.stream.Stream;
public class Testjava {
/*
*/
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("周润发");
mamber.add("成龙");
mamber.add("吴京");
mamber.add("刘德华");
mamber.add("李连杰");
mamber.add("周星驰");
mamber.add("飞虎队");
ArrayList<String> womanList = new ArrayList<String>();
womanList.add("林青霞");
womanList.add("张曼玉");
womanList.add("刘岩");
womanList.add("林心如");
womanList.add("贾玲");
womanList.add("王祖贤");
//男演员只要名字为3的前三人
Stream<String> manStream = mamber.stream().filter(s -> s.length() == 3).limit(3);
//女演员只要姓林的并且不要第一个
Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
//把过滤后的两个流合并在一起
Stream<String> concat = Stream.concat(manStream, womanStream);
// concat.map(Actor::new).forEach(System.out::println);
concat.map(s->new Actor(s)).forEach(s-> System.out.println(s.getName()));
}
}
Stream收集方法
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Testjava {
public static void main(String[] args) {
//创建一个集合存储多个字符串
ArrayList<String> mamber = new ArrayList<String>();
mamber.add("周润发");
mamber.add("成龙");
mamber.add("吴京");
mamber.add("刘德华");
mamber.add("李连杰");
mamber.add("周星驰");
mamber.add("飞虎队");
//的带名字为3个字的流
Stream<String> stringStream = mamber.stream().filter(s -> s.length() == 3);
List<String> collect = stringStream.collect(Collectors.toList());
for (String ss:collect){
System.out.println(ss);
}
Set<Integer> integers = new HashSet<>();
integers.add(10);
integers.add(20);
integers.add(30);
integers.add(40);
integers.add(50);
//得到年龄大于25的流
Stream<Integer> integerStream = integers.stream().filter(age -> age > 25);
//得到stream流操作完毕的数据收集到set集合中并遍历
Set<Integer> collect1 = integerStream.collect(Collectors.toSet());
for(Integer ss:collect1){
System.out.println(ss);
}
String star[]={"林檎下，20","张曼玉，50","柳岩，25"};
//得到字符串年龄数据大于28的流
Stream<String> stringStream1 = Stream.of(star).filter(s -> Integer.parseInt(s.split("，")[1]) > 28);
Map<String, Integer> collect2 = stringStream1.collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));
Set<String> strings = collect2.keySet();
for (String key:strings
) {
Integer value=collect2.get(key);
System.out.println(key+","+value);
}
}
}
