知新_RL

这个屌丝很懒，什么也没留下！

热门标签

玩转数组、集合，Java8 Stream API_map distinct() 是什么意思

作者：知新_RL | 2024-07-06 19:25:18

踩

map distinct() 是什么意思

Stream API介绍

Java 8引入了Stream API，它是一种处理集合（Collection）或数组（Array）数据的高级技术，可以使用非常简洁的语法完成复杂的数据操作。

Stream可以简化Java代码，减少代码量，使代码更易于维护和理解。在Java 8之前，开发人员需要使用循环来遍历集合或数组中的数据，但是Stream API提供了一种更加优雅和函数式的方式来操作数据。

下面是Stream API的一些主要特性：

1、集成Lambda表达式：Stream API可以使用Lambda表达式来定义数据操作，这样可以更加简洁地表达数据操作。

2、不存储数据：Stream API不会在内存中存储数据，而是在数据源中提取数据，对其进行操作，然后输出结果。

3、惰性求值：Stream API使用惰性求值（Lazy Evaluation）的方式处理数据，只有在需要输出结果时才会执行操作。

4、并行处理：Stream API可以将数据集合划分为多个小的数据块，然后并行处理这些小的数据块，从而提高数据处理的效率。

使用Stream API，可以轻松地对集合或数组中的数据进行过滤、映射、排序、聚合等操作。

下面是一些常用的Stream API操作：

1、filter()：对数据进行过滤，返回满足条件的数据集合。

2、map()：对数据进行映射，返回新的数据集合。

3、sorted()：对数据进行排序，返回排序后的数据集合。

4、distinct()：去除重复的数据，返回不重复的数据集合。

5、limit()：返回前N个数据。

6、skip()：跳过前N个数据，返回剩余的数据集合。

7、forEach()：对数据集合进行遍历。

8、concat()：对数据进行合并操作，返回一个合并结果。

以上是Stream API的一些常用操作，使用这些操作可以轻松地对集合或数组中的数据进行处理。

Stream API常用方法

1、Stream API之forEach

单列集合获取Stream流


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
Stream<String> stream = list.stream();

重写accept方法打印所有的数据


stream.forEach(new Consumer<String>() {
    @Override
    public void accept(String data) {
        System.out.println(data);
    }
});

使用Stream流打印所有数据

list.stream().forEach(System.out::println);

注意：“stream()”不加也可以实现输出效果，但是不加stream()程序就会按照顺序输出（不适合大数据量操作），加了stream()程序就会并行输出（适合大数据量操作）。

2、Stream API之concat

创建两个集合并添加数据


ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌","张无忌","张无忌", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");

合并list1和list2两个流为一个流

Stream.concat(list1.stream(),list2.stream()).forEach(System.out::println);

3、Stream API之count

创建一个集合并添加数据


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

计算集合中元素的总数


long count = list.stream().count();
System.out.println(count);

4、Stream API之distinct

创建一个集合并添加数据


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌","张无忌","张无忌", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

对集合中的元素去重

list.stream().distinct().forEach(System.out::println);

distinct底层通过hashset实现元素去重，依赖于hashCode和equals方法

5、Stream API之HashMap

创建双列集合，添加数据（双列集合无法直接使用stream流）


HashMap<String,Integer> hashMap = new HashMap<>();
hashMap.put("aaa",111);
hashMap.put("bbb",222);
hashMap.put("ccc",333);
hashMap.put("ddd",444);

通过stream流遍历HashMap中所有的key

hashMap.keySet().stream().forEach(System.out::println);

通过stream流遍历HashMap中所有的key以及对应的value

hashMap.entrySet().stream().forEach(System.out::println);

6、Stream API之filter

创建集合添加元素


ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

完成以下需求：

1、把所有以“张”开头的元素存储到新集合中

2、把“张”开头的，长度为3的元素再存储到新集合中

3、遍历打印最终结果

一、原始方法实现

1、把所有以“张”开头的元素存储到新集合中


ArrayList<String> list2 = new ArrayList<>();
for (String name : list1) {
    if(name.startsWith("张")){
        list2.add(name);
    }
}

2、把“张”开头的，长度为3的元素再存储到新集合中


ArrayList<String> list3 = new ArrayList<>();
for (String name : list2) {
    if(name.length() == 3){
        list3.add(name);
    }
}

3、遍历打印最终结果


for (String name : list3) {
    System.out.println(name);
}

二、使用lamdba+stream实现

方式一：


list1.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String name) {
        //如果返回值为true，表示当前数据留下
        //如果返回值为false，表示当前数据舍弃不要
        return name.startsWith("张") && name.length() ==3;
    }
}).forEach(name -> System.out.println(name));

方式二：


list1.stream()
        //1.把所有以“张”开头的元素存储到新集合中
        .filter(name->name.startsWith("张"))
        //2.把“张”开头的，长度为3的元素再存储到新集合中
        .filter(name -> name.length() == 3)
        //3.遍历打印最终结果
        .forEach(System.out::println);

7、Stream之limit、skip

创建集合添加元素


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

获取前3个元素

list.stream().limit(3).forEach(System.out::println);

跳过前4个元素

list.stream().skip(4) .forEach(System.out::println);

完成以下需求：

获取"张强", "张三丰", "张翠山"

第一种思路：

1、先获取前面6个元素："张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山",

2、然后跳过前面3个元素

list.stream().limit(6).skip(3).forEach(System.out::println);

第二种思路：

1、先跳过3个元素："张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"

2、然后再获取前面3个元素："张强", "张三丰", "张翠山"

list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));

8、Stream之map

创建集合添加元素


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");

转换流中的数据类型

方式一：


list.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String str) {
        String[] arr = str.split("-");
        String ageString = arr[1];
        int age = Integer.parseInt(ageString);
        return age;
    }
}).forEach(System.out::println);

方式二：


list.stream()
        .map(str-> Integer.parseInt(str.split("-")[1]))
        .forEach(System.out::println);

9、Stream API之Arrays

创建数组


int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
String[] arr2 = {"a","b","c"};

通过Arrays获取Stream流遍历


Arrays.stream(arr1).forEach(System.out::println);
Arrays.stream(arr2).forEach(System.out::println);

10、Stream API之of

使用of遍历数据


Stream.of(1,2,3,4,5).forEach(System.out::println);
Stream.of("a","b","c","d","e").forEach(System.out::println);

11、Stream API之collect

创建集合添加元素


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
        "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");

把所有的男性收集到List集合当中


List<String> collectList = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toList());
System.out.println(collectList);

把所有的男性收集到Set集合当中


Set<String> collectSet = list.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toSet());
System.out.println(collectSet);

把所有的男性收集到Map集合当中（键：姓名，值：年龄）

方式一：


Map<String, Integer> map1 = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toMap(new Function<String, String>() {
                                      @Override
                                      public String apply(String s) {
                                          //张无忌-男-15
                                          return s.split("-")[0];
                                      }
                                  },
                new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[2]);
                    }
                }));
System.out.println(map1);

方式二：


Map<String, Integer> map2 = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toMap(
                s -> s.split("-")[0],
                s -> Integer.parseInt(s.split("-")[2])));
System.out.println(map2);

12、Stream API之sorted

创建双列集合，添加数据（双列集合无法直接使用stream流）


HashMap<Integer,String> hashMap = new HashMap<>();
hashMap.put(111,"aaa");
hashMap.put(333,"ccc");
hashMap.put(222,"bbb");
hashMap.put(444,"ddd");

根据key顺序展示数据


List<Integer> collectSequence = hashMap.keySet().stream().sorted((o1, o2) -> o1 - o2).collect(Collectors.toList());
System.out.println("collectSequence："+collectSequence);

根据key逆序展示数据


List<Integer> collectInvertedSequence = hashMap.keySet().stream().sorted((o1, o2) -> o2 - o1).collect(Collectors.toList());
System.out.println("collectInvertedSequence："+collectInvertedSequence);

13、Stream API之toArray

创建集合添加元素


ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

收集流中的数据，放到数组中

方式一：


Object[] arr = list.stream().toArray();
System.out.println(Arrays.toString(arr));

方式二：


String[] arr1 = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});
System.out.println(Arrays.toString(arr1));

方式三：


String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));

Stream API练习

练习一：

需求：定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10

过滤奇数，只留下偶数

并将结果保存起来

1、定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10


List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

2、过滤奇数，只留下偶数，并将结果保存起来


List<Integer> newList = list.stream()
        //3、过滤奇数，只留下偶数
        .filter(n -> n % 2 == 0)
        //4、并将结果保存起来
        .collect(Collectors.toList());
System.out.println(newList);

练习二：

练习：

创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄 "zhangsan,23"，"lisi,24"，"wangwu,25"

保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值

1、创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄 "zhangsan,23"，"lisi,24"，"wangwu,25"


ArrayList<String> list = new ArrayList<>();
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");

2、保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值

方式一：


list.stream()
        .filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
        .collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split(",")[1]);
            }
        }));

方式二：


Map<String, Integer> map = list.stream()
        .filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
        .collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1])));
System.out.println(map);

练习三：

现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄。

姓名和年龄中间用逗号隔开。

比如：张三,23

要求完成如下的操作：

1，男演员只要名字为3个字的前两人

2，女演员只要姓杨的，并且不要第一个

3，把过滤后的男演员姓名和女演员姓名合并到一起

4，将上一步的演员信息封装成Actor对象

5，将所有的演员对象都保存到List集合中

备注：演员类Actor，属性有：name，age

男演员： "蔡坤坤,24" , "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27"

女演员： "赵小颖,35" , "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33"

1、现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。


ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womenList = new ArrayList<>();
Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");

按要求完成如下的操作：

1，男演员只要名字为3个字的前两人


Stream<String> stream1 = manList.stream()
        //男演员只要名字为3个字的
        .filter(s -> s.split(",")[0].length() == 3)
        //前两人
        .limit(2);

2，女演员只要姓杨的，并且不要第一个


Stream<String> stream2 = womenList.stream()
        //女演员只要姓杨的
        .filter(s -> s.split(",")[0].startsWith("杨"))
        //并且不要第一个
        .skip(1);

3，把过滤后的男演员姓名和女演员姓名合并到一起
4，将上一步的演员信息封装成Actor对象


Stream.concat(stream1,stream2).map(new Function<String, Actor>() {
    @Override
    public Actor apply(String s) {
        //"赵小颖,35"
        String name = s.split(",")[0];
        int age = Integer.parseInt(s.split(",")[1]);
        return new Actor(name,age);
    }
}).forEach(System.out::println);

5，将所有的演员对象都保存到List集合中


List<Actor> list = Stream.concat(stream1, stream2)
        .map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
        .collect(Collectors.toList());
System.out.println(list);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/793780