Set接口基本介绍：
（1）无序（添加和取出的顺序不一致），没有索引
（2）不允许重复元素，所以最多包含一个null
(3)JDK API中Set接口的实现类有：
其中set接口的已知的实现类有：
AbstractSet, ConcurrentHashMap.KeySetView, ConcurrentSkipListSet, CopyOnWriteArraySet, EnumSet, HashSet, JobStateReasons, LinkedHashSet, TreeSet
Set接口的常用方法：
和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样
Set接口的遍历方式：
同Collection的遍历方式一样，因为Set接口是Collection接口的子接口
1.可以使用迭代器
2.增强for
3.不能使用索引的方式来获取。
set的方法如下所示：
体现set特点的代码设计如下所示：
package com.rgf.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
@SuppressWarnings({"all"})
public class SetMethod {
public static void main(String[] args) {
//1.以Set接口的实现类HashSet来讲解Set接口的方法
//2.set接口的实现类的对象（set接口对象），不能存放重复的元素，可以添加一个null
//3.set 接口对象存放数据是无序的（即添加的顺序和取出的顺序不一致）
//4.注意：取出的顺序是固定的，虽然不是添加的顺序，但是是固定的。
Set set = new HashSet();
set.add("jdbc");
set.add("java");
set.add("java"); //重复数据
set.add("luck");
set.add("rgf");
set.add("ypl");
set.add(null);
set.add(null);//再次添加null
for (int i = 0; i < 3; i++) {
System.out.println("set="+set);
}
//遍历
//1.使用迭代器
System.out.println("======迭代器遍历======");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("set="+next);
}
//删除元素
set.remove(null);
//2.使用增强for循环
System.out.println("======增强for循环");
for (Object o :set) {
System.out.println("set="+o);
}
//set接口对象不能通过索引来获取。无序的，无法通过索引进行获取
}
}
运行界面如下所示：
HashSet的全面说明：
（1）HashSet实现了Set接口
（2）HashSet实际上是HashMap.
(3)可以存放null值，但是只能有一个null
(4)HashSet不保证元素是有序的，取决于hash后，再确定索引的结果。（即不保证存放元素的顺序和取出顺序一致）
（5）不能有重复元素/对象，在前面Set接口使用已经体现过。
我们设计代码如下所示：
package com.rgf.set;
import java.util.HashSet;
import java.util.Set;
@SuppressWarnings({"all"})
public class HashSet01 {
public static void main(String[] args) {
Set set = new HashSet();
//1.在执行add方法后，会返回一个boolean值
//2.如果添加成功，返回true,否则返回false.
//3.可以通过remove指定删除哪个对象
System.out.println(set.add("jdbc"));//T
System.out.println(set.add("java"));//T
System.out.println(set.add("java"));//F
System.out.println(set.add("luck"));//T
System.out.println(set.add("rgf"));//T
set.remove("java");
System.out.println("set="+set); //3个
set = new HashSet();
System.out.println("set="+set);
//4.HashSet不能添加相同的元素/数据
set.add("java");//添加成功
set.add("java"); //重复数据，加入不了
set.add(new Dog("jdk")); //可以添加成功
set.add(new Dog("jdk"));//可以添加成功
System.out.println("set="+set);
//在加深一下，非常经典的面试题。
//看源码，做分析，
//去看他的源码，即add到底发生了什么>=底层机制
set.add(new String("rgf"));//添加成功
set.add(new String("rgf"));//加入不了
System.out.println("set="+set);
}
}
class Dog{//定义了Dog类
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
运行之后如下所示：
HashSet底层机制说明：
HashSet底层是HashMap,HashMap底层是（数组+链表+红黑树）当他的链表到达一定量的时候，而且满足数组的大小，在某一个范围的时候，他就会把这个链表进行一个树化，变成一棵红黑树。
我们设计代码如下所示：
package com.rgf.set;
@SuppressWarnings({"all"})
public class HashSetStructure {
public static void main(String[] args) {
//模拟一个HashSet的底层（HashMap的底层结构）
//1.创建一个数组，数组的类型是Node []
//2.有些人直接把Node [ ]数组称为表
Node [] table=new Node[16];
System.out.println("table="+table);
//3.创建结点
Node john = new Node("john", null);
table[2]=john;
Node jack = new Node("jack", null);
john.next=jack;//将jack结点挂载到john后面
Node rose = new Node("Rose", null);
jack.next=rose; //将rose结点挂载到jack后面
Node lucy = new Node("lucy", null);
table[3]=lucy;//把lucy放到table表的索引为3的位置。
System.out.println("table="+table);
}
}
class Node{ //结点，存储数据，可以指向下一个结点，从而形成链表
Object item; //存放数据
Node next; //指向下一个结点
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
}
运行界面如下所示：
我们进行debug断点如下所示：
我们所实现的机制如下所示：
HashSet底层机制说明：
1.HashSet底层是HashMap
2.添加一个元素时，先得到这个元素的hash值（hash值是一个数字，会调用他的方法和算法来计算hash值），通过hash值，会转成一个索引值
3.找到存储数据表table，看这个索引位置是否已经存放的有元素
4.如果没有，直接加入
5.如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后
6.在java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY(默认64),就会进行树化（红黑树）
我们进入底层源码进行分析：
我们的代码设计如下所示：
package com.rgf.set;
import java.util.HashSet;
@SuppressWarnings({"all"})
public class HashSetSource {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println("set="+hashSet);
}
}
我们开始进行Debug:我们进入底层构造器：
我们之后进入add方法的底层：
public boolean add(E e) {
return map.put(e, PRESENT)==null; //(static)PRESENT = new Object();
}其中的e已经是我们要添加的字符串常量java了。 其中的PRESENT为HashSet里面的一个东西，，是一个final类型的静态的一个对象，这个对象其实没有什么意义，在这里起到一个占位的目的，为了让Hashset使用到Hashmap，他的value统一放的都是Object.
private static final Object PRESENT = new Object();我们继续进入：即为put方法
K会发生变化，但是value始终是 PRESENT ，是共享的
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}put里面的key为java,而其中的value为上一步put里面的PRESENT。
该put方法会执行hash(key)方法，得到key对应的hash值。算法为：h = key.hashCode()) ^ (h >>> 16)，降低hash冲突机率
hash值并不完全等价于hashCode.
我们要进入里面得hash（key),我们需要点击红色箭头，force:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
//hashCode为不管哪个对象都有hashCode值，是Object过来的一个方法，
//(h>>>16)无符号右移16位
/如果key=null，就返回0，如果不等于空，返回或者得到一个传进来的key对应的hash值
}我们的核心代码如下所示：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//定义了辅助变量
//if语句表示如果当前table是null，或者大小等于0.就进行第一次扩容，到16个空间
if ((tab = table) == null || (n = tab.length) == 0)
//table就是HashMap的一个数组，类型为Node[ ]数组。
n = (tab = resize()).length;
//根据刚才计算出来的key对应的hash值来计算这个key应该存放到哪一个索引位置
//(1)根据key,得到hash去计算该key应该存放到table表的哪个索引位置，并把这个位置的对象赋给辅助变量p
//(2)判断p是否为null
//(2.1)如果p为null,表示还没有存放过元素，就创建一个Node(key="java",value=PRESENT)
//而把hash也存放进去了，将来会去比较，如果再有的话，会看key对应的hash和下一步相不相等。如果相等，往后面加。而后面的null为我们之前演示的模拟代码的结点，即往后加新东西。
//(2.2)就放在该位置：newNode(hash, key, value, null);
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}我们进入HashMap的字段进行查看：里面有个table,为放Node结点的一个数组。
我们通过进行下一步，进入resize（）方法：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}经过判断，我们直接进入如下所示：
我们进入默认源码DEFAULT_INITIAL_CAPACITY：左移四位，位左移为乘以2.：1X2X2X2X2=16
里面还设计了一个临界值：newThr:临界值的作用是就是我们有16个位置，但是当已经占满12个位置的时候，我们就要进行扩容。以避免在满的时候才进行扩容。
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);我们继续运行下去发现如下所示：
我们继续进行退出即可。这个时候table的容量已经为16了。
退出去之后，我们来执行如下语句：
我们已经得到了hash值，而且此时的table已经变成了16个大小了。
if ((p = tab[i = (n - 1) & hash]) == null)我们来计算K对应的hash值应该是在table表的哪一个索引位置去存放。我们通过这行代码把计算出的hash值赋给p,p可能为空，也可能已经有对象了。
我们从putVal出去之后，如下所示：
我们发现此时已经存储进去了。
我们进行到这一步的时候，进行判断是否大于限定值，然后afterNodeInsertion为Hashset的实现子类所做的方法
afterNodeInsertion为一个空方法。是因为为了让Hashset的方法去实现这个子类，才去做这个动作的。
第二次add源码进行分析如下所示：
我们如上所示一步步进去putVal方法之后，如下所示：
if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;我们不会再进入该if语句，在我们第一次添加的时候，已经把这个table表已经存在了。直接执行：
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);我们选中（n-1）&hash按alt+F8即可进行计算：
我们所定位的索引还是为空的，直接就进去了。
我们发现成功把该位置存储进去了php.
我们进入我们编写的代码进行查看：
此时已经添加成功了两个。
我们下来进行填加重复代码的分析：‘
我们按以上步骤一步步进去之后，我们进入如下方法：
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);因为我们存储的值是相同的，所以这条if语句不再等于null了。我们可以很肯定的了解到，此时的通过计算出来的索引值i=3,所以我们不会进入该条if语句了，而是进入下面的else语句：
我们进行分析代码：
else { //一个开发技巧提示：在需要局部变量（辅助变量的）时候在创建 Node<K,V> e; K k; if (p.hash == hash && //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样，并且满足下面两个条件之一： （1）准备加入的key和p指向的Node结点的key是同一个对象 （2）p指向的Node结点的key的equals()和准备加入的key比较后相同 ((k = p.key) == key || (key != null && key.equals(k)))) //当前索引值索引到的位置的对象与当前对象进行比较，或者key不等于空，但是内容相同。 //这是逻辑或，一方为真，那么就是真， //就不能加入 e = p; //如果if满足的话我们就进入下一种情况进行判断 //再判断p是不是一颗红黑树 //如果是一颗红黑树，就调用putTreeVal进行添加 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); //如果以上方法仍然不满足，我们进行如下方法： //当我们经过以上判断无法判断出来的时候，这个时候我们认为他是一个链表，我们与该链表的每个结点进行比对。 //如果table对应索引位置，已经是一个链表，就使用for循环比较 //(1)依次和该链表的每一个元素比较后都不相同，则加入到该链表的最后 //注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点。 //(2)依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break。 else { for (int binCount = 0; ; ++binCount) { //死循环，只有碰见break才会进行退出。 //都不相同即可以执行该条语句。 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //判断结点是否达到8个。从而调用 treeifyBin（）方法对当前链表进行树化，转成红黑树 //注意，在转成红黑树时，要进行判断,判断条件如下： if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); //如果上面条件成立，先table扩容。 只有上面条件不成立时，才进行转成红黑树化 break; } //如果不为空，则与该链表的值进行一个一个比较， if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }我们在进行树化的时候，我们查看树化的源码如下所示：
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) // MIN_TREEIFY_CAPACITY<64的时候不会马上进行树化，进行数组的扩容 //我们会先判断该链表 resize(); else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; do { TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) hd.treeify(tab); } }我们完毕之后，发现进行到如下一步：
此时返回OldValue，不返回null，不返回null即代表失败。
我们进行源码的总结：
（1）HashSet底层是HashMap
（2）添加一个元素时，先得到hash值--会转成--->索引值
具体过程为：1.先获取元素的hash值（hashCode方法）
2.对哈希值进行运算，得出一个索引值即为要存放在哈希表中的位置号
3.如果该位置上没有其他元素，则直接存放
如果该位置上已经没有其他元素，则需要进行equals,如果相等，则不再添加，如果不相等，则以链表的方式添加。
HashSet的扩容和转成红黑树机制：
1.HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值（threshold)是16*加载因子（loadFactor)是0.75=12
我们来进行查看临界值（threshold)，我们发现他真正运用到的地方为：
++modCount;
//size就是我们每加入一个结点Node(k,v,h,next)，只要是加在hashmap里面添加了一个，无论加在数组还是链表都算,size就会进行加1.
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}我们设计代码如下所示：
package com.rgf.set;
import java.util.HashSet;
@SuppressWarnings({"all"})
public class HashSetIncrement {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
for (int i = 0; i <=7 ; i++) { //在table的某一条链表上添加了7个A对象
hashSet.add(new A(i));//
}
for (int i = 0; i <=7 ; i++) {//在table的另一条链表上添加了7个B对象
hashSet.add(new B(i));//
}
//当我们向hashset增加一个元素--->Node -->加入table表，就算是增加了一个
}
}
class B{
private int n;
public B(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 200;
}
}
class A{
private int n;
public A(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
我们在两条链表里面添加够12个，达到临界值：
此时我们继续进行下一步，如下所示：
我们发现此时出发了扩容机制：
2.如果table数组使用到了临界值12，就会扩容到16*2=32，新的临界值就是32*0.75=24，依此类推
3.在java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY(默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制。
我们下来针对结论1和结论2进行代码演示：
我们的设计的代码如下所示：
package com.rgf.set;
import java.util.HashSet;
@SuppressWarnings({"all"})
public class HashSetIncrement {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
for (int i = 0; i <= 100; i++) {
hashSet.add(i);// 1,2,3,4,5.....100
}
}
}
我们进行Debug如下所示：
我们进行一次for循环后，发现table表为16，临界值threshold为12，loadFactor为0.75
我们继续进行下一步的时候，当把12个存进去的时候，我们发现此时扩容为了32个。
我们此时的临界值也变成了24。
我们到达24的时候又出现如下所示：
我们对结论3进行代码演示：
3.在java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY(默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制。
我们设计的代码如下所示：
package com.rgf.set; import java.util.HashSet; @SuppressWarnings({"all"}) public class HashSetIncrement { public static void main(String[] args) { HashSet hashSet = new HashSet(); for (int i = 0; i <= 12; i++) { hashSet.add(new A(i));// } System.out.println("hashset="+hashSet); } } class A{ private int n; public A(int n) { this.n = n; } @Override public int hashCode() { //我们为了保证hashcode相同,我们让其返回一个固定的值，我们再底层得到key对应的hash值，我们的算法是h=key.hashCode,我们保证了hashcode值一样。从而放在一条链表，同时互不冲突。 return 100; } }我们进行debug查看如下所示：
我们发现链表里面存储的超过8后，在进行debug之后出现如下所示：
我们再次进行添加如下：
我们发现此时没有树化，而是继续进行数组扩容。
我们发现第9个元素进行的树化：
而且在扩容之后，再重新进行了hash值的计算，变成了索引从4变成了36.此时我们添加的10个数在36索引下面。
我们再添加一个数：
树化的代码如下所示：
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; do { TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) hd.treeify(tab); } }我们继续执行的时候，当i=11的时候，我们发现如下所示：
此时结点变成了TreeNode结点，我们此时已经变成了tree了。
我们进行实例练习：
练习1：定义一个Employee类，该类包含：private成员属性name,age 要求：
1.创建3个Employee放入HashSet中
2.当name和age的值相同时，认为是相同员工，不能添加到Hashset集合中。
我们在重写equals和hashcode方法过程中：
如果name和age的值相同，在使用equals时，返回true。
我们返回下一步之后，如果你认为的名字和年龄相同，就返回相同的hashcode。，我们进行选择next。
我们设计的代码如下所示：
package com.rgf.set;
import java.util.HashSet;
import java.util.Objects;
@SuppressWarnings({"all"})
public class HashSetExercise {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee("rgf",15));//OK
hashSet.add(new Employee("ypl",12));//OK
hashSet.add(new Employee("rgf",15));//加入不成功
System.out.println("hashset="+hashSet);
}
}
class Employee{
private String name;
private int age;
public Employee(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 "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//如果name和age值相同，则返回相同的hash值
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
运行界面如下所示：
我们来看重写的hashCode的源码：
@Override
public int hashCode() {
return Objects.hash(name, age);
}我们进入hash源码：
public static int hash(Object... values) {
return Arrays.hashCode(values);
}我们进入hashCode源码:
public static int hashCode(Object a[]) {
if (a == null)
return 0;
int result = 1;
for (Object element : a)
result = 31 * result + (element == null ? 0 : element.hashCode());
//把每个element取出来计算hashCode
//求result的代码为防止碰撞的一个数学算法。尽量让不同的Object数组得到的hashCode不同
return result;
}练习2：
定义一个Employee类，该类包含：private成员属性name,sal,birthday(MyDate类型），其中birthday为MyDate类型（属性包括：year,month,day), 要求：
1.创建3个Employee放入HashSet中
2.当name和age的值相同时，认为是相同员工，不能添加到Hashset集合中。
我们设置代码如下所示：
package com.rgf.set;
import java.util.Date;
import java.util.HashSet;
import java.util.Objects;
@SuppressWarnings({"all"})
public class HashSetExercise {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee("rgf","15",(new MyDate(2019,10,5))));//OK
hashSet.add(new Employee("ypl", "12", (new MyDate(2000, 1, 5))));//OK
hashSet.add(new Employee("rgf", "16", (new MyDate(2019, 10, 5))));//加入不成功
System.out.println("hashset="+hashSet);
}
}
class Employee{
private String name;
private String sbl;
private Object birthday;
public Employee(String name, String sbl, Object birthday) {
this.name = name;
this.sbl = sbl;
this.birthday = birthday;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return Objects.equals(name, employee.name) && Objects.equals(birthday, employee.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, birthday);
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", sbl='" + sbl + '\'' +
", birthday=" + birthday +
'}';
}
}
class MyDate{
int year;
int month;
int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyDate myDate = (MyDate) o;
return year == myDate.year && month == myDate.month && day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}我们运行之后如下所示:
