java list stream 使用

时间：2025-04-17 08:17:09

1、遍历/匹配（foreach/find/match）

List<Integer> list = (7, 6, 9, 3, 8, 2, 1);  
// 遍历输出符合条件的元素  
().filter(x -> x > 6).forEach(::println);  
// 匹配第一个  
Optional<Integer> findFirst = ().filter(x -> x > 6).findFirst();  
// 匹配任意（适用于并行流）  
Optional<Integer> findAny = ().filter(x -> x > 6).findAny();  
// 是否包含符合特定条件的元素  
boolean anyMatch = ().anyMatch(x -> x < 6);

 2、筛选（filter）

// 筛选出Integer集合中大于7的元素
List<Integer> list = (6, 7, 3, 8, 1, 2, 9);  
Stream<Integer> stream = ();  
(x -> x > 7).forEach(::println);  
// 筛选员工中工资高于8000的人，并形成新的集合
List<String> fiterList = ().filter(x -> () > 8000).map(Person::getName).collect(());

3、聚合（max/min/count)

// 获取String集合中最长的元素 
List<String> list = ("adnm", "admmt", "pot", "xbangd", "weoujgsd");  
Optional<String> max = ().max((String::length));

// 获取Integer集合中的最大值
List<Integer> list = (7, 6, 9, 4, 11, 6);  
   // 自然排序  
   Optional<Integer> max = ().max(Integer::compareTo);  
   // 自定义排序  
   Optional<Integer> max2 = ().max(new Comparator<Integer>() {  
     @Override  
     public int compare(Integer o1, Integer o2) {  
       return (o2);  
     }  
  });

// 获取员工工资最高的人
Optional<Person> max = ().max((Person::getSalary));  
("员工工资最大值：" + ().getSalary());

//计算Integer集合中大于6的元素的个数
List<Integer> list = (7, 6, 4, 8, 2, 11, 9);  
long count = ().filter(x -> x > 6).count();

4、映射(map/flatMap)

// 英文字符串数组的元素全部改为大写
  String[] strArr = { "abcd", "bcdd", "defde", "fTr" };  
  List<String> strList = (strArr).map(String::toUpperCase).collect(());  

// 整数数组每个元素+3
  List<Integer> intList = (1, 3, 5, 7, 9, 11);  
  List<Integer> intListNew = ().map(x -> x + 3).collect(());

// 将员工的薪资全部增加1000
  // 返回新实体  
  List<User> list1 = ().map(item -> {  
   User user = new User((), 0, 0, null, null);  
   (() + 10000);  
   return user;  
  }).collect(()); 
  
  // 返回旧实体
  List<User> list2= ().map(item -> {  
   (() + 10000);  
   return item;  
  }).collect(());  

// 将两个字符数组合并成一个新的字符数组
 List<String> list = ("m,k,l,a", "1,3,5,7");  
 List<String> listNew = ().flatMap(item -> {  
   // 将每个元素转换成一个stream  
   String[] split = (",");  
   Stream<String> spilitStr = (split);  
   return spilitStr;  
 }).collect(());  

 //方式一
 Map<String, String> stringMap = ().collect((v -> (()), v -> ()));
 //方式二
 Map<Long, String> stringMap2 = ().collect((User::getId, Stu::getName));

 Map<Long,User> orderCarStoreInfoMap =  ().collect(
                (User::getId, item1 -> item1 ));
 
 //转换成map的时候，可能出现key一样的情况，如果不指定一个覆盖规则，上面的代码是会报错的。
 // 转成map的时候，最好使用下面的方式：

Map<Long,MerchantUserCupboard> cupboardMap = ().filter(Objects::nonNull).collect(
                (MerchantUserCupboard::getCupboardId, (), (var1, var2) -> var1));

 Map<Long, User> maps = ().collect((User::getId, (), (key1, key2) -> key2));
 
 Map<Long, String> maps1 = ().collect((User::getId, Stu::getName, (key1, key2) -> key2));
 
 //List 以ID分组 Map
 Map<Long, List<User>> groupBy = ().collect((User::getId));

5、归约(reduce)

// 求Integer集合的元素之和、乘积和最大值  
List<Integer> list = (1, 3, 2, 8, 11, 4);  
  // 求和方式1  
  Optional<Integer> sum = ().reduce((x, y) -> x + y);  
  // 求和方式2  
  Optional<Integer> sum2 = ().reduce(Integer::sum);  
  // 求和方式3  
  Integer sum3 = ().reduce(0, Integer::sum);  
    
  // 求乘积  
  Optional<Integer> product = ().reduce((x, y) -> x * y);  
  
  // 求最大值方式1  
  Optional<Integer> max = ().reduce((x, y) -> x > y ? x : y);  
  // 求最大值写法2  
  Integer max2 = ().reduce(1, Integer::max);  

// 求所有员工的工资之和和最高工资
  // 求工资之和方式1：  
  Optional<Integer> sumSalary = ().map(User::getSalary).reduce(Integer::sum);  
  // 求工资之和方式2：  
  Integer sumSalary2 = ().reduce(0, (sum, p) -> sum += (),  
    (sum1, sum2) -> sum1 + sum2);  
  // 求工资之和方式3：  
  Integer sumSalary3 = ().reduce(0, (sum, p) -> sum += (), Integer::sum);  
  
  // 求最高工资方式1：  
  Integer maxSalary = ().reduce(0, (max, p) -> max > () ? max : (),  
    Integer::max);  
  // 求最高工资方式2：  
  Integer maxSalary2 = ().reduce(0, (max, p) -> max > () ? max : (),  
    (max1, max2) -> max1 > max2 ? max1 : max2);

6、收集(collect)

// 归集(toList/toSet/toMap)
List<Integer> list = (1, 6, 3, 4, 6, 7, 9, 6, 20);  
  List<Integer> listNew = ().filter(x -> x % 2 == 0).collect(());  
  Set<Integer> set = ().filter(x -> x % 2 == 0).collect(());    
  Map<?, Person> map = ().filter(p -> () > 8000)  
    .collect((User::getName, p -> p));  

//统计(count/averaging)

// 求总数  
  Long count = ().collect(());  
  // 求平均工资  
  Double average = ().collect((User::getSalary));  
  // 求最高工资  
  Optional<Integer> max = ().map(User::getSalary).collect((Integer::compare));  
  // 求工资之和  
  Integer sum = ().collect((User::getSalary));  
  // 一次性统计所有信息  
  DoubleSummaryStatistics collect = ().collect((User::getSalary));  
  

// 分组(partitioningBy/groupingBy)

// 将员工按薪资是否高于10000分组  
        Map<Boolean, List<User>> part = ().collect((x -> () > 10000    ));  
        // 将员工按性别分组  
        Map<String, List<User>> group = ().collect((User::getSex));  
        // 将员工先按性别分组，再按地区分组  
        Map<String, Map<String, List<User>>> group2 = ().collect((User::getSex, (User::getArea)));  
   

//接合(joining)
String names = ().map(p ->()).collect((","));

List<String> list = ("A", "B", "C");  
String string = ().collect(("-"));  

//归约(reducing) 
  Integer sum = ().collect((0, Person::getSalary, (i, j) -> (i + j - 5000)));   
  
  Optional<Integer> sum2 = ().map(User::getSalary).reduce(Integer::sum);

7、排序(sorted)

// 按工资增序排序  
  List<String> newList = ().sorted((User::getSalary)).map(User::getName)  
    .collect(());  
  // 按工资倒序排序  
  List<String> newList2 = ().sorted((User::getSalary).reversed())  
    .map(User::getName).collect(());  
  // 先按工资再按年龄自然排序（从小到大）  
  List<String> newList3 = ().sorted((User::getSalary).reversed())  
    .map(User::getName).collect(());  
  // 先按工资再按年龄自定义排序（从大到小）  
  List<String> newList4 = ().sorted((p1, p2) -> {  
   if (() == ()) {  
    return () - ();  
   } else {  
    return () - ();  
   }  
  }).map(User::getName).collect(());

8、提取/组合

Stream<String> stream1 = (arr1);  
  Stream<String> stream2 = (arr2);  
  // concat:合并两个流 distinct：去重  
  List<String> newList = (stream1, stream2).distinct().collect(());  
  // limit：限制从流中获得前n个数据  
  List<Integer> collect = (1, x -> x + 2).limit(10).collect(());  
  // skip：跳过前n个数据  
  List<Integer> collect2 = (1, x -> x + 2).skip(1).limit(5).collect(());

1、实现List对象集合的简单去重（distinct()） ​

List<User> list = ().distinct().collect(());

 ​2、实现List集合的根据属性（name）去重

list = ().filter(o -> () != null).collect( ((() -> new TreeSet<>((o -> ()))),ArrayList<Aoo>::new));

3、实现List对象集合的简单过滤（过滤为 null 的对象）

List<User> list = ().filter(item -> item != null).collect(());

4、实现List对象集合中获取其中某一属性的List集合

List<String> collect = ().map(User::getName).collect(());

5、 现List对象集合中根据对象的某一属性进行分组

Map<String, List<User>> userMap = ().collect((User :: getName));

6、实现List对象集合中求和、最大、最小、平均的统计

Long sum = ().mapToLong(User::getAge).sum(); //和
Double max = ().mapToDouble(User::getAge).max(); //最大
Integer = ().mapToInt(User::getAge).min(); //最小
OptionalDouble average = ().mapToDouble(User::getAge).average(); //平均值

7、实现List对象集合的分页

List<User> resultList = ().skip(pageSize * (currentPage - 1)).limit(pageSize).collect(());

相关文章