11.Java集合框架_Set接口

Set接口和常用方法

基本介绍

  1. 无序(添加和取出的顺序不一致),没有索引
  2. 不允许重复元素,所以最多包含一个null。
  3. JDK API中Set接口的实现类有HashSet、LinkedHashSet和TreeSet。

set接口常用方法

和List接口一样,set接口也是Collection的子接口,因此,常用方法和Collection接口一样。

Modifier and Type Method and Description
boolean add(E e)如果指定的元素不存在,则将其指定的元素添加(可选操作)。
boolean addAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合(如果尚未存在)(可选操作)。
void clear()从此集合中删除所有元素(可选操作)。
boolean contains(Object o)如果此集合包含指定的元素,则返回 true 。
boolean containsAll(Collection<?> c)返回 true如果此集合包含所有指定集合的元素。
boolean equals(Object o)将指定的对象与此集合进行比较以实现相等。
int hashCode()返回此集合的哈希码值。
boolean isEmpty()如果此集合不包含元素,则返回 true 。
Iterator<E> iterator()返回此集合中元素的迭代器。
boolean remove(Object o)如果存在,则从该集合中删除指定的元素(可选操作)。
boolean removeAll(Collection<?> c)从此集合中删除指定集合中包含的所有元素(可选操作)。
boolean retainAll(Collection<?> c)仅保留该集合中包含在指定集合中的元素(可选操作)。
int size()返回此集合中的元素数(其基数)。
default Spliterator<E> spliterator()在此集合中的元素上创建一个 Spliterator 。
Object[] toArray()返回一个包含此集合中所有元素的数组。
<T> T[] toArray(T[] a)返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

set接口的遍历方式

同Collection的遍历方法一样,因为set接口是Collection接口的子接口。

  1. 可以使用迭代器。
  2. 增强for。
  3. 不能使用索引的方式遍历

代码:

import java.util.HashSet;
import java.util.Iterator;

//set接口的遍历方式
public class SetTraversal {
    public static void main(String[] args) {
        //以set接口实现子类 HashSet举例 set接口方法
        /*
          1.set接口的实现类(set接口对象),不能存放重复元素,可以添加一个null。
          2.set接口对象存放的数据是无序的(即添加的顺序和取出的顺序不一致)。
          3.注意:取出的顺序虽然不是添加的顺序,但是它是固定的。
        */
        HashSet set = new HashSet();
        set.add("1");
        set.add("2");
        set.add("3");
        set.add("3"); //重复
        set.add("4");
        set.add("100");
        set.add(null);
        set.add(null); //重复添加null
        System.out.println(set); //[null, 1, 100, 2, 3, 4]

        //遍历(两种方式)
        //1.迭代器
        System.out.println("=====迭代器遍历=====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
        
        //2.增强for遍历,本质就是迭代器
        System.out.println("=====增强for遍历=====");
        for (Object object : set) {
            System.out.println(object);
        }

        //set接口对象,不能通过索引来获取,无法使用普通for循环遍历
    }
}

Set实现类-HashSet

基本介绍

  1. HashSet实现了Set接口。

  2. HashSet 实际上是HashMap(源码如下)

    public HashSet() {
        map = new HashMap<>();
    }
    
  3. 可以存放null值,但是只能有一个null。

  4. HashSet不保证元素是有序的,取决于hash值,再确定索引的结果。

  5. 不能有重复元素/对象。

代码:

import java.util.HashSet;

//Set实现类–HashSet
public class HashSetDemo {
    public static void main(String[] args) {
        //1.HashSet实际上是HashMap
        HashSet hashSet = new HashSet();
        /* 默认构造器源码
            public HashSet() {
                map = new HashMap<>();
            }
         */

        //2.可以存放null值,但只能有一个null
        hashSet.add(null);
        hashSet.add(null);
        System.out.println(hashSet); //[null]

        hashSet = new HashSet();
        //在执行add方法后,会返回一个boolean值。如果添加成功,返回true,否则返回false。
        //可以通过remove指定删除哪个对象
        System.out.println(hashSet.add("Tom")); //true
        System.out.println(hashSet.add("Mike")); //true
        System.out.println(hashSet.add("John")); //true
        System.out.println(hashSet.add("Tom")); //false
        System.out.println(hashSet.add("Jerry")); //true
        hashSet.remove("Tom");
        System.out.println(hashSet); //[Mike, John, Jerry]

        hashSet = new HashSet();
        //不能添加相同的元素/数据
        hashSet.add("Lucy"); //true
        hashSet.add("Lucy"); //false
        hashSet.add(new Cat("Tom")); //true
        hashSet.add(new Cat("Tom")); //true
        System.out.println(hashSet); //[Cat{name='Tom'}, Cat{name='Tom'}, Lucy]

        //经典面试题
        System.out.println(hashSet.add(new String("Helen"))); //true
        System.out.println(hashSet.add(new String("Helen"))); //false
        System.out.println(hashSet); //[Cat{name='Tom'}, Cat{name='Tom'}, Lucy, Helen]
    }
}

class Cat{
    public String name;

    public Cat(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + "'" +
                "}";
    }
}

HashSet底层机制

HashSet 底层是HashMap,HashMap底层是(数组+链表+红黑树

相较数组存储效率高

HashMap

代码实现:

//HashSet底层机制
public class HashSetMap {
    public static void main(String[] args) {
        //模拟一个HashSetMap的底层(HashMap的底层结构)

        //1.创建一个数组,数组的类型是Node[]
        //2.有些人,直接把Node[]数组称为表
        Node[] table = new Node[16];

        //3.创建节点
        Node john = new Node("John", null);
        table[2] = john;
        Node jane = new Node("Jane", null);
        john.next = jane; //将jane节点挂载到john后
        Node fred = new Node("Fred", null);
        jane.next = fred; //将fred节点挂载到jane后
        Node lucy = new Node("Lucy", null);
        table[3] = lucy;
        System.out.println(table);
    }
}

class Node {
    //结点,存储数据,可以指向下一个结点,从而形成链表
    Object item;    //存放数据
    Node next;  //指向下一个节点

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }
}

存储结构:

Node存储结构

源码分析

HashSet的add方法

  1. HashSet底层是HashMap;
  2. 添加一个元素时,先得到hash值(会转成索引值)(不是hashcode,是hashcode经过相关运算得到hash值);
  3. 找到存储数据表table,看这个索引位置是否已经存放的有元素;
  4. 如果没有,直接加入;
  5. 如果有,调用equals() 比较, 如果相同,就放弃添加,如果不相同,则添加到最后;
  6. 在 java8 中,如果一条链表的元素个数大于等于TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_CAPCAITY(默认64),就会进行树化(红黑树)。

代码:

import java.util.HashSet;

//HashSet的add方法源码分析
public class HashSetAdd {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();

        hashSet.add("java");
        hashSet.add("php");
        hashSet.add("java");

        System.out.println("haseSet="+hashSet);
        /*
        1. 执行Hashset()
        public HashSet() {
            map = new HashMap<>();
        }
        2. 执行hashSet.add()
        public boolean add(E e) { //e="java"
            return map.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();
        }
        3. 执行put方法
        public V put(K key, V value) {//key = "java" , value = PRESENT (静态)
            return putVal(hash(key), key, value, false, true);
        }
        4. hash(key)方法,得到key对应的一个“hash值”,但不是hashcode!
        static final int hash(Object key) {
            int h;
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//>>>无符号右移16位
        }
        5. 执行putVal 核心!
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;   //定义了辅助变量
            //table 就是HashMap 的一个数组,类型是Node[]
            //if语句标识如果当前table是null或者大小为0
            //第一次扩容,空间大小为16
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;//resize():扩容,第一次生成Node[16],数组扩展的阈值为0.75*16=12
            //(1)根据key,得到hash去计算该key应该存放到table表的哪个索引位置
            //并把这个位置的对象,赋给p
            //(2)判断这个p是否为空
            //(2.1)如果p为null
            //如果p为null,标识还没有存放元素,就创建一个Node(key=”java“,value=PRESENT)
            //就放在该位置tab[i] = newNode(hash, key, value, null);
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
                //开发技巧:在需要辅助变量或者局部变量的时候再创建
                //2.2如果p不为null
                Node<K,V> e; K k;
                //2.2.1 假如数组位置的元素与key(相同)
                //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                //并且满足 (准备加入的key和p指向的Node结点的key相同) 或(key动态绑定的equals()方法为真)
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                //2.2.2 判断p是不是红黑树结点
                // 调用putTreeVal方法添加
                else if (p instanceof TreeNode)
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                //2.2.3 假如是链表
                // 顺次比较链表的每一个元素是否相同(和2.2.1比较方法相同),都不相同加在最后一个位置,相同就break
                // 注意在把元素添加到链表后,立即判断,该链表是否到达8个结点,就调用treeifyBin对链表进行树化(转成红黑树)
                // 注意,在转成红黑树时,要进行判断,判断条件:tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(默认64)
                //上述条件成立,先table扩容,否则不成立才转成红黑树
                    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;
                    }
                }
                //3 判断是否存在
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;
            //size 就是我们每加入一个结点Node(k,v,h,next),size++,不论是加在数组还是链表
            if (++size > threshold)
                resize();//扩容
            afterNodeInsertion(evict);//空方法,给HashMap子类去实现
            return null;
        }
         */

    }
}

HashSet扩容机制

  1. HashSet底层是HashMap,第一次添加时,table数组扩容到16,临界值(threshold)是 16 * 加载因子(loadFactor)0.75 = 12。
  2. 如果table数组使用到了临界值12,就会扩容到 16 * 2 = 32,新的临界值就是 32 * 0.75 = 24,依次类推。
  3. 在Java8中,如果一条链表的元素个数到 TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),否则仍然采用数组扩容机制。

注意:

  • 每添加一个元素(包括在table表,与表中链表)即添加一个节点,会执行一次 ++size,当size > threshold 时就会执行扩容。
  • table表扩容并不是表的16个大小被添加完才执行,当所有元素的个数大于临界值时就会执行扩容。

代码实践

题目描述:

定义一个Employee类,该类包括:private成员属性name和age。

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

思路:不同对象的哈希值一般会不一样,导致在添加对象时可能会在table数组的不同位置添加,因此想要比较对象的属性值,就要重写hashCode方法,使具有相同属性的对象具有一样的hash值,这样才能在插入时比较对象的值;但不同的对象也可能具有相同的hash值,所以要重写equals方法来比较对象属性值。

关键:重写hashCode()与equals()方法

快捷键:Alt+Insert => equals() and hashCode() => 选择相应的参数

代码:

package com.mlt.collection.set;

import java.util.HashSet;
import java.util.Objects;

//HashSet代码实践
public class HashSetExercise {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add(new Employee("Jack", 18));
        hashSet.add(new Employee("John", 20));
        hashSet.add(new Employee("Jack", 18));
        System.out.println(hashSet); //[Employee{name='Jack', age=18}, Employee{name='John', age=20}]
    }
}

class Employee
{
    String name;
    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 +
                '}';
    }

    @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);
    }
}

Set实现类-LinkedHashSet

基本介绍

  1. LinkedHashSet是HashSet的子类。
  2. LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组 + 双向链表
  3. LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序,这使得元素看起来是以插入顺序保存得。
  4. LinkedHashSet 不允许添加重复元素。

说明:

  1. 在LinkedHashSet中维护了一个hash表和双向链表(LinkedHashSet有head和tail)。
  2. 每一个节点有before和after属性,这样可以形成双向链表。
  3. 在添加一个元素时,先求hash值,在求索引,确定该元素在table的位置,然后将添加的元素加入到双向链表(如果已经存在,不添加【原则和hashset一样】)。
  4. 这样遍历LinkedHashSet也能确保插入顺序和遍历顺序一致。

源码分析

import java.util.LinkedHashSet;

//Set实现类–LinkedHashSet
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer("刘", 1001));
        set.add(123);
        set.add("Kobe");
        for (int i = 0; i < 100; i++) {
            set.add(new Customer("Kobe", 24));
        }//也会树化 parent、left、right
        System.out.println(set);
        //1. LinkedHashSet 加入顺序和遍历顺序一致
        //2. LinkedHashSet 底层是一个LinkedHashMap(是hashMap的子类)
        //3. LinkedHashSet 底层结构(数组table+双向列表)
        //4. 添加第一次时,直接将数组table扩容到16,存放的结点类型 LinkedHashMap$Entry
        //5. 数组是HashMap$Node[] , 存放的元素/数据是 LinkedHashMap$Entry 类型
        /*
            //继承关系是在内部类完成 , 都是静态内部类
            static class Entry<K,V> extends HashMap.Node<K,V> {
                Entry<K,V> before, after;
                Entry(int hash, K key, V value, Node<K,V> next) {
                    super(hash, key, value, next);
                }
            }
         */
    }
}

class Customer
{
    String name;
    int no;

    public Customer(String name, int no) {
        this.name = name;
        this.no = no;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + "'" +
                ", no=" + no +
                "}";
    }

    @Override
    public int hashCode() {
        return 1;
    }
}

Set实现类-TreeSet

基本介绍

  • 不允许添加重复元素,不允许添加null
  • 无序(没有按照输入顺序进行输出)
  • 遍历结果有顺序
  • 底层为排序二叉树(红黑树),且采用中序遍历得到结果 (左节点,根节点,右节点)

源码分析

import java.util.Comparator;
import java.util.TreeSet;

//Set实现类–TreeSet
public class TreeSetDemo {
    public static void main(String[] args) {
        //TreeSet treeSet = new TreeSet();
        //使用匿名内部类实现Comparator接口,并重写compare方法,指定排序方法
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });

        //添加数据
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("sp");
        treeSet.add("abc");//tom和abc长度相等,key相等,添加失败
        System.out.println(treeSet);//[sp, tom, jack]
        //1.当我们使用无参构造器时,创建TreeSet时,底层默认创建TreeMap
        /*
        public TreeSet() {
            this(new TreeMap<E,Object>());
        }
         */
        //TreeMap 如果使用默认构造函数,要求key是实现了Comparable接口的,并且使用key的compareTo方法比较,
        //也就是说仍然按照key排序,如果key没有实现Comparable方法就会报错
        /*
        String类实现了Comparable接口,重写了compareTo方法:按升序排序,首字母先比较,相等再用第二个字母,以此类推
        public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

        }
         */
        //2.上面的的代码实现了添加元素按照字符串长度来排序
        //3.
        /*
         public V put(K key, V value) {
            Entry<K,V> t = root;
            if (t == null) {
                compare(key, key); // type (and possibly null) check

                root = new Entry<>(key, value, null);
                size = 1;
                modCount++;
                return null;
            }
            int cmp;
            Entry<K,V> parent;
            // split comparator and comparable paths
            Comparator<? super K> cpr = comparator;//传入的比较器
            if (cpr != null) {
                do {
                    parent = t;
                    cmp = cpr.compare(key, t.key);//动态绑定到我们的comparator
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);//如果比较器比较结果相同,更改value,不更改key
                        //TreeSet的value是类,private static final Object PRESENT = new Object();
                } while (t != null);
            }
            else {
                //如果使用默认构造函数,即没有比较器对象
                //要求key是实现了Comparable接口的,并且使用key的compareTo方法比较,
                if (key == null)//key不能为空
                    throw new NullPointerException();
                @SuppressWarnings("unchecked")
                    Comparable<? super K> k = (Comparable<? super K>) key;
                    //要求key是实现了Comparable接口的
                do {
                    parent = t;
                    cmp = k.compareTo(t.key);//使用key的compareTo方法比较
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            Entry<K,V> e = new Entry<>(key, value, parent);
            if (cmp < 0)
                parent.left = e;
            else
                parent.right = e;
            fixAfterInsertion(e);//加入后红黑树旋转
            size++;
            modCount++;
            return null;
        }
         */

        treeSet = new TreeSet();
        treeSet.add(new C(1));
        treeSet.add(new C(2));
        treeSet.add(new C(1));
        System.out.println(treeSet);
    }

}

class C implements Comparable<C>{
    int num;

    public C(int num) {
        this.num = num;
    }

    public int compareTo(C c) {
        return this.num - c.num;
    }

    @Override
    public String toString() {
        return "C{" +
                "num=" + num +
                '}';
    }
}
posted @   爱吃麻辣烫的妹纸  阅读(28)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
· 面试官:你是如何进行SQL调优的?
点击右上角即可分享
微信分享提示