我所理解的JKD集合类（五）：手写HashSet实现Set接口

最新推荐文章于 2023-09-16 00:15:00 发布
最新推荐文章于 2023-09-16 00:15:00 发布
阅读量179 收藏
点赞数
文章标签： 数据结构与算法 java python
原文链接：https://my.oschina.net/u/3466682/blog/1577591
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

package cn.test;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;

/**
 * @Description : 手写HashSet的实现
 * @Author : houshuiqiang@163.com, 2016年6月9日 上午8:24:23
 * @Modified :houshuiqiang@163.com, 2016年6月10日
 */
public class MyHashSet<E> implements Set<E> {

    private int modCount;

    private Node<E>[] table;

    private int size;

    private int capacity;

    private static final int DEFAULT_CAPACITY = 16;

    private static final int MAX_CAPACITY = 2^16;

    private float loadFactor;

    private static final float DEFAULT_LOAD_FACTOR = 0.75F;

    private static final int INCREMENT_FACTOR = 2;

    private int capacitySize; // 当前set最多允许存放多少个元素，超过则需要扩容

    public MyHashSet(){
        this(DEFAULT_CAPACITY,DEFAULT_LOAD_FACTOR);
    }

    public MyHashSet(int capacity){
        this(capacity,DEFAULT_LOAD_FACTOR);
    }

    @SuppressWarnings("unchecked")
    public MyHashSet(int capacity, float loadFactor){
        vertifyConsturctorCapacity(capacity);
        vertiryConsturctorLoadFactor(loadFactor);
        table = new Node[this.capacity];
        capacitySize =(int) (this.capacity * this.loadFactor);
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object o) {

        boolean contains = false;

        Iterator<E> iterator = this.iterator();
        for (E e = iterator.next(); iterator.hasNext() && !contains;) {
            if (e == null) {
                contains = o == null;
            }else {
                contains = e.equals(o);
            }
        }

        return contains;
    }

    @Override
    public Iterator<E> iterator() {
        return new MyIterator();
    }

    @Override
    public Object[] toArray() {
        Object[] array = new Object[size];
        int index = 0;

        Iterator<E> iterator = this.iterator();
        for (E e = iterator.next(); iterator.hasNext(); ){
            array[index++] = e;
        }

        return array;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T[] toArray(T[] a) {

        int index = 0;

        Iterator<E> iterator = this.iterator();
        for (E e = iterator.next(); iterator.hasNext(); ){
            if (index < a.length) {
                a[index++] = (T)e;
            }else{
                break;
            }
        }

        return a;
    }

    @Override
    public boolean add(E e) {
        ifIncrement();
        if (null == e) {
            Node<E> node = table[0];
            boolean alreadyHasNull = false;
            while(node != null && !alreadyHasNull) {
                alreadyHasNull = node.e == null;
                node = node.nextNode;
            }
            if (!alreadyHasNull) {
                table[0] = new Node<E>(null, 0, table[0]);
                size++;
                modCount++;
            }
            return !alreadyHasNull;
        }

        int hash = hash(e.hashCode());
        int index = indexOfTable(hash);

        Node<E> node = table[index];
        boolean alreadyHas = false;
        while (node != null && !alreadyHas) {
            alreadyHas = node.e != null && hash == node.hash && e.equals(node.e);
            node = node.nextNode;
        }
        if (!alreadyHas) {
            table[index] = new Node<E>(e, hash, table[index]);
            size++;
            modCount++;
        }

        return !alreadyHas;
    }

    @Override
    public boolean remove(Object o) {

        for (int i = 0; i < table.length; i++) {
            Node<E> node = table[i];
            if (node == null) {
                continue;
            }else{
                // 链表的第一个元素
                if (o == null && node.e == null || o != null && node.e != null
                        && o.hashCode() == node.e.hashCode() && o.equals(node.e)) {
                    table[i] = node.nextNode;

                    size--;
                    modCount++;
                    return true;
                }else{ // 链表的非第一个元素
                    Node<E> preNode = node;
                    Node<E> tempNode = node.nextNode;
                    while (tempNode != null) {
                        if (o == null && tempNode.e == null || o != null && tempNode.e != null
                                && o.hashCode() == tempNode.e.hashCode() && o.equals(tempNode.e)) {

                            preNode.nextNode = tempNode.nextNode;

                            size--;
                            modCount++;
                            return true;
                        }
                        preNode = tempNode;
                        tempNode = tempNode.nextNode;
                    }

                }
            }
        }

        return false;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean containsAll(Collection<?> c) {

        for (Object object : c.toArray()) {
            if (! contains((E)object)) {
                return false;
            }
        }
        return true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean addAll(Collection<? extends E> c) {
        boolean changed = false;

        for (Object obj : c.toArray()) {
            changed |= add((E)obj);
        }

        return changed;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean retainAll(Collection<?> c) {
        boolean changed = false;

        for (Object obj : c.toArray()) {
            E e = (E)obj;
            changed |= contains(e) ? remove(e) : false;
        }
        return changed;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean removeAll(Collection<?> c) {

        boolean changed = false;
        for (Object object : c.toArray()) {
            changed |= remove((E)object);
        }

        return changed;
    }

    @Override
    public void clear() {
        Arrays.fill(table, null);
        size = 0;
    }

    private void vertifyConsturctorCapacity(int capacity){
        if (capacity < 0) {
            throw new IllegalArgumentException("初始容量不合法");
        }
        if (capacity > MAX_CAPACITY) {
            this.capacity = MAX_CAPACITY;
            return;
        }

        // TODO 2的n次方 -- 直接copy的hashMap的代码，这个有点困难。
        this.capacity = tableSizeFor(capacity);
    }

    // 这个方法有点难实现，直接copy吧。
    /** {@link java.lang.HashMap#tableSizeFor(int)} */
    private int tableSizeFor(int capacity) {
        int n = capacity - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAX_CAPACITY) ? MAX_CAPACITY : n + 1;
    }

    private void vertiryConsturctorLoadFactor(float factor){
        if (factor <= 0 || Float.isNaN(factor)) {
            throw new IllegalArgumentException("增长因子不合法");
        }
        this.loadFactor = factor;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void ifIncrement(){
        if (capacitySize <= size) {
            // 扩容
            Node<E>[] newTable = new Node[table.length * INCREMENT_FACTOR];

            // 遍历数组
            for(Node<E> node : table){
                if (node != null) {
                    // 遍历链表
                    for (Node<E> tempNode = node; tempNode != null; tempNode = tempNode.nextNode) {
                        int indexOfTable = indexOfTable(tempNode.hash);
                        Node<E> firstNode = newTable[indexOfTable];
                        if (firstNode == null ) {
                            newTable[indexOfTable] = tempNode;
                        }else{
                            newTable[indexOfTable] = new Node(tempNode.e, tempNode.hash, firstNode);
                        }
                    }
                }
            }

            table = newTable;
            capacitySize = (int)(table.length * loadFactor);
        }
    }

    // 获得更好的hash散列
    private int hash(int h){
        // TODO
        return h;
    }

    // hash值对应的数组的位置
    private int indexOfTable(int hash){
        return hash & (table.length -1);
    }


    @SuppressWarnings("hiding")
    private class Node<E> {
        E e;
        Node<E> nextNode;
        int hash; // 为了更好的hash散列
        public Node(E e, int hash, Node<E> nextNode) {
            super();
            this.e = e;
            this.hash = hash;
            this.nextNode = nextNode;
        }
    }

    public class MyIterator implements Iterator<E> {

        private int curreantIndexOfTable = 0;

        private Node<E> nextReturnNode = table[0];

        private Node<E> lastReturnedNode;

        private int itrModCount = modCount;

        @Override
        public boolean hasNext() {
            return linkHasNext(nextReturnNode);
        }


        @Override
        public E next() {
            checkModCount();

            lastReturnedNode = nextReturnNode;
            nextReturnNode = nextReturnNode.nextNode;

            compareNext();
            return lastReturnedNode.e;
        }

        @Override
        public void remove(){
            MyHashSet.this.remove(lastReturnedNode.e);
            itrModCount = modCount;
        }

        private boolean linkHasNext(Node<E> nextReturnNode){
            return nextReturnNode != null;
        }

        private void checkModCount(){
            if (this.itrModCount != MyHashSet.this.modCount) throw new RuntimeException("遍历期间不能删元素，如果需要，请使用iterator.remove()");
        }

        private void compareNext(){
            if (! linkHasNext(nextReturnNode)) {
                boolean hashNext = false;
                while (!hashNext && ++curreantIndexOfTable < table.length) {
                    nextReturnNode = table[curreantIndexOfTable];
                    hashNext = linkHasNext(nextReturnNode);
                }
            }
        }
    }
}

写完ArrayList熟悉数组结构，写完LinkedList熟悉链表结构之后，再写HashSet就比较容易。就是数组+链表结构而已。遍历的时候，如果当前链表没有下一个节点了，就得去数组的下一个index去找了，直到找到有值的节点。如果找不到节点了，数组里也没有元素可遍历了，则hashNext()返回false。

转载于:https://my.oschina.net/u/3466682/blog/1577591

weixin_34403693
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JKD:来自https的JUkandian App脚本
04-03
特别声明： 本仓库发布的脚本项目中涉及的任何解锁和解密分析脚本，仅用于测试和学习研究，禁止用于商业用途，不能保证其合法性，准确，可以和有效，请根据情况自行判断。 本项目内所有资源文件，禁止任何公众号，自...
jkd_1.8_中文API_帮助文档_必应翻译版
07-25
jkd 1.8 中文 帮助文档 必应翻译 开发必备神器 (注意: 首次打开文档前,务必按如下操作进行设置: 1-右键文档, 2-点击'属性' ,3-在属性栏中点击'解除锁定',4- 确定 ) 非常好用,建议配合英文原版进行查看,效果更佳.
HashSet的实现（下）
weixin_34357928的博客
06-17 103
在HashSet的实现（上）中，简要介绍了散列法（hashing）的内容，并以二次探测法实现了一个简单的HashSet。在本文中，将进一步讨论散列法，尤其是GetHashCode方法的实现，最后给出完整的HashSet实现。 散列法再议 通过散列法实现的容器，不管是HashSet、Hashtable还是Dictionary，需要支持的基本操作是insert、remove和find，特别是ins...
手写简易HashSet
Arvin的博客
04-02 467
public class MyHashSet { HashMap map; private static final Object PRESENT = new Object(); public MyHashSet () { map = new HashMap(); } public int size() { return map.size(); } publi...
手写代码：HashSet
lydms的博客
02-11 470
一、简介 1、特点 Set容器特点：无序、不可重复。 无序指Set中的元素没有索引，我们只能遍历查找; 不可重复指不允许加入重复的元素。 2、底层实现: HashSet是采用哈希算法实现，底层实际是用HashMap实现的(HashSet本质就是一个简化版的（HashMap），因此，查询效率和增删效率都比较高； 查看底层代码，我们发现里面有个map属性，这就是HashSet的核心秘密。我们再看ad...
Java学习笔记：HashSet手写实现
菜到不敢run
07-22 285
  本文是对高淇版Java三百集，HashSer内容学习的记录。Set接口实现类有HashSet,TreeSet。   HashMap的本质是一个HashMap,其中HashMap的Key作为存储数据，Value设置为一个常量，private static final Object PRESENT = new Object();。 一、HashSet常用方法 1.1 add()方法 public boolean add(E e) 1.2 remove()方法 public boolean rem
自己写的类 放入HashSet的实现
qq_41018639的博客
11-04 554
编写一个学生类，具有姓名，年龄，性别三个属性,创建3个学生对象并保存到HashSet中，利用迭代器Iterator将集合里所有学生姓名，年龄，性别打印出来。 package shu; import java.util.HashSet; import java.util.Iterator; import java.util.Set; class Student{     private Str...
java jkd 1.8.0
04-24
java jkd 1.8.0
jkd api 1.6
12-11
jkd api 1.6.是学习Java的必备工具，希望对大家有所帮助。
win10 java 11(JKD 11)安装包
最新发布
02-01
java11(JKD11)安装包
Java手写HashSet
qq_48508278的博客
07-19 196
一：引言 HashSet类继承于 Set接口 其方法均可被直接调用，不用手写，本篇敲的码是为了熟悉底层原理，HashMap的特点：无序，无重复。其底层用的也是map<key,value>容器，但其value值固定,所以在HashSet当中存储key值时，不可重复。 二：上码 package cn.wyj.two; import java.util.HashMap; import java.util.Map; public class Demo8_手写HashSet { Map map;
[基础数据结构|Java实现]一：HashSet
qq_41552013的博客
03-21 840
[基础数据结构|Java实现]一：HashSet实现思路：具体实现要求：Java实现代码：测试代码：测试结果： HashSet的基本概念： 元素不能重复 不能保证顺序 💓为了实现简单，规定只能存储String，不能为Null，并且区分大小写。 实现思路： 底层用一个数组做为桶，然后每个桶都绑定一个链表；添加的每个元素都先计算其hash值，并对数组的长度取模，然后得到桶的索引，再利用equal判断是否需要添加到链表中即可。 缺陷： java中的hashSet链表的长度达到某个值时，会自动转换为红黑树
简单实现hashSet -- 应用篇
wrack0001的专栏
08-07 284
简单实现hashSet -- 应用篇 写这篇文章的起因： 在使用golang和php的时候我们经常会判断一个变量是否在map或者数组中； 在php中的时候我们经常使用in_array()来判断，这里是我们经常用的。 其实用in_array()这个函数就是对数组进行遍历判断是否存在时间复杂度是log(n) 一般数组不是太大也就这样了； 但是在golang中并没有封装这个函数，这个需...
纯手写HashMap集合
06-06 522
1. ArrayList=数组+扩容技术(底层实现技术)2.LinkedList=集合链表(底层实现技术)3.HashMap jdk1.7数组+链表，jdk1.8数组+红黑树思想本质是相同的HashMap1.8比1.7性能提高了15%左右，抽象思维能力，有一个想象的思维空间。HashMap的扩容技术就是负载因子0.75，这个根据算法是有关系的，Hashcode冲突的情况下(碰撞的原理)4.Hash...
手写HashSet的实现和拓展
qq_22593423的博客
09-16 94
通过以上步骤，我们成功实现了一个简单的HashSet类。它基于散列（Hash）实现，使用数组和链表来存储元素。我们实现了添加元素、删除元素、查找元素等基本操作。这个手写的HashSet类可以作为学习和理解HashSet的实现原理的基础。我们可以进一步扩展它，添加更多的功能和优化性能。
手写基本容器——Set （五）
qq_43551976的博客
05-28 636
手写基本容器——Set HashSet底层JDK代码代码实现展示TreeMapJDK底层源码代码 HashSet 底层JDK代码 private transient HashMap<E,Object> map; // Dummy value to associate with an Object in the backing Map private static final...
手写笔记2：谈谈HashMap和HashSet
ଳxin的博客
04-14 95
手写源代码（一）——set&map
qq_40619263的博客
02-18 525
一、Set是ES6提供给我们的构造函数，能够造出一种新的存储数据的结构，只有属性值，成员值唯一（不重复）。 class MySet{ constructor(iterator){ //判断是否是可迭代对象 if(typeof iterator[Symbol.iterator] !== "function"){ throw new Er...
手写 HashMap 集合基于数组 + 单链表
ws - 兮的博客空间
11-30 202
实现功能 1、put 方法 2、get 方法 3、扩容机制 Entry<K, V> 为数据 Node节点，单链表方法，index重复添加数据到链表最前方 接口 package map17; /** * 纯手写Map接口<br> */ public interface ExtMap<K, V> { /** * TODO 向集合中...
docker部署jkd
08-26
通过访问http://localhost:8080，您可以进入Jenkins的Web界面，并完成一些基本配置，如创建管理员账号、安装所需插件等。这样，您就可以开始使用Jenkins部署Java开发环境了。 请注意，这只是一个简单的示例步骤，您...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值