list去重的六种方法

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {
public static void main(String[] args) {
        
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method(list);
        method_1(list);
        method_2(list);
        method_3(list);
        method_4(list);
        method_5(list);
    }

    /**
     * 自定义去重
     * method去重集合:[1, 3, 5, 2, 7]
     * @param list
     */
    public static void method(List<Integer> list) {
        // 新集合
        List<Integer> newList = new ArrayList<>(list.size());
        list.forEach(i -> {
            if (!newList.contains(i)) { // 如果新集合中不存在则插入
                newList.add(i);
            }
        });
        System.out.println("method去重集合:" + newList);
    }
    /**
     * 使用迭代器去重
     * method_1去重集合:[5, 1, 3, 7, 2]
     * @param list
     */
    public static void method_1(List<Integer> list) {
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 获取循环的值
            Integer item = iterator.next();
            // 如果存在两个相同的值
            if (list.indexOf(item) != list.lastIndexOf(item)) {
                // 移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("method_1去重集合:" + list);
    }
    
    /**
     * hashset去重
     *  method_2去重集合:[1, 2, 3, 5, 7]
     * @param list
     */
    public static void method_2(List<Integer> list) {
        HashSet<Integer> set = new HashSet<>(list);
        System.out.println("method_2去重集合:" + set);
    }
    /**
     * 使用 LinkedHashSet 去重
     * method_3去重集合:[5, 1, 3, 7, 2]
     * @param list
     */
    public static void method_3(List<Integer> list) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("method_3去重集合:" + set);
    }
    /**
     * 使用 TreeSet 去重(无序)
     * method_4去重集合:[1, 2, 3, 5, 7]
     * @param list
     */
    public static void method_4(List<Integer> list) {
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("method_4去重集合:" + set);
    }
    /**
     * 使用 Stream 去重
     * method_5去重集合:[5, 1, 3, 7, 2]
     * @param list
     */
    public static void method_5(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("method_5去重集合:" + list);
    }