java list的equals方法

java list对象去重复的方法Java是一种面向对象的编程语言，常用于开发各种应用程序。

在Java程序中，List是一种常用的数据结构，用于存储一组有序的元素。

然而，有时候我们需要对List中的元素进行去重操作，即去除重复的元素，以保证数据的完整性和准确性。

本文将介绍几种实现Java List对象去重的方法。

方法一：使用HashSet去重HashSet是Java中的一种集合类，它不允许有重复的元素。

我们可以通过将List转换为HashSet，再将HashSet转换回List的方式，实现List对象的去重。

具体代码如下所示：```javaList<T> list = new ArrayList<T>();// 添加元素至listHashSet<T> set = new HashSet<T>(list);list.clear();list.addAll(set);```方法二：使用LinkedHashSet去重LinkedHashSet是HashSet的子类，它保留了元素的插入顺序。

我们可以通过将List转换为LinkedHashSet，再将LinkedHashSet转换回List的方式，实现List对象的去重。

具体代码如下所示：```javaList<T> list = new ArrayList<T>();// 添加元素至listLinkedHashSet<T> set = new LinkedHashSet<T>(list);list.clear();list.addAll(set);```方法三：使用Stream API去重Java 8引入了Stream API，可以通过Stream的distinct()方法实现List对象的去重。

具体代码如下所示：```javaList<T> list = new ArrayList<T>();// 添加元素至listlist = list.stream().distinct().collect(Collectors.toList());```方法四：使用TreeSet去重TreeSet是Java中的一种集合类，它可以对元素进行自然排序，并且不允许有重复的元素。

java 判断两个字符串相等的方法在Java中，判断两个字符串是否相等的常用方法有多种。

下面将介绍三种常用的方法。

1. 使用equals()方法：Java中的String类重写了equals()方法，用于比较字符串的内容是否相等。

这种方法将比较字符串的每个字符，如果两个字符串的长度相等且字符内容一一对应相等，则返回true，否则返回false。

示例代码如下：```String str1 = "Hello";String str2 = "World";boolean isEqual = str1.equals(str2);System.out.println("字符串是否相等: " + isEqual);```2. 使用equalsIgnoreCase()方法：如果我们想要忽略字符串的大小写进行比较，可以使用equalsIgnoreCase()方法。

这个方法与equals()方法类似，但是它忽略了大小写的差异。

示例代码如下：```String str1 = "Hello";String str2 = "hello";boolean isEqual = str1.equalsIgnoreCase(str2);System.out.println("字符串是否相等（忽略大小写）: " + isEqual);```3. 使用compareTo()方法：compareTo()方法用于比较两个字符串的字典顺序。

它返回一个整数，如果当前字符串小于目标字符串，返回负数；如果当前字符串大于目标字符串，返回正数；如果两个字符串相等，返回0。

示例代码如下：```String str1 = "apple";String str2 = "banana";int result = pareTo(str2);if (result < 0) {System.out.println("字符串1在字典顺序上小于字符串2");} else if (result > 0) {System.out.println("字符串1在字典顺序上大于字符串2");} else {System.out.println("字符串1和字符串2在字典顺序上相等");}```这些是Java中常用的几种判断两个字符串相等的方法。

equals 比较 list 的原理在编程中，equals()方法是用于比较两个对象是否相等的常用方法。

而对于比较list这样的数据结构，equals()方法同样适用。

在比较list的原理中，equals()方法主要依靠以下几个方面：1. 长度比较：首先，equals()方法会比较两个list的长度是否相等。

如果长度不相等，那么这两个list一定不相等。

2. 元素比较：接下来，equals()方法会按照顺序逐个比较两个list中的元素。

对于每个位置上的元素，equals()方法会调用元素类的equals()方法进行比较。

这里需要注意，如果list中存储的是自定义类的对象，则需要重写自定义类的equals()方法，以便正确比较对象的内容。

3. 空值判断：equals()方法还会检查两个list是否为null。

如果其中一个list为null，而另一个list不为null，则它们不相等。

需要注意的是，equals()方法比较的是list的内容，而不是list的引用。

即使两个list指向不同的内存地址，只要它们的内容一致，equals()方法仍然会认为它们相等。

下面是一个简单的示例代码，展示了如何比较两个list是否相等：```javaList<Integer> list1 = Arrays.asList(1, 2, 3);List<Integer> list2 = Arrays.asList(1, 2, 3);boolean isEqual = list1.equals(list2);System.out.println("list1和list2是否相等：" + isEqual);```在这个示例中，我们创建了两个list，分别为list1和list2，它们的元素内容相同。

通过调用equals()方法，我们可以判断它们是否相等。

在这个例子中，输出结果将为true，表示list1和list2相等。

java中的包含判断方法在Java中，可以使用多种方法来进行包含判断。

以下是一些常用的方法：1. 使用equals(方法进行相等判断：equals(方法是用来判断两个对象是否相等的方法。

对于基本类型，可以直接使用"=="来进行相等判断；对于对象类型，则需要使用equals(方法。

例如，对于字符串类型的比较，可以使用以下代码：```javaString str1 = "Hello";String str2 = "World";if (str1.equals(str2))System.out.println("str1 equals str2");} elseSystem.out.println("str1 not equals str2");}```2. 使用endsWith(方法判断字符串是否以指定后缀结尾：endsWith(方法用于判断字符串是否以指定的字符串结尾。

它返回一个布尔值，如果字符串以指定的字符串结尾，则返回true；否则返回false。

```java} else}```3. 使用contains(方法判断字符串是否包含指定的子字符串：contains(方法用于判断一个字符串是否包含指定的子字符串。

它返回一个布尔值，如果字符串包含指定的子字符串，则返回true；否则返回false。

例如，判断一个句子是否包含关键字"Java"，可以使用以下代码：```javaString sentence = "Java is a programming language";if (sentence.contains("Java"))System.out.println("The sentence contains the keyword Java");} elseSystem.out.println("The sentence does not contain the keyword Java");}```4. 使用containsAll(方法判断一个集合是否包含另一个集合：containsAll(方法用于判断一个集合是否包含另一个集合的所有元素。

javalist对象根据某个字段去重复的方法Java中的List对象是一种常用的数据结构，可用于存储一组对象并且保持它们的顺序。

当我们需要对List对象进行操作时，有时候需要根据某个字段的值来去重复。

本文将介绍两种常用的方法来实现这个需求。

方法一：使用HashSet去重复HashSet是Java中提供的一种无序、不可重复的集合。

我们可以利用HashSet 的特性来快速去重复。

具体步骤如下：1. 创建一个新的HashSet对象，用来保存去重后的List对象。

2. 遍历原始List对象，将每个元素的指定字段值作为HashSet的元素添加到HashSet对象中。

3. 将HashSet转换为List对象，即得到去重后的List对象。

以下是示例代码：```javaimport java.util.*;public class ListDuplicateRemover {public static void main(String[] args) {// 创建原始List对象List<Person> persons = new ArrayList<>();persons.add(new Person("Alice", 20));persons.add(new Person("Bob", 25));persons.add(new Person("Alice", 20));persons.add(new Person("Charlie", 30));// 使用HashSet去重复Set<String> uniqueNames = new HashSet<>();List<Person> uniquePersons = new ArrayList<>();for (Person person : persons) {if (uniqueNames.add(person.getName())) {uniquePersons.add(person);}}// 打印去重后的List对象for (Person person : uniquePersons) {System.out.println(person.getName() + " " + person.getAge()); }}}class Person {private String name;private int age;public Person(String name, int age) { = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}}```运行上述代码，输出结果为：```Alice 20Bob 25Charlie 30```方法二：使用Java 8的Stream API去重复Java 8引入了Stream API，提供了一种函数式编程的方法来处理集合数据。

Java实现⽐较两个List集合是否相等/*** ⽐较两个List集合是否相等* <p>注：1. 如果⼀个List的引⽤为<code>null</code>，或者其包含的元素个数为0，那么该List在本逻辑处理中都算作空；* <p>2. 泛型参数E涉及到对象，所以需要确保正确实现了对应对象的<code>equal()</code>⽅法。

* @param list1* @param list2* @return*/public static <E>boolean isListEqual(List<E> list1, List<E> list2) {// 两个list引⽤相同（包括两者都为空指针的情况）if (list1 == list2) {return true;}// 两个list都为空（包括空指针、元素个数为0）if ((list1 == null && list2 != null && list2.size() == 0)|| (list2 == null && list1 != null && list1.size() == 0)) {return true;}// 两个list元素个数不相同if (list1.size() != list2.size()) {return false;}// 两个list元素个数已经相同，再⽐较两者内容// 采⽤这种可以忽略list中的元素的顺序// 涉及到对象的⽐较是否相同时，确保实现了equals()⽅法if (!list1.containsAll(list2)) {return false;}return true;}。

java list的equals方法Java中的List是一种常用的数据结构，它允许我们存储和操作一组有序的元素。

List接口定义了一系列方法来操作列表中的元素，其中之一是equals方法。

在本文中，我们将深入探讨List的equals方法，并逐步回答与其相关的问题。

# 一、什么是List的equals方法？List的equals方法是用来比较两个列表是否相等的。

该方法继承自Collection接口，比较的基本原则是判断两个列表的元素是否相等以及元素的顺序是否相同。

如果两个列表的大小不同或者元素的顺序不同，equals方法将返回false；否则，如果两个列表中的所有元素均相等且顺序相同，equals方法将返回true。

# 二、如何正确使用List的equals方法？1. 使用equals方法前应先确保两个列表的大小相等，可以通过比较它们的size()方法的返回值来判断。

2. 在比较两个列表的元素时，可以使用List的get方法来获取每个位置上的元素，然后使用equals方法比较它们是否相等。

3. 如果元素是自定义对象，可以重写equals方法来实现更精确的比较。

在重写equals方法时应注意保持equals方法的对称性、传递性和一致性。

下面是一个示例代码，演示了如何使用List的equals方法比较两个列表：javaList<Integer> list1 = new ArrayList<>();list1.add(1);list1.add(2);list1.add(3);List<Integer> list2 = new ArrayList<>();list2.add(1);list2.add(2);list2.add(3);System.out.println(list1.equals(list2)); 输出true# 三、List的equals方法的时间复杂度是多少？List的equals方法的时间复杂度是O(n)，其中n是列表的大小。

java中List对象列表实现去重或取出及排序的⽅法前⾔因为在⾯试的时候碰到⼏次list的去重和排序，觉着有必要给⼤家总结⼀下具体的⽅法，分享出来供⼤家学习参考，话不多说了，来⼀起看看下⾯介绍的⼀种做法：⼀、list去重1.1 实体类StudentList<Student>容量10k以上，要求去重复。

这⾥Student的重复标准是属性相同，因此需要重写equals和hashcode⽅法，不知道有⼏个可以⼿写出来。

student的equals⽅法：public void equals(Object o){if(this == o) retun true;if(!(o instanceof Student)) return false;Student stu = (Studend)o;if(id!=stu.id) return false;if(age!=stu.age) return false;return name!=null ? name.equals() : ==null;}这⾥只要记住宗旨是⽐较Student的属性即可，如果属性相同则相等。

先考虑地址相等，然后类型匹配instanceof。

接下来是各种属性，int属性直接双等号⽐较，String类型需要判断是否为null，如果是null则都是null返回true，如果不是null则⽐较equals。

student的hashcode⽅法：public int hashCode(){int result = id;reuslt = 31*id +(name!=null?name.hashCode():0);reuslt = 31*age;return reuslt;}hashCode是为了hash表计算做辅助，⽅便快速查找。

因此hash算法的结果要尽量的散列。

这⾥⽤到31，这个31在别的博客中看到的原因是这样的： obj*31==obj<<5-obj.左移5位相当乘以2的5次⽅，就是32.null的hashCode为空。

Java中对List去重Stream去重的解决方法在Java中对List进行去重操作，可以使用Stream流进行处理。

Java8引入的Stream API提供了强大的功能来处理集合数据，包括去重功能。

下面是多种方法实现List去重的方式，使用Stream API进行操作。

1. 使用distinct(方法：Stream提供了distinct(方法，可以用于去除重复的元素。

该方法使用equals(方法来判断两个对象是否相等。

```javaList<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 5, 4, 3, 2, 1);List<Integer> distinctList =list.stream(.distinct(.collect(Collectors.toList();```上述示例中，将重复的元素去除后，得到了不重复的元素集合。

2.自定义比较器：有时候，需要根据对象的一些属性或者几个属性来进行判断两个对象是否相等。

可以使用自定义的比较器来实现。

```javaclass Personprivate String name;private int age;// getters and setterspublic boolean equals(Object obj)if (obj == this)return true;}if (obj == null ， obj.getClass( != this.getClass() return false;}Person other = (Person) obj;return name.equals() && age == other.age; }public int hashCodreturn Objects.hash(name, age);}List<Person> list = Arrays.asListnew Person("John", 25),new Person("Alice", 30),new Person("John", 25)List<Person> distinctList =list.stream(.distinct(.collect(Collectors.toList();```上述示例中，Person类重写了equals(方法和hashCode(方法，根据name和age属性来判断两个Person对象是否相等。

Java 中 equals() 方法的使用方法本文介绍了 Java 中 equals() 方法的用法，包括其作用、参数和注意事项。

Java 中的 equals() 方法是 Object 类中的方法，用于比较两个对象的值是否相等。

该方法的默认实现是比较两个对象的引用地址，如果引用地址相等，则返回 true，否则返回 false。

在 Java 中，如果需要比较两个对象的值是否相等，通常需要覆盖 equals() 方法。

覆盖 equals() 方法时，需要遵守以下规则: 1. 自反性：如果两个对象相等，则 equals() 方法应该返回true。

2. 对称性：如果对象 A 等于对象 B，则对象 B 也应该等于对象 A。

3. 传递性：如果对象 A 等于对象 B，且对象 B 等于对象 C，则对象 A 也应该等于对象 C。

4. 空值比较：如果一个对象为 null，则 equals() 方法应该返回 false。

如果两个对象都为 null，则 equals() 方法应该返回true。

5. 避免重复计算：如果 equals() 方法的计算成本很高，应该避免在循环中多次调用。

下面是一个覆盖 equals() 方法的示例代码:```javapublic class Person implements Comparable<Person> { private String name;private int age;public Person(String name, int age) { = name;this.age = age;}@Overridepublic boolean equals(Object o) {if (o == this) {return true;}if (o instanceof Person) {Person other = (Person) o;return .equals(name) && other.age == age; }return false;}}```在上面的代码中，Person 类实现了 Comparable 接口，并覆盖了 equals() 方法。

JAVA中List对象去除重复值的⽅法 JAVA中List对象去除重复值，⼤致分为两种情况，⼀种是List<String>、List<Integer>这类，直接根据List中的值进⾏去重，另⼀种是List<User>这种，List中存的是javabean对象，需要根据List中对象的某个值或某⼏个值进⾏⽐较去重。

⽅法如下：⼀、List<String>、List<Integer>对象去重复值。

这种情况的话，处理起来⽐较简单，通过JDK1.8新特性stream的distinct⽅法，可以直接处理。

1 List<String> list1 = Arrays.asList("a", "b", "c", "a", new String("c"));2 list1.stream().distinct().forEach(System.out::println);34 List<Integer> list2 = Arrays.asList(1, 2, 3, 1, new Integer(2));5 list2.stream().distinct().forEach(System.out::println);⼆、List<User>对象去重复值。

这种的话，不能直接⽐较List中的对象，需要重写bean对象的equals和hashCode⽅法，然后通过放⼊Set集合来⾃动去重，具体例⼦如下。

对象实体：1 @Data2 @AllArgsConstructor3public class User {4private String id;5private String name;6private int age;78public boolean equals(Object obj) {9 User u = (User) obj;10return name.equals();11 }1213public int hashCode() {14 String in = name;15return in.hashCode();16 }17 }以上例⼦中就是通过⽐较姓名相同，即认为对象相等。

javalist的用法详解java list的用法详解java中可变数组的原理就是不断的创建新的数组，将原数组加到新的数组中。

以下是店铺搜索整理的关于java list的用法详解，需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!|--List:元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复（角标1上有个3，角标2上也可以有个3）因为该集合体系有索引，|-- ArrayList：底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）（特点是查询很快，但增删较慢）线程不同步|-- LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）|-- Vector：底层是数组数据结构线程同步（数组长度是可变的百分之百延长）（无论查询还是增删都很慢，被ArrayList替代了）List：特有的方法，凡是可以操作角标的方法都是该体系特有的方法增代码如下:boolean add(int index, E element)boolean addAll(index,Collection)代码如下:public static void List_add(){ArrayList a1 = new ArrayList();a1.add("java");a1.add("php");//List集合中的元素可以重复a1.add(".net");System.out.println("原集合："+a1);a1.add(1, "Flash");a1.add(0, "ps");System.out.println(a1);ArrayList a2 = new ArrayList();a2.add("javascript");a2.add("3dMax");a2.add("IBM");a1.addAll(0, a2);System.out.println(a1);}删除指定位置的元素代码如下:boolean remove(int index)代码如下:public static void List_remove(){ArrayList a1 = new ArrayList();a1.add("javascript");a1.add("php");a1.add("flash");System.out.println("原集合："+a1);a1.remove(0);System.out.println(a1);}修改指定角标的元素 set(int index, E element) 返回的是修改的那个元素代码如下:public static void List_set() {ArrayList a1 = new ArrayList();a1.add("javascript");a1.add("php");a1.add(".net");System.out.println("原集合："+a1);a1.set(1, "falsh");System.out.println(a1);}查代码如下:get(int index) 返回列表中指定位置的元素subList(int fromIndex, int toIndex) 返回列表中指定的fromIndex（包括）和 toIndex（不包括）之间的部分元素。

java⽐较两个list是否相同equals的代码详解⽐较两个list是否相同，⼀般我⽤数组⾃带的函数equals，如：public int updateTemplateByVO(ContentTemplateVO contentTemplateVO) throws Exception {int flag = 0;if (null == contentTemplateVO) {return flag;}//⽐较新编辑的模板参数是否与原有的参数相同//新的参数数组List<String> stringList = getParamListFromTemplateContent(contentTemplateVO);//旧的参数数组List<TContentTemplateParam> tContentTemplateParamList = selectTemplateParamsByTemplateId(contentTemplateVO.getId()); List<String> paramList = new ArrayList<String>(); //将从表⾥获取的数组重新整理成包含相同类型的list数组for (TContentTemplateParam contentParam : tContentTemplateParamList) {paramList.add(contentParam.getParamName());} //⽐较两个listBoolean sameSortFlag = stringList.equals(paramList);String content = contentTemplateVO.getSmsMsgContent();StringBuilder stringBuilder = new StringBuilder(content);//参数有修改则重新排序if (!sameSortFlag) {String newContent = rightSortForContentParam(contentTemplateVO.getSmsMsgContent());contentTemplateVO.setSmsMsgContent(newContent);}contentTemplateVO.setUpdateTime(DateUtil.getNowAsDate());TContentTemplate tContentTemplate = ModelCopyUtil.copy(contentTemplateVO, TContentTemplate.class);flag = tContentTemplateMapper.updateByPrimaryKeySelective(tContentTemplate);if (flag == 1 && (!sameSortFlag)) {//先删除对应模板的参数配置deleteContentTemplateParam(contentTemplateVO);//重新配置模板参数addContentTemplateParam(contentTemplateVO);}return flag;}内容扩展：Java的俩个list之间⽐较，判断是否⼀致的⽅法前⽂我看了⼀篇博客，是关于判断俩个list的。

java list查重算法有几种算法可以用来查找Java的List中的重复元素。

1. 暴力法：使用两个嵌套的循环，比较每对元素是否相等。

这种方法的时间复杂度为O(n^2)，其中n是列表的大小。

javaList<Integer> list = new ArrayList<>();添加元素到列表中for (int i = 0; i < list.size(); i++) {for (int j = i + 1; j < list.size(); j++) {if (list.get(i).equals(list.get(j))) {重复元素的处理逻辑}}}2. 使用HashSet：遍历列表中的每个元素，将其添加到HashSet中。

如果添加失败，则说明元素已经存在于HashSet中，即为重复元素。

这种方法的时间复杂度为O(n)，其中n是列表的大小。

javaList<Integer> list = new ArrayList<>();添加元素到列表中Set<Integer> set = new HashSet<>();for (Integer num : list) {if (!set.add(num)) {重复元素的处理逻辑}}3. 使用HashMap：遍历列表中的每个元素，将元素作为键添加到HashMap 中，值为出现次数。

如果值大于1，则说明元素重复。

这种方法的时间复杂度为O(n)，其中n是列表的大小。

javaList<Integer> list = new ArrayList<>();添加元素到列表中Map<Integer, Integer> map = new HashMap<>();for (Integer num : list) {map.put(num, map.getOrDefault(num, 0) + 1);}for (Map.Entry<Integer, Integer> entry : map.entrySet()) { if (entry.getValue() > 1) {重复元素的处理逻辑}}。

java⼤数据⽐较两个list集合的差值有这么个场景，每天需要定时任务插⼊增量数据。

如果通过接⼝获取的直接根据时间过滤，那么就能直接就可以插⼊库中。

但有时获取到的并不是增量数据，⽐如微信公众号获取关注者列表时，获取到的是全量数据，这样每天就得将全量数据与库中进⾏⽐较，只有库中不存在数据才进⾏插⼊。

这就有了两个list⽐较差值的问题。

以前在处理该问题时，会遍历全量中的list，然后判断每个对象是否已在数中存在，如果不存在就放到⼀个临时List中，最后返回的临时List就是增量数据了，代码如下：private List<String> getNeedAddOpenidList(List<String> allOpenidList, List<String> dbOpenidList) {if (dbOpenidList != null && !dbOpenidList.isEmpty()) {List<String> resultList = new ArrayList<String>();if (allOpenidList != null && !allOpenidList.isEmpty()) {for (String openid : allOpenidList) {if (!dbOpenidList.contains(openid)) {resultList.add(openid);}}}return resultList;} else {return allOpenidList;}}但这种在处理⼏千条数据还好，等上万、或上⼗万时，执⾏效率就会很低。

即便我后来⽤list1.removeAll(list2)时，在处理40万条数据时，10分钟根本处理不完。

后来⽤如下⽅法，瞬间完成：private List<String> getNeedAddOpenidList(List<String> allOpenidList, List<String> dbOpenidList) {if (dbOpenidList != null && !dbOpenidList.isEmpty()) {Map<String, String> dataMap = new HashMap<String, String>();for (String id : dbOpenidList) {dataMap.put(id, id);}List<String> newList = new ArrayList<String>();for (String id : allOpenidList) {if (!dataMap.containsKey(id)) {newList.add(id);}}return newList;} else {return allOpenidList;}}1.将数据库中的list转成⼀个map集合2.遍历获取到的全量数据，通过主键或唯⼀索引之类的字段进⾏⽐较3.如果map.get(key)不存在，放到⼀个临时List中4.最后将临时List返回如果以后有更⾼效率的⽅法，还会进⾏更新。

equals 比较 list 的原理equals方法是用于比较两个对象是否相等的方法，对于List对象而言，equals方法用于比较两个List对象是否具有相同的元素顺序和元素内容。

List接口是Java集合框架中的一种有序集合，它允许存储重复元素并且允许插入多个null元素。

List接口继承了Collection 接口，所以List对象也具备了Collection接口中定义的equals 方法。

在List接口中，equals方法的实现如下：```public boolean equals(Object obj) {if (obj == this)return true;if (!(obj instanceof List))return false;ListIterator<E> e1 = listIterator();ListIterator<?> e2 = ((List<?>) obj).listIterator();while (e1.hasNext() && e2.hasNext()) {E o1 = e1.next();Object o2 = e2.next();if (!(o1==null ? o2==null : o1.equals(o2)))return false;}return !(e1.hasNext() || e2.hasNext());}```上述代码中，首先进行了两个对象的引用比较，如果两个对象引用相同，则直接返回true。

如果传入的对象不是List类型，则直接返回false。

接着通过ListIterator遍历两个List对象，依次比较两个List中的元素。

当发现不相等的元素时，返回false。

如果两个List对象长度不同，则返回false。

如果遍历结束后没有发现不相等的元素且两个List长度相同，则返回true。

JavaList实体类去重今天写了⼀段代码判断list中是否包含某个实体openSubjectDTO,不包含就添加进去,发现不好使if(!subjectList.contains(openSubjectDTO)){subjectList.add(openSubjectDTO);}后来发现是openSubjectDTO类中缺少两个⽅法如下:List 去除重复Object对象：对象重复是指对象⾥⾯的变量的值都相等，并不定是地址。

list集合存储的类型是基础类型还⽐较好办，直接把list集合转换成set集合就会⾃动去除。

当set集合存储的是对象类型时，需要在对象的实体类⾥⾯重写public boolean equals(Object obj) {} 和 public int hashCode() {} 两个⽅法。

List特点：元素有放⼊顺序，元素可重复Map特点：元素按键值对存储，⽆放⼊顺序Set特点：元素⽆放⼊顺序，元素不可重复（注意：元素虽然⽆放⼊顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）新建⼀个实体类[java]1. public class User {2. private String id;3. private String name;4. private String age;5. private String address;6.7. public String getId() {8. return id;9. }10.11. public void setId(String id) {12. this.id = id;13. }14.15. public String getName() {16. return name;17. }18.19. public void setName(String name) {20. = name;21. }22.23. public String getAge() {24. return age;25. }26.27. public void setAge(String age) {28. this.age = age;29. }30.31. public String getAddress() {32. return address;33. }34.35. public void setAddress(String address) {36. this.address = address;37. }38.39. @Override40. public int hashCode() {41. final int prime = 31;42. int result = 1;43. result = prime * result + ((id == null) ? 0 : id.hashCode());44. result = prime * result + ((name == null) ? 0 : name.hashCode());45. result = prime * result + ((age == null) ? 0 : age.hashCode());46. result = prime * result + ((address == null) ? 0 : address.hashCode());47. return result;48. }49.50. @Override51. public boolean equals(Object obj) {52. if (this == obj) {53. return true;54. }55. if (obj == null) {56. return false;57. }58. if (getClass() != obj.getClass()) {59. return false;60. }61. User other = (User) obj;62. if (id == null) {63. if (other.id != null) {64. return false;65. }66. } else if (!id.equals(other.id)) {67. return false;68. }69. if (name == null) {70. if ( != null) {71. return false;72. }73. } else if (!name.equals()) {74. return false;75. }76. if (age == null) {77. if (other.age != null) {78. return false;79. }80. } else if (!age.equals(other.age)) {81. return false;82. }83. if (address == null) {84. if (other.address != null) {85. return false;86. }87. } else if (!address.equals(other.address)) {88. return false;89. }90. return true;91. }92. }调⽤即可[java]1. private static List<User> removeListDuplicateObject(List<User> list) {2. System.out.println(Arrays.toString(list.toArray()));3. Set<User> set = new HashSet<User>();4. set.addAll(list);5. System.out.println(Arrays.toString(set.toArray()));6. List<User> listnewList = new ArrayList<User>(set);7. return listnewList;8. }。