常用方法 筛选与切片：
方法 |
作用 |
filter（Predicate p） |
接受一个lambda，从stream中按照要求得得到数据 |
limit(n) |
截断数据，是数据不要超过n个 |
skip(n) |
跳过元素，返回一个跳过的n个元素的stream，若不足n个返回一个空流。 |
distinct() |
通过元素的hashcode和equals去除重复元素 |
实体类
package com.example.demoTset2; import lombok.Data; @Data public class login { public String name; public String passWord; public String age; public login(String name, String passWord, String age) { super(); this.name = name; this.passWord = passWord; this.age = age; } }
filter 筛选
选出age为22的数组
package com.example.demoTset2; import java.util.Arrays; import java.util.List; import java.util.stream.Stream; public class Filter { static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); public static void main(String[] args) { Stream<login> loginRequestStream = login.stream().filter((e) -> "22".equals(e.getAge())); loginRequestStream.forEach(System.out::println); } }
运行结果为
login(name=李四, passWord=2222, age=22)
limit截断
static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); //limit截断: public static void main(String[] args) { login.stream() .filter((e) -> Integer.valueOf(e.getAge()) > 11) .limit(1)//需要几条数据 截几条 例如：1条就是1 .forEach(System.out::println); }
运行结果是
login(name=李四, passWord=2222, age=22)
skip 跳过:
static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); //skip 跳过 public static void main(String[] args) { login.stream() .filter((e) -> Integer.valueOf(e.getAge()) > 11) .skip(1)//跳过2条数据 下标0,1 .forEach(System.out::println); }
login(name=王五, passWord=3333, age=33) login(name=赵六, passWord=6666, age=66)
distinct 去重
static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); //distinct 去重 public static void main(String[] args) { login.stream() .filter((e) -> Integer.valueOf(e.getAge()) > 1) .distinct() .forEach(System.out::println); }
运行结果：
login(name=张三, passWord=1111, age=11) login(name=李四, passWord=2222, age=22) login(name=王五, passWord=3333, age=33) login(name=赵六, passWord=6666, age=66)
包含contains 两种实现方式：
static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); static List<login> login = Arrays.asList( new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("张三", "1111", "11"), new login("李四", "2222", "22"), new login("王五", "3333", "33"), new login("赵六", "6666", "66") ); public static void main(String[] args) { Stream<login> stream = login.stream(); stream.filter(t-> t.getName().contains("张三")).limit(3).forEach(System.out::println); System.out.println("-----------分割线-------"); stream = login.stream(); Stream<String> stream1= stream.map(t -> t.getName()); stream1.filter(t -> t.contains("张三")).forEach(System.out::println); }
运行结果为
login(name=张三, passWord=1111, age=11) login(name=张三, passWord=1111, age=11) login(name=张三, passWord=1111, age=11) -----------分割线------- 张三 张三 张三
映射
方法 |
映射 |
map(Function f) |
将函数作为要给参数，该函数会被应用到每一个元素上，产生一个新的DoubleStream。当然类似的还有：map ToLong（ToLongFunction f） ，mapToInt（ToIntFunction f） 等 |
flatMap(Function f) |
将一个函数作为参数，将流（stream）中的每个值都换成另一个流，然后把所有的流连接成 |
map 接受lambda,讲元素转成其他形式或提取信息,接受一个函数作为参数,该函数会被应用到每一个元素上,并将其映射成一个新的元素.
flagMap 接收一个函数作为参数,将流中的每一个值都转换成另一个流,然后把所有的流了解成一个流.
toUpperCase 转成大写
public static void main(String[] args) { List<String> list = Arrays.asList("aaa", "bbb","www","ccc", "ddd"); list.stream().map((str) -> str.toUpperCase()).forEach(System.out::println); }
输出结果
AAA BBB WWW CCC DDD
package com.example.demoTset2; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Stream; public class Test1 { // public static void main(String[] args) { // List<String> list = Arrays.asList("aaa", "bbb","www","ccc", "ddd"); // list.stream().map((str) -> str.toUpperCase()).forEach(System.out::println); // } public static void main(String[] args) { List<String> list=Arrays.asList("ab","cd","ef"); // 想要打印出 a b c d e f // 如果使用map Stream<String> stream=list.stream(); Stream<Stream<Character>> streamCs= stream.map(Test1::abc); streamCs.forEach(streamC-> streamC.forEach(System.out::println) ); System.out.println("-----------分割线-------"); // flatMap stream=list.stream(); //Stream<Character> 这个直接将里面的集合进行展开 Stream<Character> streamC=stream.flatMap(Test1::abc); streamC.forEach(System.out::println); } // 将字符串拆成一个字符 public static Stream<Character> abc(String str){ List list=new ArrayList<>(); for(Character c:str.toCharArray()) { list.add(c); } // 直接返回一stream 为了好操作 return list.stream(); } }
运行结果是
a b c d e f -----------分割线------- a b c d e f
排序
方法 |
作用 |
sorted() |
会生成一个新的流，将其按自然顺序排序 |
sorted(Comparator com ) |
会生成一个新的流，将其按比较其顺序排序 |
package com.example.demoTset2; import java.util.Arrays; import java.util.List; import java.util.stream.Stream; public class Test2 { public static void main(String[] args) { List<Integer> list= Arrays.asList(1,3,2,6,5,8); Stream<Integer> stream=list.stream(); Stream<Integer> stream1=stream.sorted(); stream1.forEach(System.out::println); System.out.println("-----------分割线-------"); stream=list.stream(); stream1=stream.sorted((o1,o2) -> Integer.compare(o2, o1) ); stream1.forEach(System.out::println); } }
运作结果是
1 2 3 5 6 8 -----------分割线------- 8 6 5 3 2
终止操作
匹配与查找
方法 |
作用 |
allMatch(Predicate p) |
检查是否匹配所有的元素,如果都满足返回true，哪怕一个不满足返回false |
anyMatch(Predicate p) |
检查是否至少匹配一个元素,如果有一个以及一个以上返回true，否则返回false |
noneMatch(Predicate p) |
检查是否没有匹配一个元素,哪怕一个满足返回false,否则返回true |
findFirst() |
返回最后一个元素,不过其返回的是一个Optional类 （这个后面补充） |
findAny() |
返回当前流中的任意元素，不过其返回的是一个Optional类 |
allMatch：检查是否匹配所有的元素,如果都满足返回true，哪怕一个不满足返回false
//检查是否匹配所有的元素,如果都满足返回true，哪怕一个不满足返回false public static void main(String[] args) { //值全部大于0 List<Integer> list=Arrays.asList(1,3,2); Stream<Integer> stream=list.stream(); boolean b=stream.allMatch(t -> t>0); System.out.println(b); System.out.println("-----------分割线-------"); //值全部大于2 stream=list.stream(); b=stream.allMatch(t -> t>2); System.out.println(b); }
运行结果是
true -----------分割线------- false
anyMatch：检查是否至少匹配一个元素,如果有一个以及一个以上返回true，否则返回false
/
/检查是否至少匹配一个元素,如果有一个以及一个以上返回true，否则返回false public static void main(String[] args) { List<Integer> list=Arrays.asList(1,3,2); Stream<Integer> stream=list.stream(); boolean b=stream.anyMatch(t -> t>0); System.out.println(b); System.out.println("-----------分割线-------"); stream=list.stream(); b=stream.anyMatch(t -> t>2); System.out.println(b); }
运行结果为
true -----------分割线------- true
noneMatch：检查是否没有匹配一个元素,哪怕一个满足返回false,否则返回true
//检查是否没有匹配一个元素,哪怕一个满足返回false,否则返回true public static void main(String[] args) { List<Integer> list=Arrays.asList(1,3,2); Stream<Integer> stream=list.stream(); boolean b=stream.noneMatch(t -> t>2); System.out.println(b); System.out.println("-----------分割线-------"); stream=list.stream(); b=stream.noneMatch(t -> t>5); System.out.println(b); }
运行结果为
false -----------分割线------- true
findFirst：返回最后一个元素,不过其返回的是一个Optional类
findAny：返回当前流中的任意元素，不过其返回的是一个Optional类
public static void main(String[] args) { List<Integer> list=Arrays.asList(1,3,2); Stream<Integer> stream=list.stream(); Optional<Integer> OP=stream.findFirst(); System.out.println(OP.get()); System.out.println("-----------分割线-------"); stream=list.stream(); OP=stream.findAny(); System.out.println(OP.get()); }
运行结果是
1 -----------分割线------- 1
整体demo实例：
allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
findFirst：返回流中第一个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最大值
min：返回流中元素最小值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); boolean allMatch = list.stream().allMatch(e -> e > 10); //false boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true Integer findFirst = list.stream().findFirst().get(); //1 Integer findAny = list.stream().findAny().get(); //1 long count = list.stream().count(); //5 Integer max = list.stream().max(Integer::compareTo).get(); //5 Integer min = list.stream().min(Integer::compareTo).get(); //1
归约
方法 |
作用 |
reduce(T identity, BinaryOperator accumulator) |
可以将流中元素反复结合起来，得到一个值，返回T（interface BinaryOperator extends BiFunction<T,T,T>） |
reduce( BinaryOperator accumulator) |
可以将流中元素反复结合起来，得到一个值，返回 Optional |
public static void main(String[] args) { List<Integer> list=Arrays.asList(1,3,2); // 把list中的值累加起来 Stream<Integer> stream=list.stream(); //为了方便理解 把这个初始值先写出来 Integer start=0; Integer sum=stream.reduce(start, Integer::sum); System.out.println(sum); System.out.println("-----------分割线-------"); stream=list.stream(); start=1; sum=stream.reduce(start, Integer::sum); System.out.println(sum); }
运行结果是
6 -----------分割线------- 7
