手写Linklist,ArrayList,HashMap

最新推荐文章于 2024-01-17 22:50:36 发布
原创 最新推荐文章于 2024-01-17 22:50:36 发布 · 537 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hashmap #arraylist #linklist

本文详细解析了Java集合框架的底层实现，包括HashMap、LinkedList和ArrayList的手写代码，对比了不同集合的特点及适用场景，深入探讨了HashTable和ConcurrentHashMap的线程安全机制。

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

在这里插入图片描述
上面是我个人画的简单的原理图，通过上面的图片我们基本也是可以看出几个集合底层到底是什么。所以要手写一个简单自己的集合也是非常简单的，
手写思路：
1、创建一个接口然后定义需要实现的方法
2、现实接口然后编写每个方法的简单逻辑
3、测试成果
在这里插入图片描述
在这里插入图片描述
这是我个人写的代码目录，还是很简单的
1、HashMap:

public interface EasyMap<k,v> {

int size();

boolean isEmpty();

Object get(Object key);

void put(Object key,Object value);

interface Entry<k,v>{
    k getKey();
    v getValue();
}

}

/**

  • Created by LENOVO on 2019/5/9.

  • hashmap底层其实就是 数组+链表 （这是jdk7以前，8以后当链表长度达到12后则是红黑树）
    */
    public class EasyHashMap implements EasyMap{
    //默认初始容器大小
    private final int DEFAULT_INITIAL_CAPACITY=1<<4;
    // 根据定义的静态内部类，初始化链表，长度为默认长度
    Node[] hashMap = new Node[DEFAULT_INITIAL_CAPACITY];
    // 加载因子
    private final float DEFAULT_LOAD_FACTOR = 0.75f;
    //长度
    int size=0;

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

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

    @Override
    public void put(Object key, Object value) {
    // 判断是否超过加载因子（是都一定要先判断，一开始加入时就开始执行判断，也很耗时
    // 或许可以到达一定程度后再开始判断以减少判断次数）
    if (++size * 1.0 / hashMap.length > DEFAULT_LOAD_FACTOR)
    rehash();
    //计算hashcode
    int hashvalue=hash(key);
    // 计算出应该存放的位置
    int index=indexFor(hashvalue,hashMap.length);
    Node node = new Node(hashvalue,key, value);
    input(node,hashMap,index);

    }
    // 添加函数
    private void input(Node node, Node[] hashMap, int index) {
    //判断下标是否存在值，不存在则直接设置值
    if(hashMap[index]==null){
    hashMap[index]=node;
    }else{
    // 否则，遍历链表
    // 先用temp记下HeadNode[index]，然后遍历链表
    //存在则key则不添加
    Node temp = hashMap[index];
    if (node.key.equals(temp.key)) {
    System.out.println(“键值” + temp.key + “已存在”);
    } else {
    while (temp.next != null) {
    temp = temp.next;
    }
    }
    temp.next = node; // 把要加入的节点加到链表最后
    }
    }

    @Override
    public Object get(Object key) {
    int index = indexFor(hash(key), hashMap.length);
    // 先找到在哪条链中
    Node temp = hashMap[index];
    // 先判断头节点是否为空
    if (temp == null)
    return null;
    else {
    if (key .equals(temp.key) )
    return temp.value;
    else {// 遍历链表
    while (temp.next != null) {
    temp = temp.next;
    if (key == temp.key)
    return temp.value;
    }
    }
    }
    return null;
    }

    //这个方法的好处就是
    public void rehash() {
    // 每次扩展都把当前的哈希表增大一倍
    Node[] newHeadNode = new Node[hashMap.length * 2];

     // 把原来的哈希表依次重新hash进去
 for (int i = 0; i < hashMap.length; i++) {
     if (hashMap[i] != null) {
         int newindex = indexFor(hashMap[i].hashCode, hashMap.length * 2);

         // 重新new新的节点来保存原理hash表中的键值对
         Node rehashheadnode = new Node(hashMap[i].hashCode,hashMap[i].key, hashMap[i].value);
         input(rehashheadnode, newHeadNode, newindex);
         Node temp = hashMap[i];
         while (temp.next != null) {
             temp = temp.next;
             Node rehashnextnode = new Node(temp.hashCode,temp.key, temp.value);
             int nextindex = indexFor(temp.hashCode, newHeadNode.length);
             input(rehashnextnode, newHeadNode, nextindex);
         }

     }
 }
 // 重新设置节点数组的引用，就是把newHeadNode数组的地址赋给HeadNode（可以理解为让HeadNode指向newHeadNode）
 hashMap = newHeadNode;

    }

    // 获取插入的位置下标(取模运算)
    public int indexFor(int hashValue,int length){
    return hashValue % length;
    }

    // 获取插入的位置,根据Obeject对象的hashcode 获取hash值
    public int hash(Object key){
    int h;
    //返回值必须是整数
    return Math.abs((key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16));
    }

    static class Node implements EasyMap.Entry{
    int hashCode;//hash值
    Object key;
    Object value;
    Node next;//下一个节点
    Node(int hashCode, Object key, Object value){
    this.hashCode=hashCode;
    this.key=key;
    this.value=value;
    }
    @Override
    public Object getKey() {
    return null;
    }

     @Override
 public Object getValue() {
     return null;
 }

    }
    }

2、LinkList:

public interface EasyList {

//集合大小
int size();
//集合是否为空
boolean isEmpty();
//是否存在某个值
boolean contians(Object o);
//清空集合
void clear();
//添加
boolean add(Object o);
//移除某个
boolean remove(int index);

Object get(int index);

}

public class EasyLinkedList implements EasyList {

class Node {
    Object obj;
    Node previous;//前一个
    Node next;//下一个

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public Node getPrevious() {
        return previous;
    }

    public void setPrevious(Node previous) {
        this.previous = previous;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

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

    public Node() {

    }
}

// LinkedList相应属性
private Node first = null;
private Node last = null;
private int size = 0;

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

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

@Override
public boolean contians(Object o) {
    for (int i = 0; i < size; i++) {
        if (first != null) {
            o.equals(first.next.obj);
            return true;
        }
    }
    return false;
}

@Override
public void clear() {
    first.next = null;
    first.previous = null;
    last.next = null;
    last.previous = null;
    first.obj = null;
    last.obj = null;
    size = 0;
}

@Override
public boolean add(Object o) {
    /**
     * 1.当第一个元素为空的时候则不存在前一个，设置前一个为空然后第一个和最后一个都是当前的值
     * 2、当存在第一个的时候，前一个则是之前集合的最后一个，当前新增的就是目前集合的最后一个元素，
     * 前一个的下一个就是当前元素
     */
    Node n = new Node();
    if (first == null) {
        n.setPrevious(null);
        n.setObj(o);
        n.setNext(null);
        first = n;
        last = n;
    } else {
        n.setPrevious(last);
        n.setObj(o);
        n.setNext(null);
        last.setNext(n);
        last = n;
    }
    size++;
    return true;
}

@Override
public boolean remove(int index) {
    Node temp = node(index);
    if (temp == first || temp == last) {
        if (temp == first) {
            //如果是第一个，则把第一个的下个的前一个元素设为空，下个元素设为第一个
            temp.next.previous = null;
            first = temp.next;
        } else {
            //如果是最后一个，则把最后个的的前一个元素设为空，前一个元素设为最后一个
            temp.previous.next = null;
            last = temp.previous;
        }
    } else {
        temp.next.previous = temp.previous;
        temp.previous.next = temp.next;

    }
    return true;
}

@Override
public Object get(int index) {
    rangeCheck(index);
    Node temp = node(index);
    return temp.obj;
}

/**
 * 简单的遍历链表获取到对应下标的值
 *
 * @param index
 * @return
 */
public Node node(int index) {
    Node temp = null;
    if (first != null) {
        temp = first;
    }
    for (int i = 0; i < index; i++) {
        temp = temp.next;
    }
    return temp;
}

// 对索引下标进行合法性检查
private void rangeCheck(int index) {
    if (index < 0 || index >= size) {
        try {
            throw new IndexOutOfBoundsException();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

}

3、ArrayList:
public interface EasyList {

public void add(T object);

public void add(int index,T object);

public Object remove(int index);

public int size();

public Object get(int index);

public void update(int index,Object obj);

}

public class EasyArrayList implements EasyList {

private transient Object[] elementData;

private int size;

public EasyArrayList(){
    this(10);
}

public EasyArrayList(int initialCapacity) {
    if(initialCapacity<0)
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    elementData = new Object[initialCapacity];

}

@Override
public void add(T object) {
    elementData[size++]=object;
}

@Override
public void add(int index, T object) {
    rangeCheck(index);
    System.arraycopy(elementData, index, elementData, index+1, size);
    elementData[index]=object;
    size++;
}

@Override
public Object remove(int index) {
    Object object=get(index);
    int numMoved = elementData.length-index-1;
    if(numMoved>0){
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    }
    elementData[--size]=null;
    return object;

}

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

@Override
public Object get(int index) {
    rangeCheck(index);
    return  elementData[index];
}

@Override
public void update(int index, Object obj) {
    rangeCheck(index);
    elementData[index]=obj;
}



/**
 * 检测数组是否下标越界
 * @param index
 */
private void rangeCheck(int index) {
    if (index >= size) {
        throw new IndexOutOfBoundsException("length--->"+index);
    }
}

}

总结：
ArrayList：数组集合。 查询、修改、新增（尾部新增）快，删除、新增（队列中间）慢，适用于查询、修改较多的场景。
LinkedList：双向链表集合。查询、修改慢（需要遍历集合），新增，删除快（只需要修改前后节点的链接即可），适用于新增、删除较多的场景。
HashMap：结合数组和链表的优势，期望做到增删改查都快速，时间复杂度接近于O(1)。当hash算法较好时，hash冲突较低。适用于增删改查所有场景。

扩展：
HashTable:
底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化
初始size为11，扩容：newsize = olesize*2+1
计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

ConcurrentHashMap:
底层采用分段的数组+链表实现，线程安全
通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

ArrayList与HashMap
simle的博客
08-08 711
list与map都是两个接口： Collection（接口）->List（接口）->ArrayList（类） Map（接口）->HashMap（类） list是有序存储，而ArrayList就是它的一个实现类，用数组实现的list map是根据一个对象查找另外一个对象，即根据关键字查找对象，HashMap就是其中一个实现类，它是利用哈希表实现的map，就是利用对象的hashcod...
面试02——线程、HashMap、、、
HRX98的博客
03-12 1651
一、线程相关 1、线程池原理，讲讲线程池里面的核心参数，你平时是怎么用线程池的 基本思想：预先创建多个线程对象，放入线程池，执行完后调用，用完还原到线程池。 优点： * 提高线程的利用率 * 提高程序的响应速度 * 便于统一管理线程对象 * 可以控制最大并发数 import org.junit.Test; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ExecutorService; import
ArrayList HashMap
XIAOCONG的博客
08-03 559
集合
Arraylist HashMap
evanYang的博客
05-09 212
集合的概述 集合概念：集合是java中提供得一种容器，可以用来存储多个数据 集合和数组的区别： 数组的长度是固定的，集合的长度是可变的 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象类型可以不一致 集合框架 集合按照其存储结构可分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map Collecti...
ArrayList, HashMap 方法汇总
Beyond_Nothing
03-06 740
文章目录HashMap 玩法案例ArrayList 玩法案例 HashMap 玩法案例 package com.beyond; import java.util.*; class Person{ private String name; private Integer age; public Person(String name, Integer age){ this.name = name; this.age = age; }
ArrayList,HashMap
02-26
ArrayList,HashMap
面试03——整理
HRX98的博客
03-12 2078
1、线程相关 1.线程池原理，讲讲线程池里面的核心参数，你平时是怎么用线程池的 2、线程池的应用与配置； 3.谈谈你理解的IO和多线程 4、网络io什么的 5.实现多线程有哪些方式 6.线程的创建方法 核心线程池的核心参数 阻塞队列 阻塞策略 7.线程的五种状态，有哪些方法控制他们状态，wait和sleep的区别， 7、threadlocal线程复用问题 8.线程池 2、必问相关 1、特别是jvm，hashmap，redis，mq这几个 2、hashmap，秒杀，jvm内存、jc，spring 生命周期be
十年架构师强烈推荐的面试通关宝典，你知道多少？
m0_62714732的博客
11-10 791
一 数据库 1．常问数据库查询、修改（SQL查询包含筛选查询、聚合查询和链接查询和优化问题，手写SQL语句，例如四个球队比赛，用SQL显示所有比赛组合；举例2：选择重复项，然后去掉重复项；） 数据库里的密码如何加密（md5）； (1)数据库的密码加密:单向加密,insert into users (username,password) values (‘mike’,MD5(‘guessme’)); (2)双向加密:insert into users (username ,password) value
大厂代码面手撕基础题
香农三定律的博客
01-17 655
嘿嘿喜欢本系列博客的可以关注下，以后除了会继续更新面试手撕代码文章外，还会出其他系列的文章！
自学Android，学多久可以加入字节跳动？
weixin_43901866的博客
01-12 1709
在回答自学Android，学多久可以加入字节跳动之前，我们先需要了解加入字节跳动的岗位职能要求，下图是我们从boss直聘上选取的今日头条Android工程师职位描述。 职位要求 假如我变成了一只小白。我想自学 Android，并且想要找到一份工作，我预计需要 6 个月的时间，前提条件是每天都处于高效率的学习状态当中，并且每天的学习时间至少在 12 个小时以上。 即便是这样，我敢肯定，找到的工作肯定不会太好，勉强能够维持生活吧，毕竟是零基础入门啊。如果想更进一步，真正成为一名不可或缺的高级Android工程
抽象类 接口 ArrayList LinkList HashMap
wlj1442的博客
10-27 1094
抽象类 抽象类其实和普通类一样，只不过多了抽象方法，可以用private修饰变量，但是不能修饰抽象方法，因为抽象方法需要子类继承它 抽象类里可以有抽象方法，也可以不写抽象方法，但是有抽象方法的类一定是抽象类 抽象类不能用来创建对象 不允许使用final和abstract同时修饰一个抽象方法或者抽象类 接口 接口中可以含有变量和方法。但是要注意，接口中的变量会被隐式地指定为 public static final 变量（并且只能是 public static final变量，用 private 修饰会报
【数据结构】Java容器——ArrayList、LinkedList、HashMap（红黑树）等结构的分析
火火的博客
12-16 4173
文章目录ArrayList和LinkedList使用场景： ArrayList和LinkedList ArrayList是基于数组实现的，LinkedList是基于双链表实现的，因此LinkedList可以作为双向队列 ，栈。 因为Array是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的，可以直接返回数组中index位置的元素，因此在随机访问集合元素上有较好的性能。Array获取数据的时间复杂度是O(1),但是要插入、删除数据却是开销很大的，因为这需要移动数组中插入位置之后的
HashMap嵌套ArrayList
风暴计划
05-22 1100
HashMap嵌套ArrayList，并遍历HashMap/* *需求： *假设HashMap集合的元素是ArrayList。有3个。 *每一个ArrayList集合的值是字符串。 *元素我已经完成，请遍历。 *结果： *         三国演义 *             吕布 *             周瑜 *         笑傲江湖 *             令狐冲 *       ...
ArrayList和HashMap解读
DavinDeng的博客
03-17 409
ArrayList 数据结构：数组 特点 查询快：数组是一块连续的空间，通过首地址，可以找到数组；通过索引可以找到数组中的某一个元素 增删慢：数组的长度是固定的，增删一个元素，必须创建一个新的数组，把原数组的数据复制过来 private static final int DEFAULT_CAPACITY = 10; 初始容量：10 ArrayList<> list ...
实现自己的ArrayList和HashMap
冯立彬的博客
11-05 6853
ArrayList的存储就是一个数组， HashMap的存储是一个数组加一个链表，下面这张图来自: http://beyond99.blog.51cto.com/1469451/429789 以下实现的MyArrayList及MyHashMap，在实际的工作中都是用不上的，最有可能用得到的地方就是面试找工作以及忽悠别人了。工作中虽然用不上，但是并不代表没有用，它可以帮助我们
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_43504447的博客
05-29 2540
以下为个人理解: ArrayList ：数组 HashMap: 数组+键值对 所以说在java集合体系其实集合也可以按照某种维度来分为两类: 单列集合 双列集合 ArrayList是属于单列集合 HashMap: 是属于双列集合 两者的add数据的方式是不同的: ArrayList添加数据是会根据底层数组下标去添加的 HashMap是根据添加数据的key经过计算去添加到对应位置的 怎么计算的,我这里简单的讲一下: hashMap会拿到key的hashcode,经过扰动函数后拿到对应的hash值，通过(n-
List、HashMap学习
weixin_44866919的博客
02-22 1212
容器包含List、Set、Map等，此次学习以List和HashMap为主了解源码。
ArrayList嵌套HashMap
wangyanming123的博客
04-21 3005
ArrayList嵌套HashMap
arraylist和linklist和hashmap区别
最新发布
05-28
ArrayList、LinkedList和HashMap都是Java集合框架中常用的数据结构，它们的区别如下： 1. ArrayList：底层是基于数组实现的动态数组，支持随机访问，适用于读取操作频繁，写入操作较少的场景。缺点是插入或删除元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值