关于Java8新特性Stream流的集合操作

文章目录

中间操作符

filter

  • 1.过滤条件,获取满足条件的数据
     List<String> strings = Arrays.asList("aaa","bbb","ccc");
        List<String> filter = strings.stream().filter(str-> str.contains("aaa")).collect(Collectors.toList());
        System.out.println(filter);
  • 输出:在这里插入图片描述
  • 2.过滤条件,去除符合某种情况的数据,false表示丢弃,true表示保留
  Person person = new Person("1", 1);
        Person person2 = new Person("1", 2);
        Person person3 = new Person("1", 3);
        Person person4 = new Person("1", 4);
        Person person5 = new Person("1", 5);
        List<Person> list = new ArrayList<>();
        list.add(person);
        list.add(person2);
        list.add(person3);
        list.add(person4);
        list.add(person5);
        Map<Integer, List<Person>> collect = list.stream().filter(e -> {
            if (e.getAge().equals(2)) {
                return false;
            }
            if (e.getAge().equals(3)) {
                return false;
            }
            return true;
        }).collect(Collectors.groupingBy(Person::getAge));

        System.out.println(collect);

在这里插入图片描述

  • 3.去重然后排序, 去重enterpriseVO的id相同的数据 ,并且按字符串表达时间的属性例如:"2022-05-31 10:16:00",o2.getCreateTimeStr()排序,倒序方式 时间最近最前
//拿到企业用户主账号信息
		List<EnterpriseVO> page = enterpriseMapper.page(pageEnIds);
		//去重+排序
		page = page.stream().filter(new Predicate<EnterpriseVO>() {
			final Map<Integer, Boolean> concurrentHashMap = new ConcurrentHashMap<>();

			@Override
			public boolean test(EnterpriseVO enterpriseVO) {
				return concurrentHashMap.putIfAbsent(enterpriseVO.getId(), Boolean.TRUE) == null;
			}
		}).sorted(new Comparator<EnterpriseVO>() {
			@Override
			public int compare(EnterpriseVO o1, EnterpriseVO o2) {
				return o2.getCreateTimeStr().compareToIgnoreCase(o1.getCreateTimeStr());
			}
		}).collect(Collectors.toList());

distinct

  • 去重 (对象不能去重,除非重写hasCode()和equals()方法)
 List<String> list = Arrays.asList("aaa","aaa","ccc");
        List<String> distinct = list.stream().distinct().collect(Collectors.toList());
        System.out.println(distinct);
  • 输出:在这里插入图片描述

limit

  • 定义多少 就返回前多少条数据
 List<String> list2 = Arrays.asList("aaa","bbb","ccc","ddd","eee");
        List<String> limit = list2.stream().limit(3).collect(Collectors.toList());
        System.out.println(limit);
  • 输出:在这里插入图片描述

skip

  • 和limit相反用法 定义多少 就除去前面多少数据, 把剩余数据返回
 List<String> list3 = Arrays.asList("aaa","bbb","ccc","ddd","eee");
        List<String> skip = list3.stream().skip(2).collect(Collectors.toList());
        System.out.println(skip);
  • 输出:在这里插入图片描述

map

  • 对流中所有元素做统一处理
 List<String> list4 = Arrays.asList("aaa","bbb","ccc","ddd","eee");
        List<String> map = list4.stream().map(str->(str.concat("xxx"))).collect(Collectors.toList());
        System.out.println(map);
  • 输出:在这里插入图片描述

sorted

  • 排序 字母默认从a字母开始排 数字默认从低到高排
    List<String> list5 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        List<String> sorted = list5.stream().sorted().collect(Collectors.toList());
        System.out.println(sorted);
  • 输出:在这里插入图片描述
  • 汉字 使用中文构造器排序(a-z姓)
        List<String> list6 = Arrays.asList("张三","李四","王五","赵六","张哥","李哥","王哥");
        List<String> sorted2 = list6.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
        System.out.println(sorted2);
  • 输出:在这里插入图片描述

mapToDouble/mapToLong/mapToInt

  • 将对象里属性累加求和 ,转化成自定义类型(一般来说属性什么类型就用什么类型的mapToX)
private static void test () {
        Person person = new Person("1", 1);
        Person person2 = new Person("1", 2);
        Person person3 = new Person("1", 3);
        Person person4 = new Person("1", 4);
        Person person5 = new Person("1", 5);
        List<Person> list = new ArrayList<>();
        list.add(person);
        list.add(person2);
        list.add(person3);
        list.add(person4);
        list.add(person5);
        double sum = list.stream().mapToDouble(Person::getAge).sum();
        System.out.println(sum);
    }
  • 输出结果: 15.0

终止操作符

anyMatch

  • 集合中是否有一个元素满足条件
  List<String> list7 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        boolean bc = list7.stream().anyMatch(s -> s.contains("bc"));
        System.out.println(bc);
  • 输出:在这里插入图片描述

allMatch

  • 集合中是否都满足条件
  List<String> list8 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        boolean allMatch = list8.stream().allMatch(s -> s.length()>1);
        System.out.println(allMatch);
  • 输出:在这里插入图片描述

noneMatch

  • 所有元素都不满足条件
List<String> list9 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        boolean noneMatch = list9.stream().noneMatch(s -> s.length()>5);
        System.out.println(noneMatch);
  • 输出:在这里插入图片描述

findAny

  • 返回集合中任意元素 要使用parallelStream(并行) 才行 (很冷门少用)
     List<String> list10 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        for (int i=0 ;i<100;i++){
            Optional<String> any = list10.parallelStream().findAny();
            if (any.isPresent()){
                System.out.println(any.get());
            }
        }
  • 输出:在这里插入图片描述

findFirst

  • 返回第一个元素
 List<String> list11 = Arrays.asList("abcx","bc","bcf","efg","efg","abcd","bca","jkl");
            Optional<String> first = list11.parallelStream().findFirst();
            if (first.isPresent()){
                System.out.println(first.get());
            }
  • 输出:在这里插入图片描述

foreach(个人最爱)

  • 循环
      List<String> list12 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        list12.stream().forEach(s -> System.out.println(s));

collect

  • 1.将流转化成为其他形式: set
   List<String> list13 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        Set<String> collect = list13.stream().collect(Collectors.toSet());
        System.out.println(collect);
  • 输出:在这里插入图片描述
  • 2.1将流转化成为其他形式: map
   List<String> list13 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
 Map<String, String> collect1 = list13.stream().collect(Collectors.toMap(v -> v, v -> v, (oldvalue, newvalue) -> newvalue));//重复的时候处理 用新的
        System.out.println(collect1);
  • 输出:在这里插入图片描述
  • 2.2 list转化成map (ps:转化成的map,key不能有重复,并且value不能为空(取决于list的值),否则会报错)
 private static void test4 () {
        Person person = new Person("啊",1);
        Person person2 = new Person("啊2",2);
        Person person3 = new Person("啊3",3);
        List<Person> result = new ArrayList<>();
        result.add(person);
        result.add(person2);
        result.add(person3);
        Map<String, Integer> collect = result.stream().collect(Collectors.toMap(e -> e.getName() + "_" + e.getName(), Person::getAge));
        System.out.println(collect);
    }

在这里插入图片描述

reduce

  • 将流中元素反复集合起来得到一个结果
 List<String> list14 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        Optional<String> reduce = list14.stream().reduce((acc, item) -> { //第一个是计算结果 第二个是初始值
            return acc + item;
        });
        if (reduce.isPresent()){
            System.out.println(reduce.get());
        }
  • 输出:在这里插入图片描述

count

  • 获取集合元素中数量
List<String> list15 = Arrays.asList("abc","bc","bcf","efg","efg","abcd","bca","jkl");
        long count = list15.stream().count();
        System.out.println(count);
  • 输出:在这里插入图片描述
版权声明：本文为EDT777原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。