1.Set接口

Set接口是通过元素的equals方法，来判断是否为重复元素。

Set接口常用的实现类有：

• HashSet类
• LinkedHashSet类
• TreeSet类

Set接口的特点

• 唯一
• 无序

1.1HashSet类

1.1.1介绍

• HashSet类实现了Set接口
• 存储到HashSet中的对象必须是唯一的，不能重复
• 对象唯一性的判断依赖于hashCode()与equals()方法
• HashSet集合不能保证的迭代顺序与元素存储顺序相同

1.1.2常用方法

1.1.3代码演示

public static void main(String[] args) {
    //1:创建集合，向集合中添加5个对象
    HashSet<String> set = new HashSet<>();
    set.add("林冲");
    set.add("李逵");
    set.add("燕青");
    set.add("武松");//重复的
    set.add("武松");//重复的
    
    //2:迭代集合 Set集合没有get()方法，获取元素只能通过迭代
    Iterator<String> iterator = set.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

运行结果

燕青
武松
林冲
李逵

集合中只存入了四个元素，重复的元素武松只存入了一个。

另外也发现HashSet对元素输出的顺序与输入的顺序不一致。

1.1.4底层数据结构

HashSet底层是使用哈希表存储数据的，什么是哈希表呢？

• 哈希表（Hashtable），也叫散列表，是通过key访问value的一种数据结构，与数组不同的是数组通过index访问value。
• 哈希表最大的优势在于查找速度快。快速查找的原理是key通过散列函数（也叫哈希函数）能够快速定位value存储的位置。
• 哈希表底层是数组+链表的数据结构，哈希表数据结构如下图所示：

1659109825005.png

• 哈希表中数组元素不存储添加到哈希表中的元素，数组元素存放的是链表。

• 添加到哈希表中的元素存储在链表的节点上。

• 当向哈希表中存放元素时，需要根据元素的特有的数据结合相应的算法，计算出元素应该放到哪个数组元素的链表上。

• 这个算法其实就是Object类中的hashCode方法。由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。也就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。

• 总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

1.1.5代码演示：HashSet中存储自定义类型的元素

class Student{
    private String name;
    private int math;
    private int cn;
    public Student(String name, int math, int cn) {
        super();
        this.name = name;
        this.math = math;
        this.cn = cn;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", math=" + math +
                ", cn=" + cn +
                '}';
    }
    //省略 get/set方法
}
public class Demo {
    public static void main(String[] args) {

        HashSet<Student> set = new HashSet<>();
        Student s1 = new Student("林冲", 90, 90);
        Student s2 = new Student("李逵", 92, 60);
        Student s3 = new Student("燕青", 71, 70);
        Student s4 = new Student("时迁", 80, 80);//重复对象
        Student s5 = new Student("时迁", 80, 80);//重复对象
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

        Iterator<Student> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("s4 哈希码="+s4.hashCode());
        System.out.println("s5 哈希码="+s5.hashCode());
    }
}

运行结果

Student{name='燕青', math=71, cn=70}
Student{name='时迁', math=80, cn=80}
Student{name='李逵', math=92, cn=60}
Student{name='时迁', math=80, cn=80}
Student{name='林冲', math=90, cn=90}
s4 哈希码=325040804
s5 哈希码=1173230247

2.Map接口

2.1.1介绍

Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

• Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

• Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值（key - value）两部分组成，通过键可以找对所对应的值。

• Collection中的集合称为单列集合，Map中的集合称为双列集合。

• 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

• Map中常用的集合为HashMap集合、LinkedHashMap集合。
  Map接口有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合、Properties集合。

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。

2.1.2常用方法

• put方法：将指定的键与值对应起来，并添加到集合中
  • 方法返回值为键所对应的值
    • 使用put方法时，若指定的键(key)在键集中不存在，那么对应的值也不存在，返回null，并把指定的键值添加到集合中
    • 使用put方法时，若指定的键(key)在键集中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。
• get方法：获取指定键(key)所对应的值(value)
• remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)

2.1.3Map集合的遍历

• Map集合遍历方式是键找值：即通过元素中的键，获取键所对应的值。
• Map集合的键集是一个Set集合
• 遍历Set集合，分别取出key
• 通过key找到value

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String,String>();

    map.put("豹子头", "林冲");
    map.put("黑旋风", "李逵");
    map.put("浪子","燕青");
    map.put("行者","武松");

    Set<String> sets = map.keySet();
    Iterator<String> iterator = sets.iterator();
    while (iterator.hasNext()){
        String key = iterator.next();
        String value = map.get(key);
        System.out.println("key="+key +",value="+value);
    }
}

运行结果

key=豹子头,value=林冲
key=行者,value=武松
key=黑旋风,value=李逵
key=浪子,value=燕青

2.1.4Entry键值对对象

Map集合除了通过keySet()迭代集合外，还可以通过entrySet()迭代集合。

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

遍历set集合得到 Entry<String , String> 对象

Entry<String , String> 对象调用 getKey()得到 key

Entry<String , String> 对象调用 getValue()得到 value

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String,String>();

    map.put("豹子头", "林冲");
    map.put("黑旋风", "李逵");
    map.put("浪子","燕青");
    map.put("行者","武松");

    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
    while (iterator.hasNext()){
        Map.Entry<String, String> entry = iterator.next();
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println("key="+key +",value="+value);
    }
}

运行结果

key=豹子头,value=林冲
key=行者,value=武松
key=黑旋风,value=李逵
key=浪子,value=燕青

2.2.1HashMap类

需求：学生有姓名、年龄的属性，学生都有自己的家庭住址。将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if(!(o instanceof Student)){
            System.out.println("类型错误");
            return false;
        }
        Student other = (Student) o;
        return  this.age == other.age && this.name.equals(other.name);

    }
    //重写hashCode方法
    @Override
    public int hashCode() {
        final int base = 31;
        int result = 1;
        result = base * result + age;
        result = base * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //重写 toString 方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
    //省略了 get/set 方法
}

/**
 * HashMap集合的用法
 */
public class Demo {
    public static void main(String[] args) {
        //1：创建Map集合对象
        Map<Student, String> map = new HashMap<Student, String>();

        //2：创建学生对象
        Student s1 = new Student("林冲", 30);
        Student s2 = new Student("李逵", 32);
        Student s3 = new Student("燕青", 22);
        Student s4 = new Student("武松", 29);//重复对象
        Student s5 = new Student("武松", 29);//重复对象

        //3：添加到map集合中 学生对象作为key，家庭地址作为value
        map.put(s1, "河南开封");
        map.put(s2, "山东沂水");
        map.put(s3, "北京大名府");
        map.put(s4, "河北清河");
        map.put(s5, "辽宁铁岭");

        //3：取出元素，键值对方式
        Set<Map.Entry<Student, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Student, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Student, String> entry = iterator.next();
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key=" + key + ",value=" + value);
        }
        System.out.println("-------------------- 分界线 ----------------------");
        //3：取出元素，键找值方式
        Set<Student> sets = map.keySet();
        Iterator<Student> iterator1 = sets.iterator();
        while (iterator1.hasNext()) {
            Student key = iterator1.next();
            String value = map.get(key);
            System.out.println("key=" + key + ",value=" + value);
        }
    }
}

运行结果

key=Student{name='武松', age='29'},value=辽宁铁岭
key=Student{name='林冲', age='30'},value=河南开封
key=Student{name='李逵', age='32'},value=山东沂水
key=Student{name='燕青', age='22'},value=北京大名府
-------------------- 分界线 ----------------------
key=Student{name='武松', age='29'},value=辽宁铁岭
key=Student{name='林冲', age='30'},value=河南开封
key=Student{name='李逵', age='32'},value=山东沂水
key=Student{name='燕青', age='22'},value=北京大名府

2.2.2底层数据结构

HashMap底层数据结构是（ 数组 + 链表 | 红黑树）

1659179248735.png