java 查找重复数据结构 java list找出重复元素

参考 Java中List集合去除重复数据的六种方法

1. 循环list中的所有元素然后删除重复
2. 通过 hashset 剔除重复元素
3. 删除ArrayList中重复元素，保持顺序
4. 把list里的对象遍历一遍，用list.contains()，如果不存在就放入到另外一个list集合中
5. 用JDK1.8 Stream中对List进行去重：list.stream().distinct();
   demo： 新建 Test

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

/**
 *  list 集合去重
 *
 */
public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        List<String> lists = test.generateList();

//        test.removeDuplicate(lists);
//        test.quChong01(lists);
//        test.quChong02(lists);
//        test.quChong03(lists);
//        test.quChong04(lists);
        test.quChong05(lists);

        // 当 执行 quChong05()方法时， 出现不排序的原因是，quChong05()中 lists 更改了引用， 但 main 方法中 lists并没有更改引用
        test.listData(lists);  // 执行 quChong05(),如果再此处打印，程序不正常， 打印的是没有去重的集合

    }

    /**
     * 生成 lists 集合
     */
    public List<String> generateList(){
        List<String> lists = new ArrayList<String>();
        lists.add("hello");
        lists.add("world");
        lists.add("hello");
        lists.add("list");
        lists.add("hello");
        lists.add("hadoop");
        lists.add("java");
        lists.add("world");
        lists.add("list");
        lists.add("hadoop");
        return lists;
    }

    /**
     *  遍历数据
     * @param lists
     */
    public void listData(List<String> lists){
        lists.stream().forEach(item -> {
            System.out.println(item);
        });
    }


    /**
     *  循环list中的所有元素然后删除重复
     *  倒着删除时，
     *  1. 等删除可元素时， 该元素前的元素的索引是没有变化的
     *  2. 等 i = 0时，所有的元素都比较了，如果 i = 1, 索引为 0的元素，在上一次循环时已经比较了，因此无需再比较了
     * @param lists
     * @return
     */
    public void quChong01(List<String> lists){
        for(int i = 0; i < lists.size(); i++){
            for(int j = lists.size() - 1; j >= 0; j--){
                if(i != j){
                    if(lists.get(i).equals(lists.get(j))){
                        lists.remove(j);
//                        System.out.println(i + " " + j);
//                        System.out.println(lists.size());
//                        System.out.println(lists.toString());

                    }
                }
            }
        }
    }

    /**
     *  通过 hashset 剔除重复元素
     * @param lists
     */
    public void quChong02(List<String> lists){
        HashSet<String> set = new HashSet<>(lists);
        lists.clear();
        lists.addAll(set);
    }

    /**
     *  删除ArrayList中重复元素，保持顺序   
     * @param lists
     */
    public void quChong03(List<String> lists){
        HashSet<String> set = new HashSet<>();
        ArrayList<String> arrayList = new ArrayList<>();
        Iterator<String> iterator = lists.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            if(set.add(next)){ // 则证明 set 中 无此元素
                arrayList.add(next);
            }
        }
        lists.clear();
        lists.addAll(arrayList);
    }

    /**
     *  把list里的对象遍历一遍，用list.contains()，如果不存在就放入到另外一个list集合中
     * @param lists
     */
    public void quChong04(List<String> lists){
        ArrayList<String> arrayList = new ArrayList<>();
        for(String item: lists){
            if(!arrayList.contains(item)){  // 如果不包含此元素，则添加此元素
                arrayList.add(item);
            }
        }
        lists.clear();
        lists.addAll(arrayList);
    }


    /**
     * 用JDK1.8 Stream中对List进行去重：list.stream().distinct();
     * @param lists
     */
    public void quChong05(List<String> lists){
        List<String> collect = lists.stream().distinct().collect(Collectors.toList());

        // 当 执行 quChong05()方法时， 出现不排序的原因是，quChong05()中 lists 更改了引用， 但 main 方法中 lists并没有更改引用
        lists = collect;
//        listData(lists);  // 执行 quChong05(),如果再此处打印，程序正常
    }


    /**
     *  倒着删除时，
     *  1. 等删除可元素时， 该元素前的元素的索引是没有变化的
     *  2. 等 i = 0时，已经比较了，如果 i = 1, 索引为 0的元素，在上一次循环时已经比较了，因此无需再比较了
     * @param list
     * @return
     */
    public   static   List  removeDuplicate(List list)  {
        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);
                }
            }
        }
        return list;
    }


}