java查找list重复数据 java list 判断重复

转载

码海探险家 2024-05-28 16:43:45

文章标签 java查找list重复数据 java System List 并集 文章分类 Java 后端开发

一种简单的通过ArrayList自带的方法，另一种使用lamda在不破坏原有集合的情况下进行操作

简单方式

求差集
求并集(不去重)---将一个集合全部加入另一个集合：
求并集(去重)
判断是否相等
求交集

Lamda方式

简单方式

前提需要明白List是引用类型，引用类型采用引用传递。
　　我们经常会遇到一些需求求集合的交集、差集、并集。例如下面两个集合:

List<String> list1 = new ArrayList<String>();
        list1.add("A");
        list1.add("B");

        List<String> list2 = new ArrayList<String>();
        list2.add("B");
        list2.add("C");

求差集

例如，求List1中有的但是List2中没有的元素:

public static void test3(List list1, List list2) {
        list1.removeAll(list2);
        System.out.println(list1);
    }
结果:
[A]

查看ArrayList的removeAll的源码：

public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

再查看batchRemove的源码:(如果传的第二个参数是false，保留差集;如果传的是true，保留的是交集)

private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

是重新定义elementData数组的元素，下面代码的作用是将本集合中不包含另一个集合的元素重新加入元素，以此实现删除的功能(注意上面调用的方法传的参数是false，也就是不包含的元素得以保留,实现差集的功能)

if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];

求并集(不去重)—将一个集合全部加入另一个集合：

public static void test(List list1, List list2) {
        list1.addAll(list2);
        System.out.println(list1);
    }
结果:
[A, B, B, C]

查看ArayList的addAll()源码是数组复制:

public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

再查看System的arraycopy发现是一个native方法(本地方法):–-其实system类的好多方法都是native方法

public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

求并集(去重)

例如:求List1和List2的并集,并实现去重。
　　　　思路是:先将list中与list2重复的去掉，之后将list2的元素全部添加进去。

public static void test1(List list1, List list2) {
        list1.removeAll(list2);
        list1.addAll(list2);
        System.out.println(list1);
    }
结果:
[A, B, C]

判断是否相等

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent(list, list1));
    }
    
     /** 
      * 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等
      */
     private static boolean checkDiffrent(List<String> list, List<String> list1) { 
        long st = System.nanoTime();
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        list.sort(Comparator.comparing(String::hashCode));  
        list1.sort(Comparator.comparing(String::hashCode)); 
        return list.toString().equals(list1.toString());
    }
}

求交集

例如:求List1和List2中都有的元素。

public static void test2(List list1, List list2) {
        list1.retainAll(list2);
        System.out.println(list1);
    }
结果：
[B]

在上面2的实验过程中，我们知道batchRemove(Collection,true)也是求交集，所以猜想 retainAll 内部应该是调用 batchRemove(Collection,true)，查看ArrayList的源码如下:

public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

Lamda方式

以上这种操作破坏了原始的javaList对象，采用java8 lambda表达式流操作则可以不影响原始list对象而得到两个javaList对象的交、并、差集。

package com.wxx.webbase;

import java.util.*;

import static java.util.stream.Collectors.toList;

/**
 * @author admin
 */
public class MyTest {
    /**
     * 用于测试的对象类
     */
    static class Student {
        /**
         * 姓名
         */
        private String name;

        /**
         * 学号 唯一值
         */
        private String code;

        public Student(String name, String code) {
            this.name = name;
            this.code = code;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof Student)) {
                return false;
            }
            Student student = (Student) o;
            return code.equals(student.getCode());
        }

        @Override
        public int hashCode() {
            return Objects.hash(code);
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", code='" + code + '\'' +
                    '}';
        }

        public String getName() {
            return name;
        }

        public String getCode() {
            return code;
        }
    }

    /**
     * 对象类型的处理
     */
    public static void showObjectDeal() {
        List<Student> list1 = new ArrayList<>();
        list1.add(new Student("name1","1001"));
        list1.add(new Student("name2","1002"));
        list1.add(new Student("name3","1003"));

        List<Student> list2 = new ArrayList<>();
        list2.add(new Student("name3","1003"));
        list2.add(new Student("name4","1004"));

        Set<Student> list1Set = new HashSet<>(list1);

        Set<Student> list2Set = new HashSet<>(list2);

        // 交集
        List<Student> intersection = list1.stream().filter(list2Set::contains).collect(toList());
        System.out.println("---得到交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<Student> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<Student> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
        List<Student> listAll = list1.parallelStream().collect(toList());
        List<Student> listAll2 = list2.parallelStream().collect(toList());
        listAll.addAll(listAll2);
        System.out.println("---得到并集 listAll---");
        listAll.parallelStream().forEach(System.out::println);

        // 去重并集
        list1Set.addAll(list2Set);
        List<Student> listDistinctAll = new ArrayList<>(list1Set);
        System.out.println("---得到去重并集 listDistinctAll---");
        listDistinctAll.parallelStream().forEach(System.out::println);

        System.out.println("---原来的List1---");
        list1.parallelStream().forEach(System.out::println);
        System.out.println("---原来的List2---");
        list2.parallelStream().forEach(System.out::println);
    }

    /**
     * 简单类型的处理
     */
    public static void showSimpleDeal() {
        List<String> list1 = new ArrayList<>();
        list1.add("1111");
        list1.add("2222");
        list1.add("3333");

        List<String> list2 = new ArrayList<>();
        list2.add("3333");
        list2.add("4444");

        Set<String> list1Set = new HashSet<>(list1);

        Set<String> list2Set = new HashSet<>(list2);

        // 交集
        List<String> intersection = list1.stream().filter(list2Set::contains).collect(toList());
        System.out.println("---得到交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);
输出结果：
---得到交集 intersection---
3333
        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);
输出结果：
---得到差集 reduce1 (list1 - list2)---
1111
2222
        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);
输出结果：
---得到差集 reduce2 (list2 - list1)---
4444
        // 并集
        List<String> listAll = list1.parallelStream().collect(toList());
        List<String> listAll2 = list2.parallelStream().collect(toList());
        listAll.addAll(listAll2);
        System.out.println("---得到并集 listAll---");
        listAll.parallelStream().forEach(System.out::println);
输出结果：
---得到并集 listAll---
2222
1111
4444
3333
3333
        // 去重并集
        list1Set.addAll(list2Set);
        List<String> listDistinctAll = new ArrayList<>(list1Set);
        System.out.println("---得到去重并集 listDistinctAll---");
        listDistinctAll.parallelStream().forEach(System.out::println);
输出结果：
---得到去重并集 listDistinctAll---
3333
4444
1111
2222
        System.out.println("---原来的List1---");
        list1.parallelStream().forEach(System.out::println);
输出结果：
---原来的List1---
1111
2222
3333
        System.out.println("---原来的List2---");
        list2.parallelStream().forEach(System.out::println);
输出结果：
---原来的List2---
4444
3333
    }


    public static void main(String[] args) {
        // 基本类型测试
        showSimpleDeal();
        // 对象测试
        showObjectDeal();

        // 一般有filter 操作时，不用并行流parallelStream ,如果用的话可能会导致线程安全问题 ！
        // parallelStream 由于是并行执行， 输出可能和list本身的顺序不一样 ！
    }
}

比较两个数组是否相等

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent(list, list1));
    }
    
     /** 
      * 使用stream流去比较两个数组是否相等
      */
     private static boolean checkDiffrent(List<String> list, List<String> list1) {    
        long st = System.nanoTime();  
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        /** 先将集合转成stream流进行排序然后转成字符串进行比较 */
        return list.stream().sorted().collect(Collectors.joining())
                        .equals(list1.stream().sorted().collect(Collectors.joining()));
       }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。