体验Stream流
创建集合,再通过对集合的筛选,得到我们想要的内容,下面是stream流的实现代码
import java.util.ArrayList;
public class ConsumerDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("aa");
list.add("ba");
list.add("ab");
list.add("abc");
//stream流 filter提限制条件 startsWith过滤开头字符 length过滤长度 //foreach输出过滤后的集合
list.stream().filter(s -> s.startsWith("a")).filter(s -> s.length()==2).forEach(System.out::println);
}
}
运行结果:
在体验中我们能感受到stream流的方便,原本复杂的代码通过stream可以非常简便的实现该功能。
Stream流常见生成方式
代码实现:
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
//stream流的常见生成方式
//1.Collection体系的集合可以使用默认方法
List<String> arrayList = new ArrayList<>();//List
Stream<String> stream1 = arrayList.stream();
Set<String> hashSet = new HashSet<String>();//Set
Stream<String> stream2 = hashSet.stream();
//2.Map体系的集合间接的生成
Map<String, Integer> hashMap = new HashMap<>();
Stream<String> stream3 = hashMap.keySet().stream();//String
Stream<Integer> stream4 = hashMap.values().stream();//Intger
Stream<Map.Entry<String, Integer>> stream5 = hashMap.entrySet().stream();
//3.数组可以通过Stream接口的静态方法of生成流
String[] ss = {"hello","world","java"};
Stream<String> ss1 = Stream.of(ss);
Stream<String> ss2 = Stream.of("hello", "world", "java");
Stream<Integer> ss3 = Stream.of(10, 10, 10);
}
}
Stream流的常见中间操作方法
下面是中间操作方法常见方法
1.filter
(
Predicate<? super
T> predicate)
返回由与此给定谓词匹配的此流的 元素组成的流。(filter中你可以规定条件,将其进行过滤)
2.limit
(long maxSize)
返回由此流的元素组成的流,截断长度不超过 maxSize
。
(截取前指定参数个数的数据)
3.skip
(long n)
在丢弃流的第一个 n
元素后,返回由此流的其余元素组成的流。
4.concat
(
Stream<? extends T> a,
Stream<? extends T> b)
创建一个延迟连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素。(合并a和b两个流为一个流)
5.distinct()
返回由此流的不同元素(根据 Object.equals(Object)
)组成的流。(去掉重复的元素)
6.sorted()
返回由此流的元素组成的流,按照自然顺序排序。
sorted
(
Comparator<? super
T> comparator)
返回由此流的元素组成的流,根据提供的 Comparator
进行排序。
7.map
(Function<? super T,
? extends R>
mapper)
返回一个流,该流包含将给定函数应用于此流的元素的结果。
mapToInt
(ToIntFunction<? super T> mapper)
返回 IntStream
其中包含将给定函数应用于此流的元素的结果。
8.forEach
(Consumer<? super T> action)
对此流的每个元素执行操作。
count()
返回此流中元素的数量。
下面是各方法的代码实现
1.filter
(
Predicate<? super
T>predicate)
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张五");
list.add("王小三");
list.add("李小二");
list.add("赵小四");
list.add("赵三");
//filter
//取“张”的姓,输出
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
System.out.println("............");
//名字长度为3的输出
list.stream().filter(s -> s.length()==3).forEach(System.out::println);
System.out.println("............");
}
运行结果:
2.limit
(long maxSize)
与
skip
(long n)
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张五");
list.add("王小三");
list.add("李小二");
list.add("赵小四");
list.add("赵三");
//limit 取前三个元素输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("............");
//skip 跳过前两个元素输出后面的
list.stream().skip(2).forEach(System.out::println);
System.out.println("............");
}
运行结果:
3.concat
(
Stream<? extends T>a,
Stream<?extends T>b)
和
distinct()
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张五");
list.add("王小三");
list.add("李小二");
list.add("赵小四");
list.add("赵三");
//concat 将limit和skip合并为一个流,输出
Stream<String> limit = list.stream().limit(3);
Stream<String> skip = list.stream().skip(2);
Stream.concat(limit,skip).forEach(System.out::println);
System.out.println("............ ");
//distinct 将limit和skip合并为一个流,最后输出
Stream.concat(limit,skip).distinct().distinct().forEach(System.out::println);
System.out.println("............");
}
运行结果:
我们可以发现,运行第二个是会报错,我们需要注意使用forEach语句使得该流结束了,不能被distinct调用。因此,我们可以把第一次注释掉。
将其注释
// Stream.concat(limit,skip).forEach(System.out::println);
运行结果得到第二个结果:
4.sorted()
和sorted
(
Comparator<? super
T>comparator)
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("fasfafasf");
list.add("dgsgsdg");
list.add("fasdfsaf");
list.add("vcxxgdfg");
list.add("ewttgfrefg");
list.add("afasj");
//sorted
//按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(System.out::println);
System.out.println("...........");
//按照字符串长度把数据在控制台输出
list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
}
运行结果:
5.map
(Function<? super T,
? extends R>
mapper)
和
mapToInt
(ToIntFunction<? super T>mapper)
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
//需求,将集合中的字符串数据转换为整数后在控制台输出
list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
System.out.println(".........");
list.stream().map(Integer::parseInt).forEach(System.out::println);
System.out.println(".........");
list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//返回一个总和
System.out.println(".........");
System.out.println(list.stream().mapToInt(Integer::parseInt).sum());
}
运行结果:
6.forEach
(Consumer<? super T>action)
和
count()
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张五");
list.add("王小三");
list.add("李小二");
list.add("赵小四");
list.add("赵三");
//统计集合中有几个姓张的元素,并输出在控制台
long cot = list.stream().filter(s->s.startsWith("张")).count();
System.out.println(cot);
}
运行结果: