方式一：利用TreeSet集合特性排序+去重（有序）

TreeSet可以將字符串類型的數(shù)據(jù)按照字典順序進行排序，首字母相同則看第二位

 public static void main(String[] args) {
        // 一.利用TreeSet集合特性排序+去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        list.forEach(item->{
            System.out.println("去重前的集合："+item);
        });
        System.out.println("-----------------");


        List<String> result=new LinkedList<>(new TreeSet<>(list));
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

---

去重后的集合：[11, 22, 33, 66]

方式二：利用HashSet的特性去重（無序）

由于Set的特性是無序且不可重復(fù)，我們利用這個特性進行兩步操作：

1. 把list放入set中
2. 把set還回list里

public static void main(String[] args) {
        // 利用set的特性去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        Iterator iter=list.iterator();
        while(iter.hasNext()){
            System.out.println("去重前的集合元素："+iter.next());
        }
        System.out.println("-----------------");


        // result集合存放最終的結(jié)果
        List<String> result=new LinkedList<>();

        if (list.size()>0&&list!=null){
            // 新建HashSet集合，將list放入
            Set<String> set=new HashSet<>();
            set.addAll(list);

            // 將去重后的set集合放入結(jié)果集合result中
            result.addAll(set);
        }
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

---

去重后的集合：[22, 11, 33, 66]

方式三：利用LinkedHashSet去重（有序）

LinkedHashSet雖然可以去重，但是根據(jù)它的特性，它不能對數(shù)據(jù)進行排序，只能維持原來插入時的秩序

  public static void main(String[] args) {
        // 利用LinkedHashSet集合去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        for (int i=0;i<list.size();i++){
            System.out.println("去重前的集合元素："+list.get(i));
        }
        System.out.println("-----------------");


        List<String> result=new LinkedList<>(new LinkedHashSet<String>(list));
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

---

去重后的集合：[22, 11, 33, 66]

方式四：迭代器去重（無序）

此方法得到的新集合是無序的，也就是新集合的排列順序和原集合不一致

public static void main(String[] args) {
        // 二.迭代器去重（無序）

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        for (String item:list){
            System.out.println("去重前的集合元素："+item);
        }
        System.out.println("-----------------");


        Iterator<String> iterator=list.iterator();
        while (iterator.hasNext()){
            String next= iterator.next();
            // 如果存在兩個相同的值
            if (list.indexOf(next)!=list.lastIndexOf(next)){
                //移除最后那個相同的值
                iterator.remove();
            }
        }
        System.out.println("去重后的集合："+list);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

---

去重后的集合：[11, 33, 66, 22]

方式五：使用list.contains()對全部元素進行判斷（有序）

• String類型會判斷字符串里是否有相同的部分
• List里則會判斷是否有相同的元素
• 我們可以用list.contains()的方法進行判斷，然后將其添加到新的list當(dāng)中，元素的順序不發(fā)生改變

 public static void main(String[] args) {
        // 使用list.contains()對全部元素進行判斷


        System.out.println("----------");
        System.out.println("探究contains()方法");
        String s1="aaa";
        String s2="aa";
        System.out.println(s1.contains(s2));

        List<String> list0=new LinkedList<>();
        list0.add("aaa");
        System.out.println(list0.contains("aa"));
        System.out.println("----------");



        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        System.out.println("去重前的集合:"+list);
        System.out.println("-----------------");


        List<String> result=new LinkedList<>();
        for (String str:list){
            if (!result.contains(str)){
                result.add(str);
            }
        }
        System.out.println("去重后的集合："+result);
    }

探究contains()方法
true
false

---

去重前的集合:[22, 11, 33, 66, 22]

---

去重后的集合：[22, 11, 33, 66]

方式六：使用Java8特性（Stream去重）去重（有序）

把list集合->Stream流，然后對流用distinct()去重，再用collect()收集

public static void main(String[] args) {
        // 使用Java8特性去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        System.out.println("去重前的集合:"+list);
        System.out.println("-----------------");


        List<String> result=new LinkedList<>();
        result=list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后的集合："+result);
    }

去重前的集合:[22, 11, 33, 66, 22]

---

去重后的結(jié)集合：[22, 11, 33, 66]

方式七：使用list自身方法remove()–>不推薦

• 如果你的list里存的比較復(fù)雜，是一個List<Map<String,Object>>格式的情況，最無奈之舉就是這種方法
• 主要操作是將同一個list用兩層for循環(huán)配合.equals()方法，有相同的就用remove()方法剔除掉，然后得到一個沒有重復(fù)數(shù)據(jù)的list

  public static List<Map<String,Object>> distinct(List<Map<String,Object>> list){
        if (list!=null && list.size()>0){
            for (int i=0;i<list.size();i++){
                for (int j=list.size()-1;j>i;j--){
                    // 這里是對象的比較，如果去重條件不一樣，修改這里即可
                    if (list.get(j).equals(list.get(i))){
                        list.remove(j);
                    }
                }
            }
        }
        return list;
    }

總結(jié)：

介紹集合去重的方法中實現(xiàn)最簡潔，且去重之后的順序能和原集合保持一致的實現(xiàn)方法，只有兩種：LinkedHashSet 去重和 Stream 去重，其中后一種去重方法無需借助新集合，是我們優(yōu)先考慮的去重方法文章來源地址http://www.zghlxwxcb.cn/news/detail-766540.html

到了這里，關(guān)于【Java】List集合去重的方式的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！