实现自己的ArrayList和HashMap

最新推荐文章于 2025-02-11 18:24:55 发布
最新推荐文章于 2025-02-11 18:24:55 发布
阅读量677 收藏
点赞数
文章标签： java 面向对象
本文通过自定义实现ArrayList和HashMap，深入浅出地讲解这两种数据结构的存储方式和内部运作机制。具体包括ArrayList的数组存储原理及扩容机制，以及HashMap的数组加链表存储结构、哈希碰撞解决策略、rehash过程等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

ArrayList的存储就是一个数组，


HashMap的存储是一个数组加一个链表，下面这张图来自: http://beyond99.blog.51cto.com/1469451/429789


以下实现的MyArrayList及MyHashMap，在实际的工作中都是用不上的，最有可能用得到的地方就是面试找工作以及忽悠别人了。工作中虽然用不上，但是并不代表没有用，它可以帮助我们去理解他们的实现原理，等实现完后再去仔细查看JDK中的源码，就会发现别人实现当中那些可供学习的地方。

MyArrayList

[java]  view plain copy
  1. public class MyArrayList<E> {  
  2.     private int capacity = 10;  
  3.     private int size = 0;  
  4.     private E[] values = null;  
  5.   
  6.     @SuppressWarnings("unchecked")  
  7.     public MyArrayList() {  
  8.         values = (E[]) new Object[capacity];  
  9.     }  
  10.   
  11.     @SuppressWarnings("unchecked")  
  12.     public MyArrayList(int capacity) {  
  13.         this.capacity = capacity;  
  14.         values = (E[]) new Object[this.capacity];  
  15.     }  
  16.   
  17.     public void put(E e) {  
  18.         if (e == null) {  
  19.             throw new RuntimeException("The value should not be null.");  
  20.         }  
  21.         if (size >= capacity) {  
  22.             enlargeCapacity();  
  23.         }  
  24.         values[size] = e;  
  25.         size++;  
  26.     }  
  27.   
  28.     public E get(int index) {  
  29.         if (index >= size) {  
  30.             throw new RuntimeException("The index:" + index + " is out of band.");  
  31.         }  
  32.         return values[index];  
  33.     }  
  34.   
  35.     public void remove(int index) {  
  36.         if (index >= size) {  
  37.             throw new RuntimeException("The index:" + index + " is out of band.");  
  38.         }  
  39.         for (int i = index; i < size - 1; i++) {  
  40.             values[i] = values[i + 1];  
  41.         }  
  42.         values[size - 1] = null;  
  43.         size--;  
  44.     }  
  45.   
  46.     @SuppressWarnings("unchecked")  
  47.     private void enlargeCapacity() {  
  48.         capacity = capacity * 2;  
  49.         E[] tmpValues = (E[]) new Object[capacity];  
  50.         System.arraycopy(values, 0, tmpValues, 0, size);  
  51.         values = tmpValues;  
  52.     }  
  53.   
  54.     public String toString() {  
  55.         StringBuilder sb = new StringBuilder();  
  56.         sb.append("[");  
  57.         for (int i = 0; i < size; i++) {  
  58.             sb.append(values[i]).append(",");  
  59.         }  
  60.         if (size > 0) {  
  61.             sb.deleteCharAt(sb.length() - 1);  
  62.         }  
  63.         sb.append("]");  
  64.         return sb.toString();  
  65.     }  
  66.   
  67.     /** 
  68.      * @param args 
  69.      */  
  70.     public static void main(String[] args) {  
  71.         MyArrayList<String> myList = new MyArrayList<String>();  
  72.         myList.put("1");  
  73.         myList.put("2");  
  74.         myList.put("3");  
  75.         myList.put("4");  
  76.         myList.put("5");  
  77.         myList.put("6");  
  78.         myList.put("7");  
  79.         myList.put("8");  
  80.         myList.put("9");  
  81.         myList.remove(7);  
  82.         System.out.println(myList.toString());  
  83.     }  
  84.   
  85. }  

MyHashMap

[java]  view plain copy
  1. public class MyHashMap<K, V> {  
  2.     //initialization capacity  
  3.     private int capacity = 10;  
  4.     //total entities  
  5.     private int size = 0;  
  6.     private Entity<K, V>[] entities = null;  
  7.   
  8.     @SuppressWarnings("unchecked")  
  9.     public MyHashMap() {  
  10.         entities = new Entity[capacity];  
  11.     }  
  12.   
  13.     public void put(K key, V value) {  
  14.         if (key == null) {  
  15.             throw new RuntimeException("The key is null");  
  16.         }  
  17.         reHash();  
  18.         Entity<K, V> newEntity = new Entity<K, V>(key, value);  
  19.         put(newEntity, this.entities, this.capacity);  
  20.     }  
  21.   
  22.     private void put(Entity<K, V> newEntity, Entity<K, V>[] entities, int capacity) {  
  23.         int index = newEntity.getKey().hashCode() % capacity;  
  24.         Entity<K, V> entity = entities[index];  
  25.         Entity<K, V> firstEntity = entities[index];  
  26.         if (entity == null) {  
  27.             entities[index] = newEntity;  
  28.             size++;  
  29.         } else {  
  30.             if (newEntity.getKey().equals(entity.getKey())) {//Find the same key for the first entity, if find then replace the old value to new value  
  31.                 newEntity.setNext(entity.getNext());  
  32.                 newEntity.setPre(entity.getPre());  
  33.                 if (entity.getNext() != null) {  
  34.                     entity.getNext().setPre(newEntity);  
  35.                 }  
  36.                 entities[index] = newEntity;  
  37.             } else if (entity.getNext() != null) {  
  38.                 while (entity.getNext() != null) {//Find the same key for all the next entity, if find then replace the old value to new value  
  39.                     entity = entity.getNext();  
  40.                     if (newEntity.getKey().equals(entity.getKey())) {  
  41.                         newEntity.setPre(entity.getPre());  
  42.                         newEntity.setNext(entity.getNext());  
  43.                         if (entity.getNext() != null) {  
  44.                             entity.getNext().setPre(newEntity);  
  45.                         }  
  46.                         entities[index] = newEntity;  
  47.                         return;  
  48.                     }  
  49.                 }  
  50.                 //Cannot find the same key, then insert the new entity at the header  
  51.                 newEntity.setNext(firstEntity);  
  52.                 newEntity.setPre(firstEntity.getPre());  
  53.                 firstEntity.setPre(newEntity);  
  54.                 entities[index] = newEntity;  
  55.                 size++;  
  56.             } else {  
  57.                 //Cannot find the same key, then put the new entity in head  
  58.                 newEntity.setNext(firstEntity);  
  59.                 firstEntity.setPre(newEntity);  
  60.                 entities[index] = newEntity;  
  61.                 size++;  
  62.             }  
  63.         }  
  64.     }  
  65.   
  66.     public V get(K key) {  
  67.         if (key == null) {  
  68.             throw new RuntimeException("The key is null");  
  69.         }  
  70.         int index = key.hashCode() % capacity;  
  71.         Entity<K, V> entity = entities[index];  
  72.         if (entity != null) {  
  73.             if (entity.getKey().equals(key)) {  
  74.                 return entity.getValue();  
  75.             } else {  
  76.                 entity = entity.getNext();  
  77.                 while (entity != null) {  
  78.                     if (entity.getKey().equals(key)) {  
  79.                         return entity.getValue();  
  80.                     }  
  81.                     entity = entity.getNext();  
  82.                 }  
  83.             }  
  84.   
  85.         }  
  86.         return null;  
  87.     }  
  88.   
  89.     public void remove(K key) {  
  90.         if (key == null) {  
  91.             throw new RuntimeException("The key is null");  
  92.         }  
  93.         int index = key.hashCode() % capacity;  
  94.         Entity<K, V> entity = entities[index];  
  95.         if (entity != null) {  
  96.             if (entity.getKey().equals(key)) {  
  97.                 if (entity.getNext() != null) {//remove the first entity  
  98.                     entity.getNext().setPre(entity.getPre());  
  99.                     entities[index] = entity.getNext();  
  100.                     entity = null;  
  101.                 } else {//empty this index  
  102.                     entities[index] = null;  
  103.                 }  
  104.                 size--;  
  105.             } else {  
  106.                 entity = entity.getNext();  
  107.                 while (entity != null) {  
  108.                     if (entity.getKey().equals(key)) {  
  109.                         if (entity.getNext() != null) {  
  110.                             entity.getPre().setNext(entity.getNext());  
  111.                             entity.getNext().setPre(entity.getPre());  
  112.                             entity = null;  
  113.                         } else {  
  114.                             //release the found entity  
  115.                             entity.getPre().setNext(null);  
  116.                             entity = null;  
  117.                         }  
  118.                         size--;  
  119.                         return;  
  120.                     }  
  121.                     entity = entity.getNext();  
  122.                 }  
  123.             }  
  124.         }  
  125.     }  
  126.   
  127.     public String toString() {  
  128.         StringBuilder sb = new StringBuilder();  
  129.         for (int i = 0; i < capacity; i++) {  
  130.             sb.append("index=").append(i).append("[");  
  131.             boolean hasEntity = false;  
  132.             Entity<K, V> entity = entities[i];  
  133.             if (entity != null) {  
  134.                 hasEntity = true;  
  135.             }  
  136.             while (entity != null) {  
  137.                 sb.append("[").append(entity.getKey()).append("=").append(entity.getValue()).append("]").append(",");  
  138.                 entity = entity.getNext();  
  139.             }  
  140.             if (hasEntity) {  
  141.                 sb.deleteCharAt(sb.length() - 1);  
  142.             }  
  143.             sb.append("]\n");  
  144.         }  
  145.         return sb.toString();  
  146.     }  
  147.   
  148.     /** 
  149.      * Simple re-hash strategy, if the size is bigger than capacity, then do re-hash action 
  150.      */  
  151.     private void reHash() {  
  152.         if (size >= capacity) {  
  153.             int newCapacity = capacity * 2;  
  154.             @SuppressWarnings("unchecked")  
  155.             Entity<K, V>[] newEntities = new Entity[newCapacity];  
  156.             for (int i = 0; i < capacity; i++) {  
  157.                 Entity<K, V> entity = entities[i];  
  158.                 while (entity != null) {  
  159.                     put(entity, newEntities, newCapacity);  
  160.                     entity = entity.getNext();  
  161.                 }  
  162.             }  
  163.             this.capacity = newCapacity;  
  164.             this.entities = newEntities;  
  165.         }  
  166.     }  
  167.   
  168.     public static void main(String[] args) {  
  169.         MyHashMap<String, String> map = new MyHashMap<String, String>();  
  170.         map.put("one", "1");  
  171.         map.put("two", "2");  
  172.         map.put("three", "3");  
  173.         map.put("four", "4");  
  174.         map.put("five", "5");  
  175.         map.put("six", "6");  
  176.         map.put("seven", "7");  
  177.         map.put("eight", "8");  
  178.         map.put("nine", "9");  
  179.         map.put("ten", "10");  
  180.         System.out.println(map.get("one"));  
  181.         System.out.println(map.get("two"));  
  182.         System.out.println(map.get("three"));  
  183.         System.out.println(map.get("four"));  
  184.         System.out.println(map.get("five"));  
  185.         System.out.println(map.get("six"));  
  186.         System.out.println(map.get("seven"));  
  187.         System.out.println(map.get("eight"));  
  188.         System.out.println(map.get("nine"));  
  189.         System.out.println(map.get("ten"));  
  190.         System.out.println(map.toString());  
  191.   
  192.         map.remove("nine");  
  193.         map.remove("three");  
  194.         System.out.println(map.get("one"));  
  195.         System.out.println(map.get("two"));  
  196.         System.out.println(map.get("three"));  
  197.         System.out.println(map.get("four"));  
  198.         System.out.println(map.get("five"));  
  199.         System.out.println(map.get("six"));  
  200.         System.out.println(map.get("seven"));  
  201.         System.out.println(map.get("eight"));  
  202.         System.out.println(map.get("nine"));  
  203.         System.out.println(map.get("ten"));  
  204.         System.out.println(map.toString());  
  205.     }  
  206. }  
  207.   
  208. class Entity<K, V> {  
  209.     private K key;  
  210.     private V value;  
  211.     private Entity<K, V> pre;  
  212.     private Entity<K, V> next;  
  213.   
  214.     public Entity(K key, V value) {  
  215.         this.key = key;  
  216.         this.value = value;  
  217.     }  
  218.   
  219.     public K getKey() {  
  220.         return key;  
  221.     }  
  222.   
  223.     public void setKey(K key) {  
  224.         this.key = key;  
  225.     }  
  226.   
  227.     public V getValue() {  
  228.         return value;  
  229.     }  
  230.   
  231.     public void setValue(V value) {  
  232.         this.value = value;  
  233.     }  
  234.   
  235.     public Entity<K, V> getPre() {  
  236.         return pre;  
  237.     }  
  238.   
  239.     public void setPre(Entity<K, V> pre) {  
  240.         this.pre = pre;  
  241.     }  
  242.   
  243.     public Entity<K, V> getNext() {  
  244.         return next;  
  245.     }  
  246.   
  247.     public void setNext(Entity<K, V> next) {  
  248.         this.next = next;  
  249.     }  
  250.   
  251. }  

IT冲浪者
关注
ArrayList与HashMap
simle的博客
08-08 710
list与map都是两个接口： Collection（接口）->List（接口）->ArrayList（类） Map（接口）->HashMap（类） list是有序存储，而ArrayList就是它的一个实现类，用数组实现的list map是根据一个对象查找另外一个对象，即根据关键字查找对象，HashMap就是其中一个实现类，它是利用哈希表实现的map，就是利用对象的hashcod...
【Java八股面试系列】Arraylist和HashMap的底层原理
asdfasaa的博客
04-01 1531
****底层是使用名为 **的动态数组进行实现，与Java中的数组相比，她的容量能够动态的进行增长。在我们更新元素的时候，我们会通过方法来确保我们的容量够用，如果容量不够则调用**方法对我们的数组进行扩容为1.5倍，然后将我们原来的的数组复制过去。ArrayList 和 Vector 的区别?ArrayList 可以添加 null 值吗？ 中可以存储任何类型的对象，包括 值。不过，不建议向 中添加 值， 值无意义，会让代码难以维护比如忘记做判空处理就会导致空指针异常。Arraylist 与 Linke
利用HashMap，自己实现一个简易版的HashSet
蒋含竹的博客
02-25 667
简介 HashSet是常用的容器类，主要特征表现为不可重复性 其内部实现主要用到了HashMap，利用了HashMap的键的不可重复性 使用HashMap的键作为其元素，同时令HashMap的所有的value为同一个Object 代码如下 import java.util.HashMap; /** * 自己实现一个简易版的HashSet * * @author ALion...
实现ArrayList和HashMap类
qingmengwuhen1的博客
08-25 436
实现ArrayList类，定义为MyArrayList. package practice.collections.myArrayList; /** * 实现ArrayList类 * @author 835890 * * @param */ public class MyArrayList { private int capacity = 16; private int s
ArrayList和HashMap
a15271801276的博客
11-01 298
ArrayList 1.ArrayList继承了List/RandomAccess/Cloneable/serializable 接口，内部维护一个数组用来存放对象。 2.RandomAccess接口，用于标明实现该接口的List支持快速随机访问，也就是For循环速度会比用iterator要快。LinkedList没有实现该接口，适合用iterator来遍历。 3.ArrayList 初始容量是10，每次扩容增加一半 HashMap 1.默认长度是16，每扩容一次加倍。 2.底层结构是数组...
ArrayList和HashMap如何自己实现实例详解
08-31
ArrayList和HashMap是Java编程语言中两种常用的集合类，它们分别实现了List接口和Map接口，用于存储和操作数据。在本实例中，我们将探讨如何自己实现这两个数据结构，以加深对它们工作原理的理解。 首先，ArrayList...
Java集合框架详解：从ArrayList到HashMap
省赚客开发者博客
08-04 477
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！它不保证映射的顺序，特别是它不保证顺序在随时间的变化。HashSet是一个基于哈希表的Set集合，它不允许有重复的元素，并且不保证集合的迭代顺序。TreeMap是一个基于红黑树的Map接口实现，保证键的自然排序。TreeSet是一个基于红黑树的Set集合，保证元素的自然排序。HashSet的优点是查找、插入和删除元素的效率高；
ArrayList和HashMap、Set
热门推荐
诗水人间
07-10 12万+
List、Set、Map都是线程不安全的 ArrayList 底层是数组，传的是一个Object泛型 初始值长度10，jdk8是空（采用懒加载机制） 扩容会变成10+10/2=15 ArrayList 是线程不安全的 ArrayList的故障现象 导致原因 解决方法 优化建议 异常： 多个线程进行add可能会报java.util.ConcurrentModificationException异常 导致原因： 多个线程同时写入同一个位置 解决方法： 解决多线程并发写入异常使用 优化建议： 1.new V
HashMap与ArrayList的PK
轻轻草原
11-04 256
本周要闻，这一周自己先干了两天的代码优化工作，优化自己的导入代码，在虎哥的指引下自己一步步理解优化这个过程很艰辛啊，其中在这个过程中理解到了，一个好的设计并非那么容易，同样一段程序如何让这段代码学的非常有精髓，有思想，这一点是非常不容易的。 对于以前自己很多地方都是用的list这样在循环太可怕了，五千次不怕，怕的是五千乘以五千这样你的代码现的非常没有代码深度，这样你的代码循环起来太慢了，这个...
ArrayList和HashMap简析
Insist__的博客
05-12 1501
HashMap：无序，存储个数不固定，可以动态添加数据，以键值对的形式存储数据，其中键是不能重复的，值是可以重复的。1、声明：               HashMap&lt;引用数据类型,引用数据类型 &gt; map;2、定义 ：  HashMap&lt;Integer, String&gt; map1 = new HashMap&lt;Integer,String&gt;(); // 推荐...
ArrayList和HashMap详解
qq_38668544的博客
04-13 1052
文章详细介绍了ArrayList和HashMap底层实现原理以及扩容机制，包括常见面试题
ArrayList和hashMap的遍历
zbt_xioazhukuaipao的博客
03-09 313
hashMap的遍历方式Map&lt;String,String&gt; map = new hashMap&lt;String,String&gt;;     map.put("1","Java");     map.put("2","C++");     map.put("3","PHP"); 1.取值遍历for(String key : map.key
ArrayList和HashMap解读
DavinDeng的博客
03-17 409
ArrayList 数据结构：数组 特点 查询快：数组是一块连续的空间，通过首地址，可以找到数组；通过索引可以找到数组中的某一个元素 增删慢：数组的长度是固定的，增删一个元素，必须创建一个新的数组，把原数组的数据复制过来 private static final int DEFAULT_CAPACITY = 10; 初始容量：10 ArrayList<> list ...
集合讲解（ArrayList、HashMap等）
kumufengchun_的博客
05-19 1295
**集合讲解（ArrayList、HashMap等）**CollectionListArrayListLinkedListVectorSetMapHashtableHashMapSortedMap数据结构（扩展巩固）线性表队列栈 * 首先我们了解一下集合的用处 最主要的是以前用数组作为容器存储时，总会遇到扩容问题，数组不能自动扩容在之就是数组进行增删操作时，需要开发者自己实现 集合就优化了这些 所有集合的底层都是由Collection，Map，Iterator 三个接口派生而出； Collect
ArrayList和HashMap的比较
逸致
03-16 2万+
ArrayList和HashMap是Java项目开发中经常用到的容器，下面来比较一下两者之间的区别！例子：//ArrayListArrayList array = new ArrayList(); array.add("张三"); array.add("李四"); array.add("王五"); System.out.println("ArrayList的元素个数为："+array.size()...
（java1.8）部分java集合（ArrayList，LinkList，HashMap，ConcurrentHashMap）源码分析
sjs_caomei的博客
07-22 209
ArrayList 属性 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { ​ //初始容量大小10 private static fina...
Java集合框架核心组件详解：ArrayList与HashMap
最新发布
qq_73993301的博客
02-11 502
ArrayList和HashMap
ArrayList与HashMap自实现解析
"这篇教程详细解释了如何自己动手实现ArrayList和HashMap这两个常见的Java集合类，旨在帮助读者理解它们的内部工作原理。通过阅读和实践这些自定义实现，开发者可以更深入地了解这两种数据结构的机制，并在面试或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值