方法一：


 bool b= lst.GroupBy(l=>l.Name).Where(g=>g.Count()>1).Count()>0;


方法二：


lst.ToDictionary(o => { return o.name; });
不出异常就没重复





http://bbs.csdn.net/topics/390492533

如果想要集合中的元素不会有重复，那么推荐使用hashSet，如下：





[java] view
 plaincopy





//  list是有重复元素的ArrayList  

    HashSet hSet  =   new  HashSet(list);  

    list.clear();  

    list.addAll(hSet);  





但是有时我们想删除某一个重复属性值（值相同）的某个元素，如下：





[java] view
 plaincopy





NetWork nw1 = new NetWork();  

nw1.id = 1;  

nw1.destip = "192.168.1.3";  

  

NetWork nw2 = new NetWork();  

nw2.id = 2;  

nw2.destip = "192.168.1.5";  

  

NetWork nw3 = new NetWork();  

nw3.id = 3;  

nw3.destip = "192.168.1.3";  

  

NetWork nw4 = new NetWork();  

nw4.id = 4;  

nw4.destip = "192.168.1.4";  

  

NetWork nw5 = new NetWork();  

nw5.id = 5;  

nw5.destip = "192.168.1.3";  

  

mList.add(nw1);  

mList.add(nw2);  

mList.add(nw3);  

mList.add(nw4);  

mList.add(nw5);  

明显nw1、nw3、nw5中的ip值都一样，我们只需要一个就足够了，那么用ArrayList该如何循环遍历删除自身的元素值呢？







[java] view
 plaincopy





for (int i = 0; i < mList.size()-1; i++) {  

    for (int j = mList.size()-1; j > i; j--) {  

        if (mList.get(j).destip.equals(mList.get(i).destip)) {  

            mList.remove(j);  

        }  

    }  

}  
两个for循环足矣，记住最好从尾部开始逐一比较，这样一旦某一个元素符号要求，需要delete，能保证删除尾部之上的，不会造成循环错乱。

如果你是用的JDK8，那推荐你使用stream来操作
List<String> resultList=oldList.stream()
            .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getUserName()+f.getAge()))), ArrayList::new));

菜鸟教程
end.
自己造轮子：主要通过反射获取指定对象属性，然后利用set集合，对指定属性的值进行比较，结果相等则代表重复，代码如下：
package cn.sinobest.sdg.util;

import java.lang.reflect.Field;
import java.util.*;

/**
 * @description 集合工具类
 * @author: dengweiping
 * @time: 2020/6/1 14:49
 */
public class ListUtil {
       /**
     * 根据指定对象属性去除重复对象
     *
     * @param list         传入的list集合
     * @param propertyName 指定的去重属性名称
     */
    public static <T> List<T> removeRepeat(List<T> list, String propertyName) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        //根据属性值进行去重
        Set<T> sets = new TreeSet<>((o1, o2) -> {
            try {
                Field field1 = o1.getClass().getDeclaredField(propertyName);
                Field field2 = o2.getClass().getDeclaredField(propertyName);
                field1.setAccessible(true);
                field2.setAccessible(true);
                Object obj1 = field1.get(o1);
                Object obj2 = field2.get(o2);
                //根据指定属性进行去重
                return obj1.toString().compareTo(obj2.toString());
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
            }
            return 0;
        });
        sets.addAll(list);
        return new ArrayList(sets);
    }

    /**
     * 根据指定key去除重复Map
     *
     * @param list    传入的list集合
     * @param keyName 指定的key
     */
    public static List<Map<String, Object>> removeMapRepeat(List<Map<String, Object>> list, String keyName) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        //根据属性值进行去重
        Set<Map<String, Object>> sets = new TreeSet<>((m1, m2) -> {
            Object obj1 = m1.get(keyName);
            Object obj2 = m2.get(keyName);
            //根据指定的key进行去重
            return obj1.toString().compareTo(obj2.toString());
        });
        sets.addAll(list);
        return new ArrayList(sets);
    }

}


更多工具类可以查看我的博客：Java字符串、集合等工具类合集

项目源码地址：全球同性交友网站

1、判断对象是否存在于list集合中 

    用list的contains方法，即list.contains(object)，返回的是boolean值。 

2、去掉list集合中重复的元素 

    方法一：循环元素删除



public static void 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);        
                }      
             }     
        } 
            System.out.println(list); 
    }

或者

public static void removeDuplicate(List list) {    
        List<object> list1 = new ArrearyList<object>();
        for ( int i = 0  i < list.size() - 1  i ++ ) {      
            if(!list1.contains(list.get(i))){               
            list1.add(list.get(i))
        } 
            System.out.println(list); 
    }

方法二：通过HashSet剔除



public static void removeDuplicate(List list) {       
    HashSet h = new HashSet(list);       
    list.clear();       
    list.addAll(h); 
    System.out.println(list); 
}

一开始用过这个方法，但是因为需要的是不改变集合里对象的顺序，set集合是无序的，也就是说他会打乱你之前list集合中的顺序，所以按照自己需要的进行选择。

方法三： 删除ArrayList中重复元素，保持顺序



public static void removeDuplicateWithOrder(List list) {    
    Set set = new HashSet(); 
    List newList = new ArrayList(); 
    for (Iterator iter = list.iterator(); iter.hasNext();) {           
        Object element = iter.next();           
        if (set.add(element)) {
             newList.add(element);
        }                        
    } 
      list.clear(); 
      list.addAll(newList); 
}
这个方法类似与方法一中我改进的那个方法。

说明：判断两个对象相等是否要重写equals 和hashcode方法  

         首先说建议的情况：比如你的对象想放到Set集合或者是想作为Map的key时，那么你必须重写equals()方法，这样才能保证唯一性。当然，在这种情况下，你不想重写hashCode()方法，也没有错。但是，对于良好的编程风格而言，你应该在重写equals（）方法的同时，也重写hashCode()方法。  

         必须重写hashCode()的情况：  

         如果你的对象想放进散列存储的集合中（比如：HashSet,LinkedHashSet）或者想作为散列Map（例如：HashMap,LinkedHashMap等等）的Key时，在重写equals()方法的同时，必须重写hashCode()方法。  

         最后明白两点就行了：  

          1.hashCode()方法存在的主要目的就是提高效率。  

          2.在集合中判断两个对象相等的条件，其实无论是往集合中存数据，还是从集合中取数据，包括如果控制唯一性等，都是用这个条件判断的，条件如下：  

           首先判断两个对象的hashCode是否相等，如果不相等，就认为这两个对象不相等，就完成了。如果相等，才会判断两个对象的equals()是否相等，如果不相等，就认为这两个对象不相等，如果相等，那就认为这两个对象相等。  

           上面的条件对于任何集合都是如此，只要理解上面的条件，你就明白了，为什么在有些情况下建议重写hashCode().有些情况下，是必须要重写的，只有一个目的，就是提高效率，你想想，如果你重写了hashCode(),只要不满足第一个条件，那就直接可以判断两个对象是不等的，也就不用花费时间再去比较equals了。  

           最后总结一句话就是，hashCode()方法存在的主要目的就是提高效率，但是如果你想把对象放到散列存储结构的集合中时，是必须要重写的。