Stream流
体验Stream流
创建一个集合，存储多个字符串元素
1.把集合中所有以"张"开头的元素存储到一个新的集合
2.把"张"开头的集合中的长度为3的元素存储到一个新的集合
3.遍历新的集合
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("林青霞");
str.add("张曼玉");
str.add("王祖贤");
str.add("柳岩");
str.add("张敏");
str.add("张无忌");
//把集合中所有以"张"开头的元素存储到一个新的集合
ArrayList<String> zhang = new ArrayList<>();
for(String s:str){
if(s.startsWith("张")){
zhang.add(s);
}
}
//把"张"开头的集合中的长度为3的元素存储到一个新的集合
ArrayList<String> newarr = new ArrayList<>();
for(String s:zhang){
if(s.length()==3){
newarr.add(s);
}
}
//遍历集合
for(String s:newarr){
System.out.println(s);
}
System.out.println("----更优雅的方法----");
//stream流来改写
//将集合生成流
str.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
//用方法引用改进
str.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
}
使用Stream流的方式完成过滤操作
- list.stream().filter(s->s.startWith(“张”)).filter(s->s.length==3).forEach(System.out.println(s));
- 直接阅读代码的字面意思即可完美展示无关逻辑的语义：生成流，过滤姓张，过滤长度为3，逐一打印
- stream流把真正的函数式编程风格引入到Java中
stream流的使用
-
生成流
通过数据源（集合，数组等）生成流//list.stream
-
中间操作
一个流后面可以跟随零个或多个中间操作，其主要目的是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流交给下一个操作使用//filter（）
-
终结操作
一个流只能有一个终结操作，当这个操作执行后，流就被使用‘光’了，无法在操作，所以这必定是流的最后一个操作//forEach()
Stream流的生成方式
Stream流的常见生成方式
- Collection体系的集合可以使用默认方法stream()生成流
- Map体系的集合间接生成流
- 数组可以通过stream接口的静态方法of(T…values)生成流
public static void main(String[] args) {
//Collection体系的集合可以使用默认方法stream()生成流
Set<String> set=new HashSet<String>();
Stream<String> setstream = set.stream();
List<String> list=new ArrayList<String>();
Stream<String> liststream = list.stream();
//Map体系的集合间接生成流
Map<String,Integer> map=new HashMap<String,Integer>();
Stream<String> mapkeystream = map.keySet().stream();//通过键的集合生成流
Stream<Integer> mapvaluestream = map.values().stream();//通过值的集合生成流
Stream<Map.Entry<String, Integer>> mapEntrysetstream = map.entrySet().stream();//通过键值对的集合生成流
//数组可以通过stream接口的静态方法of(T..values)生成流
int[]a={123,32,23,43,45,32,234};
String []aa={"java","hello","world"};
Stream<int[]> astream = Stream.of(a);
Stream<String> aastream = Stream.of(aa);
Stream<Integer> integerStream = Stream.of(12, 34, 435, 234, 634);
Stream<String> StringStream = Stream.of("hello", "java");
}
Stream流的常见中间操作方法
-
Streamfilter (Predicate pre):对于流中的数据进行过滤
Predicate接口中的方法：boolean test(T t):对给定的参数进行判断，返回一个布尔值
-
Streamlimit(long maxsize):返回此流中的元素组成的流，截取前指定参数个数的数据
-
Streamskip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
-
static Stream concat(Stream a,Stream b):合并ab两个流为一个流//注意，这是一个静态方法！需要用接口名Stream调用
-
Stream distinct():去掉该流的重复数据
-
Stream**sorted()😗*返回由此流的元素组成的流，根据自然顺序排序
-
Streamsorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
-
Streammap(Function mapper):返回由给定函数应用与此流的元素的结果组成的流
Function接口中的方法 R apply(T t)
-
intStream mapTolnt(TolntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流元素的结果
IntStream : 表示原始int流
ToIntFunction接口中的方法 int applyAsInt(T value)
-
Stream filter
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("林青霞");
str.add("张曼玉");
str.add("王祖贤");
str.add("柳岩");
str.add("张敏");
str.add("张无忌");
//把集合中所有以"张"开头的元素在控制台输出
str.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
System.out.println("--------");
//把"张"开头的集合中的长度为3的元素在控制台输出
str.stream().filter(s->s.length()==3).forEach(System.out::println);
System.out.println("--------");
//把"张"开头的集合中的长度为3的元素在控制台输出
str.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
}
skip&limit
简单来说skip就是跳过从第一数的几个数据。limit是只作用从第一个开始的数据
public class Streamdemo1 {
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("林青霞");
str.add("张曼玉");
str.add("王祖贤");
str.add("柳岩");
str.add("张敏");
str.add("张无忌");
//将前三个数据在控制台输出
str.stream().limit(3).forEach(System.out::println);
System.out.println("--------");
//跳过三个数据，把剩下的数据输出
str.stream().skip(3).forEach(System.out::println);
System.out.println("--------");
//跳过两个元素，把剩下的元素中前两个在控制台输出
str.stream().skip(2).limit(2).forEach(System.out::println);
}
}
concat&distinct
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("林青霞");
str.add("张曼玉");
str.add("王祖贤");
str.add("柳岩");
str.add("张敏");
str.add("张无忌");
//取前四个数据组成一个流
Stream<String> s1 = str.stream().limit(4);
//跳过前两个数据组成一个流
Stream<String> s2 = str.stream().skip(2);
//合并前面两个流并将结果输出
// Stream.concat(s1,s2).forEach(System.out::println);
System.out.println("--------");
//合并前面两个流并将结果输出，要求元素不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);
//注意 一个程序中出现两个concat会报错！！
//因为 流只能运行（调用中间或终端流操作）一次
}
sorted
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("linqingxia");
str.add("zhangmanyu");
str.add("wangzuxian");
str.add("liuyan");
str.add("zhangmin");
str.add("zhangwuji");
//按照字母顺序把数据在控制台输出
str.stream().sorted().forEach(System.out::println);
//按照字符长度将数据在控制台输出
str.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(s -> System.out.println(s));
}
//(s1,s2)->s1.length()-s2.length()是一个比较器
map&&mapToInt
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("199");
str.add("100");
str.add("234");
str.add("36");
str.add("64");
str.add("97");
//将数组中的字符串转换为整数数据，并在控制台输出
str.stream().map(Integer::parseInt).forEach(System.out::println);
int sum = str.stream().mapToInt(Integer::parseInt).sum();
//当流调用mapToInt()方法后就会返回IntStream流，就可以使用IntStream中特有的方法
System.out.println(sum);
}
}
Stream流的常见终结操作方法
Stream流的常见终结操作方法
-
viod forEach(Consumer action):对此流的每个元素执行操作
Consumer接口中的方法void accept （Tt):对给定的参数执行此操作
-
long count():返回此流中的元素数
Stream流的收集操作
流的操作之后还是流的形式，但是流的收集操作之后就把流中的数据给写入到了集合里
Stream流的收集方法
- R collect(Collector collector)
- 这个收集方法的参数是一个Collector接口
工具类Collector提供了具体的收集方式
public static Collector toList():把元素收集到List集合中
public static Collector toSet():把元素收集到Set集合中
public static Collector toMap(Function KeyMapper,Function valueMapper):把元素收集到Map集合中
public class Streamdemo5 {
public static void main(String[] args) {
ArrayList<String> str=new ArrayList<String>();
str.add("林青霞");
str.add("张曼玉");
str.add("王祖贤");
str.add("柳岩");
str.add("张敏");
str.add("张无忌");
//得到名字为三个字的流
Stream<String> stringStream = str.stream().filter(s -> s.length() == 3);
//把使用Stream流操作完毕的数据收集到List集合中并遍历
stringStream.collect(Collectors.toList()).forEach(System.out::println);
System.out.println("---------");
//创建Set对象
Set<Integer> set=new HashSet<Integer>();
set.add(10);
set.add(30);
set.add(20);
set.add(50);
set.add(40);
//得到大于五的流
Stream<Integer> integerStream = set.stream().filter(s -> s > 25);
//将得到的流收集到Set集合中并遍历
integerStream.collect(Collectors.toSet()).forEach(System.out::println);
//定义一个字符串数组
String [] a= {"林青霞,39","王祖贤,34","张曼玉,40","柳岩,25"};
//得到年龄大于30的流
//Stream<String> a1 = Stream.of(a);
//a1.filter(s->s.split(",")[1]>30)
Stream<String> stream = Stream.of(a).filter(s -> Integer.parseInt(s.split(",")[1])>30);
//把得到流里面的数据收集到map集合中，名字作为键，年龄作为值
Map<String, Integer> collect = stream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
Set<String> set1 = collect.keySet();
for(String s:set1){
System.out.println("键："+s+"，值："+collect.get(s));
}
}
}
4218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
