stream流的详细操作
文章目录
-
- 一、Stream概述
- 二、Stream的创建
- 三、Stream的操作符
-
- 中间操作符
-
-
- 1.filter
- 2.distinct
- 3.limit
- 4.skip
- 5.map
- 6.flatmap
- 7.sorted
-
- 终止操作符
-
-
- 1.anyMatch
- 2.allMatch
- 3.noneMatch
- 4.findAny
- 5.findFirst
- 6.forEach
- 7.collect
- 8.reduce
- 9.count
-
- Collectors的操作符
-
-
- 1.joining
- 2.summarizingInt
- 3.groupingBy
- 4.groupingBy+counting
- 5.partitioningBy
- 6.maxBy、minBy
- 7.summingInt、averagingInt
-
- **`重要`**
一、Stream概述
Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的 Lambda ，给我们操作集合（Collection）提供了极大的便利。
那么什么是Stream？
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。
二、Stream的创建
list.stream() //转换成流进行操作
三、Stream的操作符
stream的操作符可以分为两种：中间操作符和终止操作符
中间操作符
1.filter
/**
* 用于过滤不满足条件的元素
*/
@Test
public void filter(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg");
List<String> filtered = list.stream().filter(str -> str.contains("a")).collect(Collectors.toList());
System.out.println(filtered);
}
2.distinct
/**
* 用于去掉重复的元素
*/
@Test
public void distinct(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<String> distincted = list.stream().distinct().collect(Collectors.toList());
System.out.println(distincted);
}
3.limit
/**
* 用于获取前n个元素
*/
@Test
public void limit(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<String> limited = list.stream().limit(3).collect(Collectors.toList());
System.out.println(limited);
}
4.skip
/**
* 用于获取除前n个元素以外的所有元素
*/
@Test
public void skip(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<String> skiped = list.stream().skip(3).collect(Collectors.toList());
System.out.println(skiped);
}
5.map
/**
* 用于对所有元素进行集体的操作
*/
@Test
public void map(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<String> mapped = list.stream().map(str->"han Shen_"+str).collect(Collectors.toList());
System.out.println(mapped);
}
6.flatmap
/**
* 用于对所有元素进行扁平化的操作
*/
@Test
public void flatMap(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<Character> flatMaped = list.stream().flatMap(str -> javaStream.getCharacter(str)).collect(Collectors.toList());
System.out.println(flatMaped);
}
//创建了一个字符流转换的方法
public static Stream<Character> getCharacter(String str){
ArrayList<Character> list = new ArrayList<>();
for (Character character : str.toCharArray()) {
list.add(character);
}
return list.stream();
}
map和flatmap的区别：
7.sorted
/**
* 用于对所有元素进行以a到z顺序进行排序
*/
@Test
public void sorted(){
//---------------------------字母排序-------------------------------------
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
List<String> sorted = list.stream().sorted().collect(Collectors.toList());//正序
List<String> collect1 = list.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.US))).collect(Collectors.toList());
System.out.println(sorted);
System.out.println(collect1);
//---------------------------汉字排序-------------------------------------
List<String> list3 = Arrays.asList("吕布","刘备","阿斗","赵云","张辽","马超","法正");
List<String> sorted1 = list3.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());//正序
List<String> collect2 = list3.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
System.out.println(sorted1);
System.out.println(collect2);
//---------------------------数字排序-------------------------------------
List<Integer> list1 = Arrays.asList(1,5,9,54,33,-52,54);
List<Integer> collect = list1.stream().sorted().collect(Collectors.toList());//正序
Stream<Integer> sorted2 = list1.stream().sorted(Collections.reverseOrder());//反序
System.out.println(collect);
sorted2.forEach(s-> System.out.print(s+","));
}
终止操作符
1.anyMatch
/**
* 用于判断集合中是否有一个元素满足条件
*/
@Test
public void anyMatch(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
boolean a = list.stream().anyMatch(s -> s.contains("a"));
System.out.println(a);
}
2.allMatch
/**
* 用于判断集合中是否所有元素都满足条件
*/
@Test
public void allMatch(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
boolean a = list.stream().allMatch(s -> s.contains("a"));
System.out.println(a);
}
3.noneMatch
/**
* 用于判断集合中是否所有元素都不满足条件
*/
@Test
public void noneMatch(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
boolean a = list.stream().noneMatch(s -> s.length()>4);
System.out.println(a);
}
4.findAny
/**
* 用于返回集合中的任意元素
*/
@Test
public void findAny(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
for (int i=0;i<1000;i++){
Optional<String> any = list.parallelStream().findAny();
if (any.isPresent()) System.out.println(any.get());
}
}
5.findFirst
/**
* 用于返回集合中的第一个元素
*/
@Test
public void findFirst(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
Optional<String> first = list.stream().findFirst();
if (first.isPresent()) System.out.println(first.get());
}
6.forEach
/**
* 用于循环
*/
@Test
public void forEach(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
list.stream().forEach(s -> System.out.println(s));
}
7.collect
/**
* 用于将流转换成其他类型的数据：list，map，set
*/
@Test
public void collect(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
Set<String> collect = list.stream().collect(Collectors.toSet());
System.out.println(collect);
//-------------------------------------------------------------------
Map<String, Object> collect1 = list.stream().collect(Collectors.toMap(v -> "han_" + v, v -> v,(oldvalue, newvalue)->newvalue));
System.out.println(collect1);
}
8.reduce
/**
* 将流中的元素反复的结合起来得到一个结果
*/
@Test
public void reduce(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
Optional<String> reduce = list.stream().reduce((acc,item) -> {return (acc+item).replace("s","h");});
if(reduce.isPresent()) System.out.println(reduce.get());
}
9.count
/**
* 获取集合中元素的数量
*/
@Test
public void count(){
List<String> list = Arrays.asList("abc","sd","as","few","wth","dfg","as");
long count = list.stream().count();
System.out.println(count);
}
Collectors的操作符
1.joining
/*拼接*/
public static void join(){
List<User> list = users();
String names = list.stream()
.map(User::getName)
.collect(Collectors.joining(", "));
System.out.println(names);
}
2.summarizingInt
/*一次性得到元素的个数、总和、最大值、最小值*/
public static void allVlaue(){
List<User> list = users();
IntSummaryStatistics statistics = list.stream()
.collect(Collectors.summarizingInt(User::getAge));
System.out.println(statistics);
}
3.groupingBy
/*分组*/
public static void group(){
Map<Integer, List<User>> map = users().stream()
.collect(Collectors.groupingBy(User::getSex));
System.out.println(new Gson().toJson(map));
System.out.println();
Map<Integer, Map<Integer,List<User>>> map2 = users().stream()
.collect(Collectors.groupingBy(User::getSex,
Collectors.groupingBy(User::getAge)));
System.out.println(new Gson().toJson(map2));
}
4.groupingBy+counting
/*分组合计*/
public static void groupCount(){
Map<Integer, Long> num = users().stream()
.collect(Collectors.groupingBy(User::getSex, Collectors.counting()));
System.out.println(num);
Map<Integer, Long> num2 = users().stream()
.filter(user -> user.getAge()>=18)
.collect(Collectors.groupingBy(User::getSex, Collectors.counting()));
System.out.println(num2);
}
5.partitioningBy
/*分区*/
public static void partitioningBy(){
List<User> list = users();
Map<Boolean, List<User>> part = list.stream()
.collect(Collectors.partitioningBy(user -> user.getAge() <= 30));
System.out.println(new Gson().toJson(part));
}
6.maxBy、minBy
public static void max_min(){
List<User> list = users();
Optional<User> max = list.stream()
.collect(
Collectors.maxBy(
Comparator.comparing(User::getAge)
)
);
Optional<User> min = list.stream()
.collect(
Collectors.minBy(
Comparator.comparing(User::getAge)
)
);
System.out.println("max--> " + max+" min--> "+ min);
}
7.summingInt、averagingInt
/*求和_平均值*/
public static void sum_avg(){
List<User>list = users();
int totalAge = list.stream()
.collect(Collectors.summingInt(User::getAge));
System.out.println("totalAge--> "+ totalAge);
/*获得列表对象金额， 使用reduce聚合函数,实现累加器*/
BigDecimal totalMpney = list.stream()
.map(User::getMoney)
.reduce(BigDecimal.ZERO, BigDecimal::add);
System.out.println("totalMpney--> " + totalMpney);
double avgAge = list.stream()
.collect(Collectors.averagingInt(User::getAge));
System.out.println("avgAge--> " + avgAge);
}
重要
1.isPresent();
为了判断查询的类对象是否存在，采用此方法
.isPresent()一般与.get()方法合用，当optional中存在course时，optional.isPresent()值为true，通过get（）方法返回对象。
2.IntStream是存的是int类型的stream,而Steam是一个存了Integer的stream。boxed的作用就是将int类型的stream转成了Integer类型的Stream。
比如下面这段代码就是很好理解了：
List<Integer> numbers = Arrays.asList(1, 2, 3, 3, 4, 5);
IntStream intStream = numbers.stream().mapToInt(i -> i); //转成IntStream
Stream<Integer> boxed = intStream.boxed(); //转成Stream所以我们在用到这种原始int值的流,比如下面生成随机数的，得到IntStream在转成集合是不行的。会报错。
random.ints(0, 100).limit(10).collect(Collectors.toList());
所以我们一定要把它转成。Integer类型，像下面这种使用boxed转成了object类型
random.ints(0, 100).limit(10).boxed().collect(Collectors.toList());