List去重的几种方式

版权声明:本文为@huaiyan 博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/yihuaiyan/article/details/94719541


方案一:借助Set的特性进行去重

	/**
     * 去除重复数据
     * 由于Set的无序性,不会保持原来顺序
     * @param list
     */
    public static List<Map<String, Object>> distinct(List<Map<String, Object>> list) {
       
	      Set set = new HashSet();
	      List doubleList= new ArrayList();
	      set.addAll(list);
	      doubleList.addAll(set);
	      return doubleList;
    }

方案二 : 利用set集合特性保持顺序一致去重

// Set去重并保持原先顺序的两种方法
   public static void delRepeat(List<String> list) {
   	   //方法一
       List<String> listNew = new ArrayList<String>(new TreeSet<String>(list));
       //方法二
       List<String> listNew2 = new ArrayList<String>(new LinkedHashSet<String>(list));
   }

方案三 : 使用list自身方法remove()

 /**
     * 去除重复数据(一般不推荐)
     * 类似于冒泡排序
     * @param list
     */
  public static List<Map<String, Object>> distinct(List<Map<String, Object>> list) {
        if (null != list && list.size() > 0) {
        //循环大的list集合
            for (int i = 0; i < list.size(); i++) {
            //得到list中每一个map
                Map map= list.get(i);
                for (int j = 1; j < list.size(); j++) {
                    Map map2= list.get(j);
                    if (map.equals(map2)) {
                        list.remove(j);
                        continue;
                    }
                }
            }
        }
        //得到最新移除重复元素的list
        return list;
    }

方案四 :遍历List集合,将元素添加到另一个List集合中

// 遍历后判断赋给另一个list集合,保持原来顺序
public static List<String> delRepeat(List<String> list) {
	  List<String> listNew = new ArrayList<String>();
	  for (String str : list) {
	       if (!listNew.contains(str)) {
	           listNew.add(str);
	       }
	   }
	  return listNew ;
}

方案五 :使用Java8特性去重

public static List<String> delRepeat(List<String> list) {
     List<String> myList = list.stream().distinct().collect(Collectors.toList());
	 return myList ;
}
### 回答1: 在 Java 中,可以使用以下几种方式实现 List 去重: 1. 利用 Set 去重。将 List 中的元素存放到 Set 中,自动去除重复元素,然后再将 Set 转换回 List。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); List<Integer> newList = new ArrayList<>(new HashSet<>(list)); System.out.println(newList); // [1, 2, 3, 4] ``` 2. 利用 Java 8 中的 Stream 去重。利用 Stream 的 distinct() 方法对 List 进行去重。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); List<Integer> newList = list.stream().distinct().collect(Collectors.toList()); System.out.println(newList); // [1, 2, 3, 4] ``` 3. 利用循环遍历去重。利用双重循环遍历 List,将重复的元素删除。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); for (int i = 0; i < list.size() - 1; i++) { for (int j = i + 1; j < list.size(); j++) { if (list.get(i).equals(list.get(j))) { list.remove(j); j--; } } } System.out.println(list); // [1, 2, 3, 4] ``` 以上三种方法都可以实现 List 去重,具体使用哪一种方法可以根据实际情况选择。 ### 回答2: 在Java中,可以使用以下几种方式List进行去重: 1. 使用Set集合:将List作为参数传递给Set的构造函数,然后再将Set转换回List。由于Set的元素不能重复,这样就能实现去重的效果。 ```java List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("A"); list.add("C"); Set<String> set = new LinkedHashSet<>(list); List<String> distinctList = new ArrayList<>(set); System.out.println(distinctList); // 输出:[A, B, C] ``` 2. 使用Java 8的Stream API:通过使用Java 8引入的流操作,我们可以很方便地对List进行去重。 ```java List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("A"); list.add("C"); List<String> distinctList = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList); // 输出:[A, B, C] ``` 这里使用了`distinct()`方法来去除重复的元素,并使用`collect(Collectors.toList())`将流转换为List。 3. 自定义比较器:如果要对自定义对象的List进行去重,可以通过自定义对象的`equals()`和`hashCode()`方法来实现去重的逻辑。 ```java class Person { private String name; public Person(String name) { this.name = name; } public String getName() { return name; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } Person person = (Person) obj; return Objects.equals(name, person.getName()); } @Override public int hashCode() { return Objects.hash(name); } } List<Person> list = new ArrayList<>(); list.add(new Person("John")); list.add(new Person("Mary")); list.add(new Person("John")); List<Person> distinctList = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList); // 输出:[John, Mary] ``` 这里重写了`Person`类的`equals()`和`hashCode()`方法,通过比较对象的`name`属性来判断是否相等,从而实现了去重的效果。 ### 回答3: JavaList去重方式有多种。 1. 使用Set:将List转化为Set,Set特性是不允许重复元素的,所以会自动去除List中的重复元素。然后将Set再转化回List即可实现去重。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... Set<Integer> set = new HashSet<Integer>(list); // 将List转为Set,去除重复元素 List<Integer> dedupList = new ArrayList<Integer>(set); // 将Set转为List ``` 2. 使用Java 8的Stream:利用Stream的distinct()方法,可以根据元素的自然顺序或指定的比较器,去重List中的元素。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... List<Integer> dedupList = list.stream().distinct().collect(Collectors.toList()); // 利用Stream去重 ``` 3. 使用Apache Commons Collections工具类:使用CollectionUtils工具类的removeDuplicates()方法,可以去除List中的重复元素。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... CollectionUtils.removeDuplicates(list); // 去除List中的重复元素 ``` 这些方法都可以实现List去重,具体根据使用环境和需求选择适合的方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值