写在前面
Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！谢谢大家！！！
如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多点赞加关注呀！❤❤❤ 爱你们！！！
目录
2.5 Eclipse/IDEA工具里hashCode()的重写
【往期回顾】
1. Collection子接口之一：List接口
1.1 List接口概述
- 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
- List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
1.2 List接口方法
List除了从 Collection 集合继承的方法外， List 集合里添加了一些根据索引来操作集合元素的方法。
- void add(int index, Object ele):在index位置插入ele元素
- boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
- Object get(int index):获取指定index位置的元素
- int indexOf(Object obj):返回obj在集合中首次出现的位置
- int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
- Object remove(int index):移除指定index位置的元素，并返回此元素
- Object set(int index, Object ele):设置指定index位置的元素为ele
- List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
1.3 List实现类之一：ArrayList
- ArrayList 是 List 接口的典型实现类、主要实现类
- 本质上，ArrayList是对象引用的一个”变长”数组
- ArrayList的JDK1.8之前与之后的实现区别？
- JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
- JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
- Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合
面试题：
public void testListRemove() { List list = new ArrayList(); list.add(1); list.add(2); list.add(3); updateList(list); System.out.println(list);// } private static void updateList(List list) { list.remove(2); }答案：输出[1, 2]，此时删除的是索引位置为2的对象，并不是删除值为2的对象
修改：
/* 区分List中remove(int index)和remove(Object obj) */ public void testListRemove() { List list = new ArrayList(); list.add(1); list.add(2); list.add(3); updateList(list); System.out.println(list); } private void updateList(List list) { list.remove(new Integer(2)); }此时输出[1, 3]，删除的是值为2的对象。
1.4 List实现类之二：LinkedList
- 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
- 新增方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()
- LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置
private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }
1.5 List 实现类之三：Vector
- Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
- 在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
新增方法：
- void addElement(Object obj)
- void insertElementAt(Object obj,int index)
- void setElementAt(Object obj,int index)
- void removeElement(Object obj)
- void removeAllElements()
面试题：请问ArrayList/LinkedList/Vector 的异同？谈谈你的理解？ ArrayList 底层是什么？扩容机制？Vector 和 ArrayList 的最大区别 ?ArrayList和LinkedList的异同
- 二者都线程不安全，相对线程安全的Vector，执行效率高。
- 此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
ArrayList和Vector的区别
- Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。
1.6 List接口代码演示
import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; /** * 1. List接口框架 * |----Collection接口：单列集合，用来存储一个一个的对象 * |----List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组 * |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储 * |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储 * |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储 * * 2. ArrayList的源码分析： * 2.1 jdk 7情况下 * ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData * list.add(123);//elementData[0] = new Integer(123); * ... * list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。 * 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。 * * 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity) * * 2.2 jdk 8中ArrayList的变化： * ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组 * * list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0] * ... * 后续的添加和扩容操作与jdk 7 无异。 * 2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象 * 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。 * * 3. LinkedList的源码分析： * LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null * list.add(123);//将123封装到Node中，创建了Node对象。 * * 其中，Node定义为：体现了LinkedList的双向链表的说法 * private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } } * * 4. Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。 * 在扩容方面，默认扩容为原来的数组长度的2倍。 * * 面试题：ArrayList、LinkedList、Vector三者的异同？ * 同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据 * 不同：见上 * * 5. List接口中的常用方法 */ public class ListTest { /* void add(int index, Object ele):在index位置插入ele元素 boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来 Object get(int index):获取指定index位置的元素 int indexOf(Object obj):返回obj在集合中首次出现的位置 int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置 Object remove(int index):移除指定index位置的元素，并返回此元素 Object set(int index, Object ele):设置指定index位置的元素为ele List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合 总结：常用方法 增：add(Object obj) 删：remove(int index) / remove(Object obj) 改：set(int index, Object ele) 查：get(int index) 插：add(int index, Object ele) 长度：size() 遍历：① Iterator迭代器方式 ② 增强for循环 ③ 普通的循环 */ @Test public void test1() { ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Tom", 12)); list.add(456); System.out.println(list); //void add(int index, Object ele):在index位置插入ele元素 list.add(1, "BB"); System.out.println(list); //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来 List list1 = Arrays.asList(1, 2, 3); list.addAll(list1); //list.add(list1); System.out.println(list.size());//9 //Object get(int index):获取指定index位置的元素 System.out.println(list.get(0)); } @Test public void test2() { ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Tom", 12)); list.add(456); //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1. int index = list.indexOf(4567); System.out.println(index);//-1 //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1. System.out.println(list.lastIndexOf(456));//4 //Object remove(int index):移除指定index位置的元素，并返回此元素 Object obj = list.remove(0); System.out.println(obj);//123 System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456] //Object set(int index, Object ele):设置指定index位置的元素为ele list.set(1, "CC"); System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456] //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合 List subList = list.subList(2, 4); System.out.println(subList); System.out.println(list); } @Test public void test3() { ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); //方式一：Iterator迭代器方式 Iterator iterator = list.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } System.out.println("***************"); //方式二：增强for循环 for (Object obj : list) { System.out.println(obj); } System.out.println("***************"); //方式三：普通for循环 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } }
2. Collection接口之二：Set接口
2.1 Set 接口概述
- Set接口是Collection的子接口，set接口没有提供额外的方法
- Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
- Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法
2.2 Set实现类之一：HashSet
- HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
- HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
HashSet 具有以下特点：
- 不能保证元素的排列顺序
- HashSet 不是线程安全的
- 集合元素可以是 null
HashSet 集合判断两个元素相等的标准 ：
- 两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
- 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Objectobj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
向HashSet中添加元素的过程：
- 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）
- 如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
- 如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
- 底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128....等）
2.3 重写 hashCode() 方法的基本原则
- 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
- 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()方法的返回值也应相等。
- 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
2.4 重写 equals() 方法的基本原则
以自定义的Customer类为例，何时需要重写equals()？
- 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
- 因此，违反了“相等的对象必须具有相等的散列码”。
- 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
2.5 Eclipse/IDEA工具里hashCode()的重写
- 以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。
问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？
- 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
- 并且31只占用5bits,相乘造成数据溢出的概率较小。
- 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
- 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)
2.6 Set实现类之二：LinkedHashSet
- LinkedHashSet 是 HashSet 的子类
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
- LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
- LinkedHashSet 不允许集合元素重复。
2.7 Set实现类之三：TreeSet
- TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
- TreeSet底层使用红黑树结构存储数据
- 新增的方法如下： (了解)
- Comparator comparator()
- Object first()
- Object last()
- Object lower(Object e)
- Object higher(Object e)
- SortedSet subSet(fromElement, toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)
- TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
- TreeSet和后面要讲的TreeMap采用红黑树的存储结构
- 特点：有序，查询速度比List快
2.8 自然排序
- 向 TreeSet 中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
- 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
- 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 方法比较返回值。
- 当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0。否则，让人难以理解。
2.9 定制排序
- TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
- 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
- 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
- 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
- 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0。
2.10 Set接口代码演示
public class User implements Comparable{ private String name; private int age; public User() { } public User(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object o) { System.out.println("User equals()...."); if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; if (age != user.age) return false; return name != null ? name.equals(user.name) : user.name == null; } @Override public int hashCode() { //return name.hashCode() + age; int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } //按照姓名从大到小排列,年龄从小到大排列 @Override public int compareTo(Object o) { if(o instanceof User){ User user = (User)o; // return -this.name.compareTo(user.name); int compare = -this.name.compareTo(user.name); if(compare != 0){ return compare; }else{ return Integer.compare(this.age,user.age); } }else{ throw new RuntimeException("输入的类型不匹配"); } } }import org.junit.Test; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; /** * 1. Set接口的框架： * * |----Collection接口：单列集合，用来存储一个一个的对象 * |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合” * |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值 * |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历 * 对于频繁的遍历操作，LinkedHashSet效率高于HashSet. * |----TreeSet：可以按照添加对象的指定属性，进行排序。 * * 1. Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。 * * 2. 要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals() * 要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码 * 重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。 */ public class SetTest { /* 一、Set：存储无序的、不可重复的数据 以HashSet为例说明： 1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。 2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。 二、添加元素的过程：以HashSet为例： 我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值， 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断 数组此位置上是否已经有元素： 如果此位置上没有其他元素，则元素a添加成功。 --->情况1 如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值： 如果hash值不相同，则元素a添加成功。--->情况2 如果hash值相同，进而需要调用元素a所在类的equals()方法： equals()返回true,元素a添加失败 equals()返回false,则元素a添加成功。--->情况2 对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。 jdk 7 :元素a放到数组中，指向原来的元素。 jdk 8 :原来的元素在数组中，指向元素a 总结：七上八下 HashSet底层：数组+链表的结构。 */ @Test public void test1() { Set set = new HashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add("CC"); set.add(new User("Tom", 12)); set.add(new User("Tom", 12)); set.add(129); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } //LinkedHashSet的使用 //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个 //数据和后一个数据。 //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet @Test public void test2() { Set set = new LinkedHashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add("CC"); set.add(new User("Tom", 12)); set.add(new User("Tom", 12)); set.add(129); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } }
2.11 TreeSet代码演示
import org.junit.Test; import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; public class TreeSetTest { /* 1.向TreeSet中添加的数据，要求是相同类的对象。 2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序（Comparator） 3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals(). 4.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals(). */ @Test public void test1() { TreeSet set = new TreeSet(); //失败：不能添加不同类的对象 // set.add(123); // set.add(456); // set.add("AA"); // set.add(new User("Tom",12)); //举例一： // set.add(34); // set.add(-34); // set.add(43); // set.add(11); // set.add(8); //举例二： set.add(new User("Tom", 12)); set.add(new User("Jerry", 32)); set.add(new User("Jim", 2)); set.add(new User("Mike", 65)); set.add(new User("Jack", 33)); set.add(new User("Jack", 56)); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } //User{name='Tom', age=12} //User{name='Mike', age=65} //User{name='Jim', age=2} //User{name='Jerry', age=32} //User{name='Jack', age=33} //User{name='Jack', age=56} } @Test public void test2() { Comparator com = new Comparator() { //按照年龄从小到大排列 @Override public int compare(Object o1, Object o2) { if (o1 instanceof User && o2 instanceof User) { User u1 = (User) o1; User u2 = (User) o2; return Integer.compare(u1.getAge(), u2.getAge()); } else { throw new RuntimeException("输入的数据类型不匹配"); } } }; TreeSet set = new TreeSet(com); set.add(new User("Tom", 12)); set.add(new User("Jerry", 32)); set.add(new User("Jim", 2)); set.add(new User("Mike", 65)); set.add(new User("Mary", 33)); set.add(new User("Jack", 33)); set.add(new User("Jack", 56)); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } //User{name='Jim', age=2} //User{name='Tom', age=12} //User{name='Jerry', age=32} //User{name='Mary', age=33} //User{name='Jack', age=56} //User{name='Mike', age=65} } }
3. 练习
import org.junit.Test; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List; public class CollectionTest { @Test public void test1() { Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(343); coll.add(343); coll.forEach(System.out::println); } //练习：在List内去除重复数字值，要求尽量简单 public static List duplicateList(List list) { HashSet set = new HashSet(); set.addAll(list); return new ArrayList(set); } @Test //练习：在List内去除重复数字值，要求尽量简单 public void test2() { List list = new ArrayList(); list.add(new Integer(1)); list.add(new Integer(2)); list.add(new Integer(2)); list.add(new Integer(4)); list.add(new Integer(4)); List list2 = duplicateList(list); for (Object integer : list2) { System.out.println(integer); } } @Test public void test3() { HashSet set = new HashSet(); Person p1 = new Person(1001, "AA"); Person p2 = new Person(1002, "BB"); set.add(p1); set.add(p2); System.out.println(set);//[Person{id=1002, name='BB'}, Person{id=1001, name='AA'}] p1.name = "CC"; set.remove(p1); //remove之前会判断Hash值是否相等，CC和AA的哈希值不同，找到的索引位置不一样，相当于没remove System.out.println(set); //[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}] set.add(new Person(1001, "CC")); //现在1001 CC 所在位置的索引是通过1001 AA算出来的，此时添加1001 CC算出的索引位置和之前的不同，可以添加 System.out.println(set); //[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}] set.add(new Person(1001, "AA")); //add时算出的索引位置上已经有元素，但是已经不是1001 CC了，之前把AA改成了CC，没有重复，可以添加 System.out.println(set); //[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}] } }public class Person { int id; String name; public Person(int id, String name) { this.id = id; this.name = name; } public Person() { } @Override public String toString() { return "Person{" + "id=" + id + ", name='" + name + '\'' + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; if (id != person.id) return false; return name != null ? name.equals(person.name) : person.name == null; } @Override public int hashCode() { int result = id; result = 31 * result + (name != null ? name.hashCode() : 0); return result; } }
结语
本人会持续更新文章的哦！希望大家一键三连，你们的鼓励就是作者不断更新的动力
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
