day22--Java集合05

Java集合05

11.HashSet课堂练习

11.1课堂练习1

定义一个Employee类，该类包括：private成员属性name，age
要求：

• 创建3个Employee对象放入HashSet中
  
• 当name和age的值相同时，认为是相同员工，不能添加到HashSet集合中
  

思路：不同对象的哈希值一般会不一样，导致在添加对象时可能会在table数组的不同位置添加，因此想要比较对象的属性值，就要重写hashCode方法，使具有相同属性的对象具有一样的hash值，这样才能在插入时比较对象的值；但不同的对象也可能具有相同的hash值，所以要重写equals方法来比较对象属性值
如下图：在add()方法最终调用的putVal（）方法中可以看出，如果插入的新元素的哈希值相同 且 值也相同 就不加入

例子：

1. package li.collections.set.hashset;
3. import java.util.HashSet;
4. import java.util.Objects;
6. @SuppressWarnings("all")
7. public class HashSetPractice {
8.     public static void main(String[] args) {
9.         HashSet hashSet = new HashSet();
10.         hashSet.add(new Employee("jack", 18));
11.         hashSet.add(new Employee("smith", 18));
12.         hashSet.add(new Employee("jack", 18));
14.         System.out.println(hashSet);//[Employee{name='smith', age=18.0}, Employee{name='jack', age=18.0}]
16.     }
17. }
19. class Employee {
20.     private String name;
21.     private double age;
23.     public Employee(String name, double age) {
24.         this.name = name;
25.         this.age = age;
26.     }
28.     public String getName() {
29.         return name;
30.     }
32.     public void setName(String name) {
33.         this.name = name;
34.     }
36.     public double getAge() {
37.         return age;
38.     }
40.     public void setAge(double age) {
41.         this.age = age;
42.     }
44.     @Override
45.     public String toString() {
46.         return "Employee{" +
47.                 "name='" + name + '\'' +
48.                 ", age=" + age +
49.                 '}';
50.     }
52.     @Override
53.     public boolean equals(Object o) {
54.         if (this == o) return true;
55.         if (o == null || getClass() != o.getClass()) return false;
56.         Employee employee = (Employee) o;
57.         return Double.compare(employee.age, age) == 0 && Objects.equals(name, employee.name);
58.     }
60.     @Override
61.     public int hashCode() {
62.         return Objects.hash(name, age);
63.     }
64. }

复制代码

快捷键：alt+insert选择equals（）and hashCode（）快速重写
如果name和age的值相同，在使用equals时，返回true
如果name和age的值相同，在计算hashCode的时候返回相同的hash值
11.2课堂练习2

定义一个Employee类，该类包含：private成员属性name，sal，birthday，其中birthday为MyDate类型，属性包括year，month，day
要求：

• 创建3个Employee对象放入到HashSet中
  
• 当name和birthday的值相同时，热卫视相同员工，不能添加到HashSet集合中
  

思路：和练习1思路一致，不同的是MyDate类也要重写equals（）和hashCode（）方法

练习：

1. package li.collections.set.hashset;
3. import java.util.HashSet;
4. import java.util.Objects;
6. @SuppressWarnings("all")
7. public class HashSetPractice2 {
8.     public static void main(String[] args) {
9.         HashSet hashSet = new HashSet();
10.         hashSet.add(new Employee("jack",8000,new MyDate(1997,12,23)));
11.         hashSet.add(new Employee("jack",8000,new MyDate(1997,12,23)));
12.         hashSet.add(new Employee("jack",8000,new MyDate(1997,12,23)));
13.         hashSet.add(new Employee("jack",8000,new MyDate(1997,12,23)));
15.         System.out.println(hashSet);//[Employee{name='jack', sal=8000.0, birthday=MyDate{year=1997, month=12, day=23}}]
17.     }
18. }
20. class Employee {
21.     private String name;
22.     private double sal;
23.     private MyDate birthday;
25.     public Employee(String name, double sal, MyDate birthday) {
26.         this.name = name;
27.         this.sal = sal;
28.         this.birthday = birthday;
29.     }
31.     public String getName() {
32.         return name;
33.     }
35.     public void setName(String name) {
36.         this.name = name;
37.     }
39.     public double getSal() {
40.         return sal;
41.     }
43.     public void setSal(double sal) {
44.         this.sal = sal;
45.     }
47.     public MyDate getBirthday() {
48.         return birthday;
49.     }
51.     public void setBirthday(MyDate birthday) {
52.         this.birthday = birthday;
53.     }
55.     @Override
56.     public boolean equals(Object o) {
57.         if (this == o) return true;
58.         if (o == null || getClass() != o.getClass()) return false;
59.         Employee employee = (Employee) o;
60.         return Double.compare(employee.sal, sal) == 0 && Objects.equals(name, employee.name) && Objects.equals(birthday, employee.birthday);
61.     }
63.     @Override
64.     public int hashCode() {
65.         return Objects.hash(name, sal, birthday);
66.     }
68.     @Override
69.     public String toString() {
70.         return "Employee{" +
71.                 "name='" + name + '\'' +
72.                 ", sal=" + sal +
73.                 ", birthday=" + birthday +
74.                 '}';
75.     }
76. }
79. class MyDate {
80.     private int year;
81.     private int month;
82.     private int day;
84.     public MyDate(int year, int month, int day) {
85.         this.year = year;
86.         this.month = month;
87.         this.day = day;
88.     }
90.     public int getYear() {
91.         return year;
92.     }
94.     public void setYear(int year) {
95.         this.year = year;
96.     }
98.     public int getMonth() {
99.         return month;
100.     }
102.     public void setMonth(int month) {
103.         this.month = month;
104.     }
106.     public int getDay() {
107.         return day;
108.     }
110.     public void setDay(int day) {
111.         this.day = day;
112.     }
114.     @Override
115.     public boolean equals(Object o) {
116.         if (this == o) return true;
117.         if (o == null || getClass() != o.getClass()) return false;
118.         MyDate myDate = (MyDate) o;
119.         return year == myDate.year && month == myDate.month && day == myDate.day;
120.     }
122.     @Override
123.     public int hashCode() {
124.         return Objects.hash(year, month, day);
125.     }
127.     @Override
128.     public String toString() {
129.         return "MyDate{" +
130.                 "year=" + year +
131.                 ", month=" + month +
132.                 ", day=" + day +
133.                 '}';
134.     }
135. }

复制代码

12.LinkedHashSet

12.1LinkedHashSet底层

• LinkedHashSet是HashSet的子类
  
• LinkedHashSet底层是一个LinkedHashMap（LinkedHashMap是HashMap的子类），底层维护了一个       数组+双向链表
  
• LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这是元素看起来是以插入顺序保存的
  
• LinkedHashSet不允许重复元素
  

说明：
1）在LinkedHashSet中维护了一个hash表和双向链表（LinkedHashSet中有head和tail）
2）每一个节点都有前后指针（before和after属性），形成双向链表
3）在添加一个元素时，先求hash值，再求索引。确定该元素在table的位置然后将添加的元素加入到双向链表（如果已经村存在，就不添加，原理和HashSet一样）

1. tail.next = newElement;//将新添加的节点连接至尾节点的后面
2. newElement.pre = tail;//将尾节点设为新结点的前驱结点
3. tail = newElement;//将新节点设为尾节点

复制代码

4）这样，遍历LinkedHashSet也能确保插入顺序和遍历顺序一致

例子1：LinkedHashSet底层分析

1. package li.collections.set.hashset;
3. import java.util.LinkedHashSet;
4. import java.util.Set;
6. @SuppressWarnings("all")
8. public class LinkedHashSetSource {
9.     public static void main(String[] args) {
10.         Set set = new LinkedHashSet();
11.         set.add(new String("AA"));
12.         set.add(456);
13.         set.add(456);
14.         set.add(new Customer("刘", 1001));
15.         set.add(123);
16.         set.add("jack");
17.         System.out.println(set);
18.     }
19. }
21. class Customer {
22.     private String name;
23.     private int number;
25.     public Customer(String name, int number) {
26.         this.name = name;
27.         this.number = number;
28.     }
30.     @Override
31.     public String toString() {
32.         return "Customer{" +
33.                 "name='" + name + '\'' +
34.                 ", number=" + number +
35.                 '}';
36.     }
37. }

复制代码

如下图，LinkedHashSet不允许重复值，且插入顺序和取出顺序一致
在Set set = new LinkedHashSet();出打上断点调试：
如下图：可以看到，LinkedHashSet底层是一个LinkedHashMap

如下图所示：点击map展开，Step Over之后可以看到第一次添加数据时，直接将数组table扩容到16（数组下标从零开始），存放的节点类型是LinkedHashMap$Entry
数组是HashMap$Node[ ]
存放的元素/数据是LinkedHashMap$Entry类型(LinkedHashMap的内部类Entry继承了HashMap的内部类Node)

如下图：继续添加数据，可以看到在索引为8 的位置添加了新的数据456，点开索引为0 的节点，可以看到这时原来节点的after指向了新的节点，并且新结点的before指向了原来的节点，形成了双向链表
如下图所示：在add（）底层仍然是和HashSet调用了相同的方法，详情见10.3HashSet源码详解



以此类推，形成一条双向链表：

12.1.LinkedHashSet练习

有一个Car类，存在两个私有属性name和price
要求：如果两个Car对象的name和price一样，就认为是相同元素，不能添加

练习：

1. package li.collections.set.hashset;
3. import java.util.LinkedHashSet;
4. import java.util.Objects;
6. @SuppressWarnings("all")
7. public class LinkedHashSetPractice {
8.     public static void main(String[] args) {
9.         LinkedHashSet linkedHashSet = new LinkedHashSet();
10.         linkedHashSet.add(new Car("奥拓",100_000));
11.         linkedHashSet.add(new Car("保时捷",990_000));
12.         linkedHashSet.add(new Car("法拉利",3100_000));
13.         linkedHashSet.add(new Car("特斯拉",100_000));
14.         linkedHashSet.add(new Car("特斯拉",100_000));
15.         for (Object o:linkedHashSet) {
16.             System.out.println(o);
17.         }
18.     }
19. }
21. class Car{
22.     private String name;
23.     private double price;
25.     public Car(String name, double price) {
26.         this.name = name;
27.         this.price = price;
28.     }
30.     @Override
31.     public String toString() {
32.         return "Car{" +
33.                 "name='" + name + '\'' +
34.                 ", price=" + price +
35.                 '}';
36.     }
38.     @Override
39.     public boolean equals(Object o) {
40.         if (this == o) return true;
41.         if (o == null || getClass() != o.getClass()) return false;
42.         Car car = (Car) o;
43.         return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
44.     }
45.     @Override
46.     public int hashCode() {
47.         return Objects.hash(name, price);
48.     }
49.    
50. }

复制代码

在没有重写hashCode()和equals()之前不同的对象实例的hash值一般是不一样的，因此可以插入name和price相同的对象数据。重写之后可以看到相同属性的对象无法插入了。具体解题思路和11HashSet的课堂练习一致。
13.Map接口


13.1Map接口特点

Map接口实现类的特点：（ JDK8的Map接口特点 ）

• Map和Collection并列存在。Map用于保存具有映射关系的数据：key-value（双列元素）
  
• Map中的key和value可以是任何引用类的数据，会封装到HashMap$Node对象中
  
• Map中的key不允许重复（key值不允许重复，重复的话就会用新的值替换/覆盖旧的值e = p--->详细原因和HashSet一样，详见10.1-10.3）
  
• Map中的value允许重复（hash值取决于key）
  
• Map中的key可以为null，value也可以为null（注意key的null最多只能有一个，value的null可以有多个）
  
• 常用String类作为Map的key
  
• key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
  

例子：map的简单使用

1. package li.map;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class MapIntroduce {
7.     @SuppressWarnings("all")
8.     public static void main(String[] args) {
9.         Map map = new HashMap();
10.         map.put("no1","北京");//k-v
11.         map.put("no4","深圳");//k-v
12.         map.put("no4","长沙");//no4=长沙-->key值不允许重复，重复的话就会用新的值替换/覆盖旧的值 e=p
13.         map.put("no5","北京");//value可以重复,hash值取决于key
14.         map.put(null,null);
15.         map.put(null,"abc");//key不能重复，因此这里的值会将上一行的值覆盖 null=abc
16.         map.put("abc",null);//value可以重复
17.         map.put(new Object(),123);
19.         //无序的：原因是底层是按计算的hash值来存放
20.         //{null=abc, no1=北京, no4=长沙, abc=null, no5=北京, java.lang.Object@1b6d3586=123}
21.         System.out.println(map);
23.         //通过指定的key总能找到对应的value
24.         System.out.println(map.get(null));//abc
25.         System.out.println(map.get("no1"));
28.     }
30. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！