多种方式实现List集合的去重和移除Map中指定的元素

List 去重的多种实现方法

public class TestList {
    
    
    public List<String> initList = Arrays.asList(
            "张三",
            "李四",
            "张三",
            "赵六",
            "刘四",
            "李强",
            "李白",
            "张三",
            "李强",
            "王五"
    );

方式一： 两个list集合遍历去重利用contains()方法

  @Test
    public void test01() {
    
    
        ArrayList<String> list = new ArrayList<>(initList);
        ArrayList<String> list1 = new ArrayList<>();
        for (String s : list) {
    
    
            if (!list1.contains(s)) {
    
    
                list1.add(s);
            }
        }
        System.out.println("list1 = " + list1);
    }

方式二：一个list集合循环嵌套去重

 @Test
    public void remove2() {
    
    
        List<String> list = new ArrayList<>(initList);
        for (int i = 0; i < list.size() - 1; i++) {
    
    
            for (int j = list.size() - 1; j > i; j--) {
    
    
                if (list.get(j).equals(list.get(i))) {
    
    
                    list.remove(j);
                }
            }
        }
        System.out.println(list);
    }

方式三：使用Stream流去重

  @Test
    public void remove3() {
    
    
        ArrayList<String> list = new ArrayList<>(initList);
        List<String> list1 = list.stream().distinct().collect(Collectors.toList());
        System.out.println("list1 = " + list1);
    }

方式四：利用Set集合去重

  @Test
    public void remove4(){
    
    
        ArrayList<String> list = new ArrayList<>(initList);
        //HashSet 去重无序
        HashSet<String> set = new HashSet<>(list);
        System.out.println("set = " + set);
        //linkedHashSet 去重有序
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(list);
        System.out.println("linkedHashSet = " + linkedHashSet);
    }

移除Map中指定的元素

public class TestHashMap {
    
    
    public Map<String, String> initMap = new HashMap<String, String>() {
    
    
        private static final long serialVersionUID = -1064788964816803485L;

        {
    
    
            put("user1", "张三");
            put("user2", "李四");
            put("user3", "张三");
            put("user4", "李四");
            put("user5", "王五");
            put("user6", "赵六");
            put("user7", "李四");
            put("user8", "王五");
        }
    };

方式一：iterator迭代器

    @Test
    public void remove01() {
    
    
        HashMap<String, String> map = new HashMap<>(initMap);
        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
    
    
            Map.Entry<String, String> entry = iterator.next();
            if ("张三".equals(entry.getValue()))
                iterator.remove();
        }
        System.out.println("map = " + map);
    }

方式二：利用集合的 removeif( ) 方法

  @Test
    public void remove02() {
    
    
        HashMap<String, String> map = new HashMap<>(initMap);
        map.entrySet().removeIf(entry -> "张三".equals(entry.getValue()));
        System.out.println("map = " + map);
    }

方式三：利用增强for循环

  @Test
    public void remove03() {
    
    
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>(initMap);
        map.forEach((k, v) -> {
    
    
            if ("张三".equals(v))
                map.remove(k);
        });
        System.out.println(map);
    }

方式四：利用Stream流

  @Test
    public void test01() {
    
    
        Stream<Map.Entry<String, String>> stream = initMap.entrySet().stream();
        Map<String, String> map = stream.filter(user -> !"张三".equals(user.getValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        //.collect(Collectors.toMap(entry->entry.getKey, entry->entry.getValue));
        System.out.println(map);
    }