HashMap常见面试题和源码注释（完整版在最后面）

最新推荐文章于 2022-05-18 08:49:35 发布
最新推荐文章于 2022-05-18 08:49:35 发布
阅读量8.5w 收藏 9
点赞数 14
分类专栏： # jdk源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41813208/article/details/108663452
版权

关于HashMap的几个面试题

  1. put数据时key与已有数据的hashCode相等时会怎么样？

    答：产生hash碰撞，hash码相同，则通过key的equals()方法比较值是否相同.
    key值不相等：则会在该节点的链表结构上新增一个节点（如果链表长度>=8且 数组节点数>=64 链表结构就会转换成红黑树）
    key值相等：则用新的value替换旧的value

  2. 什么时候会产生hash碰撞? 如何解决hash碰撞？

    答：只要两个元素产生的hash值相同就会产生hash碰撞。
    jdk8前采用链表解决hash碰撞、jdk8以后采用链表 + 红黑树解决hash碰撞。

  3. 如果hashCode相同，如何存储key-value对?

    答：hashCode相同，进一步通过equals比较内容是否相同
    相同：新值覆盖旧值
    不相同：将新的key-value添加到HashMap中

  4. hashMap是怎么扩容的？

    答：通过put方法不断添加数据时，如果元素个数超过了阈值旧会触发扩容，默认情况是原来的2倍，并且将原来的数据复制过来

  5. 如果确定了要存储的元素个数n，设置多少的初始容量可以减少扩容导致的性能损失？

    答：应该设置初始容量m= n / 0.75 + 1 取整即可减少resize导致的性能损失。

HashMap存储原理

map以key:value的形式存储，而HashMap则是对key进行hash算法得到一个hash值，然后根据特定算法得到索引值

如果是直接new HashMap()初始容量为0,底层创建的是一个空数组
添加第一个元素后会触发 扩容 达到默认初始容量16。

我们也都知道HashMap底层是数组 + 链表 + 红黑树(jdk1.8以后)

说起HashMap中的hash算法，是根据key的类型而定，key如果是String类型则会调用String.hashCode()返回一个hash值。

如果是自定义类 作为HashMap的key则必须重写hashCode方法和Object.equals()方法。
否则会直接调用父类Object.hashCode()和Object.equals()方法，那么就不好达到我们想要的效果
举个例子：使用下面这个类作为key

class Person{
	private String name;
	private Integer age;
	Person(String name,Integer age){
		this.name=name;
		this.age=age;
	}
}

会产生如下问题：

  1. 存的进去，取不出来

    HashMap hashMap = new HashMap<Person,String>();
//存
Person p1 = new Person("zhangsan",18);
hashMap.put(p1,"职业：程序员");
//取
Person p2 = new Person("zhangsan",18);//想当然的创建一个对象
//会得到null，因为此 Person 非 彼 Person。但我们希望得到 "职业：程序员"
String info = hashMap.get(p2);

    会得到null（当然也有可能得到正确的数据，得碰运气），为什么呢？因为Person没有重写父类Object的hashCode和equals方法，那么HashMap就会调用Object的这两个方法进行存和取操作。两次new就得到两个Person实例两个不同得对象，他们得地址和hash值很显然不相同。因此存得进去，但不好取出来。

红黑树

链表长度>= 8且Node数组长度>= 64，将链表转换为红黑树
红黑树得查询效率是log(n)也因此才加入红黑树结构

jdk1.8中的HashMap

HashMap的源码中有2k多行代码，如果粘贴出来会很长，不方便解读源码。

对HashMap进行简化和总结。最终将2k行代码尽量的缩成几十行的内容，方便理解。

初步的简化

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

	/*
	* 下面是成员属性的定义
	*/
    private static final long serialVersionUID = 362498820763181265L;  // 实现序列化接口的序列化默认版本号
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始容量等于16
    static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次方也等于 Integer.MAXVALUE
    static final float DEFAULT_LOAD_FACTOR = 0.75f;// 默认的扩容因子
    static final int TREEIFY_THRESHOLD = 8; // 红黑数的阈值，hash碰撞达到了8链表才会转换成红黑数
    static final int UNTREEIFY_THRESHOLD = 6;// hash碰撞小于6才解开红黑树结构转换成链表结构
    static final int MIN_TREEIFY_CAPACITY = 64; // 树型容量的最小值，这个值不能小于 4*TREEIFY_THRESHOLD = 32
    transient Node<K,V>[] table;// 真正存储数据的数组结构
    transient Set<Map.Entry<K,V>> entrySet;// 所有节点Entry的集合
    transient int size;// hashMap的大小
    transient int modCount;// 并发修改计数，用于检测并发修改异常的值
    int threshold;// 扩容的条件，threshold=0.75*容量
    final float loadFactor;// 加载因子，默认值为0.75.可以通过构造方法重新设定
    
   /**
    *
    * 下面的是静态内部类，可以粗略的过一眼，不用细究代码。
    * 
    */
    // 这个结构很重要，是真正存储数据的数据结构
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; // 存储的 hash值
        final K key;    // 存储的 key值
        V value;        // 存储的 value值
        Node<K,V> next; // 链表结构，下一个节点的数据。结合前面定义的 transient Node<K,V>[] table;因此说HashMap的存储结构是数组+链表。
        
        Node(int hash, K key, V value, Node<K,V> next) {} // 构造方法
        
        public final K getKey() {}        // 获取当前节点的key
        public final V getValue() {}      // 获取当前节点的value
        public final String toString() {} // 返回{key:value}的字符串
        public final int hashCode() {}    // hash当前节点的key，value并返回hash值
        public final V setValue(V newValue) {}	// 给节点设置value值
        public final boolean equals(Object o) {}// 实现equals方法用于比较o与当前节点是否相等
    }

	/*
	* 树节点数据结构，重要部分
	*/
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;	// 父节点
        TreeNode<K,V> left;		// 左节点
        TreeNode<K,V> right;	// 右节点
        TreeNode<K,V> prev;		// 删除后需要取消链接
        boolean red;			// 用来判断当前节点是红还是黑节点
        /* 构造方法，创建对象的时候数据也存进来了 */
        TreeNode(int hash, K key, V val, Node<K,V> next) {}
       
        // 查找节点
        final TreeNode<K,V> find(int h, Object k, Class<?> kc) {}
        // 获取红黑树中的节点
        final TreeNode<K,V> getTreeNode(int h, Object k) {}

        // 链表 转换成 红黑树
        final void treeify(Node<K,V>[] tab) {}
        // 红黑树 转换成 链表
        final Node<K,V> untreeify(HashMap<K,V> map) {}
        
        // 添加红黑树节点
        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v) {}
        // 删除红黑树节点
        final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,boolean movable) {}// 移除节点
        final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {} // 拆分
        // 左旋
        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,TreeNode<K,V> p) {}
        // 右旋
        static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,TreeNode<K,V> p) {}
        // 插入元素时保存平衡
        static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,TreeNode<K,V> x) {}
        // 删除元素时保存平衡
        static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,TreeNode<K,V> x) {}
        final TreeNode<K,V> root() {}
        static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {}
        static int tieBreakOrder(Object a, Object b) {}
        static <K,V> boolean checkInvariants(TreeNode<K,V> t) {}
    }
	static Class<?> comparableClassFor(Object x) {/*省略*/} //
	//Entry集合的内部结构，其目的就是实现Set方法，方便获取Set中的Entry（实际存储的数据结构）
    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final int size(){}   // Set中元素个数
        public final void clear(){} // 清空Set
        public final Iterator<Map.Entry<K,V>> iterator() {} // 迭代器，迭代获取Set内容
        public final boolean contains(Object o) {} // 是否包含某个元素
        public final boolean remove(Object o) {}   // 移除某个元素
        public final Spliterator<Map.Entry<K,V>> spliterator() {} // 拆分Set集合，暂没有遇到使用场景。跳过
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {} // 遍历元素，使用函数式接口Consumer，可以使用lambda表达式进行遍历消费
    }
   /*
    * 下面是类迭代器分别代表hash、key、value、Entry
    */
    abstract class HashIterator {
        Node<K,V> next;        // 下一个节点
        Node<K,V> current;     // 当前节点
        int expectedModCount;  // 预期的修改计数
        int index;             // 当前索引值
        HashIterator() {} //构造方法
        public final boolean hasNext() {} // 判断是否还有下一个Node节点
        final Node<K,V> nextNode() {}     // 返回下一个节点Node
        public final void remove() {}     // 移除当前节点
    }
    final class KeyIterator extends HashIterator implements Iterator<K> {public final K next() {  }// 返回下一个节点的 键 key}
    final class ValueIterator extends HashIterator implements Iterator<V> { public final V next() { }//返回下一个节点的 值 value}
    final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> {public final Map.Entry<K,V> next() { }//返回下一个节点}
    /*
    * 下面是Spliterator和上面迭代器一样作用，
    * 只不是这些迭代器可以并行处理
    * 
    */
    static class HashMapSpliterator<K,V> {
        final HashMap<K,V> map;
        Node<K,V> current;          // 当前节点
        int index;                  // 当前索引
        int fence;                  // 上一个节点索引
        int est;                    // 预估值
        int expectedModCount;       // 预期的并发修改次数
        //构造方法
        HashMapSpliterator(HashMap<K,V> m, int origin,int fence, int est,int expectedModCount) {}
        final int getFence() {}//返回上一个节点的索引
        public final long estimateSize() {} // 返回Map的预估个数
    }
	// 该类的目的是解决hashMap存储数据过大，不方便处理，对数据进行拆分，提供性能。
    static final class KeySpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<K> {
		// 构造方法
		KeySpliterator(HashMap<K,V> m, int origin, int fence, int est, int expectedModCount) {}
        public KeySpliterator<K,V> trySplit() {} // 
        public void forEachRemaining(Consumer<? super K> action) {}//遍历剩余元素
        /*如果有剩余元素，执行Consumer操作，并返回true，否则返回false */
        public boolean tryAdvance(Consumer<? super K> action) {} 
        public int characteristics() {} //特征值
    }
    static final class ValueSpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<V> {
    	// 
        ValueSpliterator(HashMap<K,V> m, int origin, int fence, int est,int expectedModCount) {} 
        public ValueSpliterator<K,V> trySplit() {}
        public void forEachRemaining(Consumer<? super V> action) {}
        public boolean tryAdvance(Consumer<? super V> action) {}
        public int characteristics() {}
    }
    static final class EntrySpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<Map.Entry<K,V>> {
        public EntrySpliterator<K,V> trySplit() {}
        public void forEachRemaining(Consumer<? super Map.Entry<K,V>> action) {}
        public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {}
        public int characteristics() {}
    }
    
    
    /*
    * 四种构造方法
    */
    public HashMap(int initialCapacity, float loadFactor) {}
    public HashMap(int initialCapacity) {}
    public HashMap() {}
    public HashMap(Map<? extends K, ? extends V> m) {}

	/*
	* HashMap中定义的方法
	*/
	static final int tableSizeFor(int cap) {} // 得到大于cap的最佳容量值
	final float loadFactor() {}	// 返回加载因子
	final int capacity() {}		// 返回容量值
    public void clear() {}		// 清空hashMap
    public int size() {}		// 返回hashMap存储了多少个元素
    public boolean isEmpty() {}	// 判断hashMap是否没有存储元素
    static final int hash(Object key) {}	// 得到key的hash值
    /* 添加和修改 */
    public V put(K key, V value) {}			// 存除键值对数据
    // 实际真正存数据的方法put方法就是调用它才真正的将key，value存入hashMap
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {}
    public void putAll(Map<? extends K, ? extends V> m) {}	//批量添加
    // 查询
    public V get(Object key) {}		// 根据key取出hashMap中的内容
    // 删除
    public V remove(Object key) {}	// 删除key所对于的键值对
	// hashMap的扩容方法
    final Node<K,V>[] resize() {}	
    public boolean containsKey(Object key) {}		// 判断hashMap中是否包含key
    public boolean containsValue(Object value) {}	// 判断hashMap中是否包含value
    final void treeifyBin(Node<K,V>[] tab, int hash) {}// 转换成红黑树
    //获取节点
    final Node<K,V> getNode(int hash, Object key) {}
    //删除节点
    final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {}
	// 批量添加Entry
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {}
    public Collection<V> values() {} // 获取所有value
    
    public Set<K> keySet() {}
    final class KeySet extends AbstractSet<K> {}
    final class Values extends AbstractCollection<V> {}
    public Set<Map.Entry<K,V>> entrySet() {}

	/*
	* 下面是集合类作者失误导致的结果，
	* 不用细究，
	* 原因是HashMap实现了Map接口，继承的AbstractMap也实现了同样的接口
	* 导致出现下面这么多重写方法。（后作者发现自己的错误，想修改，但被拒绝了，因为jdk组织认为不值得修改）
	*/
	@SuppressWarnings({"rawtypes","unchecked"})
    static int compareComparables(Class<?> kc, Object k, Object x) {}
    @Override
    public V getOrDefault(Object key, V defaultValue) {}
    @Override
    public V putIfAbsent(K key, V value) {}
    @Override
    public boolean remove(Object key, Object value) {}
    @Override
    public boolean replace(K key, V oldValue, V newValue) {}
    @Override
    public V replace(K key, V value) {}
    @Override
    public V computeIfAbsent(K key,Function<? super K, ? extends V> mappingFunction) {}
    public V computeIfPresent(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {}
    @Override
    public V compute(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {}
    @Override
    public V merge(K key, V value,BiFunction<? super V, ? super V, ? extends V> remappingFunction) {}
    @Override
    public void forEach(BiConsumer<? super K, ? super V> action) {}
    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {}
    @SuppressWarnings("unchecked")
    @Override
    public Object clone() {}
    private void writeObject(java.io.ObjectOutputStream s)}
    private void readObject(java.io.ObjectInputStream s)throws IOException, ClassNotFoundException {}
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {}
    Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {}
    TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {}
    TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {}
    void reinitialize() {}
    void afterNodeAccess(Node<K,V> p) { }
    void afterNodeInsertion(boolean evict) { }
    void afterNodeRemoval(Node<K,V> p) { }
    void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {}


}

再度简化HashMap

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

	/*
	* 下面是成员属性的定义
	*/
    private static final long serialVersionUID = 362498820763181265L;  // 实现序列化接口的序列化默认版本号
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始容量等于16
    static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次方也等于 Integer.MAXVALUE
    static final float DEFAULT_LOAD_FACTOR = 0.75f;// 默认的扩容因子
    static final int TREEIFY_THRESHOLD = 8; // 红黑数的阈值，hash碰撞达到了8链表才会转换成红黑数
    static final int UNTREEIFY_THRESHOLD = 6;// hash碰撞小于6才解开红黑树结构转换成链表结构
    static final int MIN_TREEIFY_CAPACITY = 64; // 树型容量的最小值，这个值不能小于 4*TREEIFY_THRESHOLD = 32
    transient Node<K,V>[] table;// 真正存储数据的数组结构
    transient Set<Map.Entry<K,V>> entrySet;// 所有节点Entry的集合
    transient int size;// hashMap的大小
    transient int modCount;// 并发修改计数，用于检测并发修改异常的值
    int threshold;// 扩容的条件，threshold=0.75*容量
    final float loadFactor;// 加载因子，默认值为0.75.可以通过构造方法重新设定
    
   /**
    *
    * 下面的是静态内部类，可以粗略的过一眼，不用细究代码。
    * 
    */
    // 这个结构很重要，是真正存储数据的数据结构
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; // 存储的 hash值
        final K key;    // 存储的 key值
        V value;        // 存储的 value值
        Node<K,V> next; // 链表结构，下一个节点的数据。结合前面定义的 transient Node<K,V>[] table;因此说HashMap的存储结构是数组+链表。
    }

	/*
	* 树节点数据结构，重要部分
	*/
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;	// 父节点
        TreeNode<K,V> left;		// 左节点
        TreeNode<K,V> right;	// 右节点
        TreeNode<K,V> prev;		// 删除后需要取消链接
        boolean red;			// 用来判断当前节点是红还是黑节点
        /*
        * 封装的左旋、右旋、保持平衡等方法
        */
	}
    

	//Entry集合的内部结构，其目的就是实现Set方法，方便获取Set中的Entry（实际存储的数据结构）
    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {}
   /*
    * 下面是类迭代器分别代表hash、key、value、Entry
    */
    abstract class HashIterator {}
    final class KeyIterator extends HashIterator implements Iterator<K> {public final K next() {  }// 返回下一个节点的 键 key}
    final class ValueIterator extends HashIterator implements Iterator<V> { public final V next() { }//返回下一个节点的 值 value}
    final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> {public final Map.Entry<K,V> next() { }//返回下一个节点}
   /*
    * 下面是Spliterator和上面迭代器一样
    * Spliterator是并行的迭代器与Iterator相比支持并行操作
    */
    static class HashMapSpliterator<K,V> {}
    static final class KeySpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<K> {}
    static final class ValueSpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<V> {}
    static final class EntrySpliterator<K,V> extends HashMapSpliterator<K,V> implements Spliterator<Map.Entry<K,V>> {}
    
    
    /**
     * 四种构造方法
     */
    public HashMap(int initialCapacity, float loadFactor) {}
    public HashMap(int initialCapacity) {}
    public HashMap() {}
    public HashMap(Map<? extends K, ? extends V> m) {}

	/*
	* HashMap中定义的方法
	*/
	static final int tableSizeFor(int cap) {} // 得到大于cap的最佳容量值
	final float loadFactor() {}	// 返回加载因子
	final int capacity() {}		// 返回容量值
    public void clear() {}		// 清空hashMap
    public int size() {}		// 返回hashMap存储了多少个元素
    public boolean isEmpty() {}	// 判断hashMap是否没有存储元素
    static final int hash(Object key) {}	// 得到key的hash值
    /* 添加和修改 */
    public V put(K key, V value) {}			// 存除键值对数据
    // 实际真正存数据的方法put方法就是调用它才真正的将key，value存入hashMap
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {}
    public void putAll(Map<? extends K, ? extends V> m) {}	//批量添加
    // 查询
    public V get(Object key) {}		// 根据key取出hashMap中的内容
    // 删除
    public V remove(Object key) {}	// 删除key所对于的键值对
	// hashMap的扩容方法
    final Node<K,V>[] resize() {}	
    public boolean containsKey(Object key) {}		// 判断hashMap中是否包含key
    public boolean containsValue(Object value) {}	// 判断hashMap中是否包含value
    final void treeifyBin(Node<K,V>[] tab, int hash) {}// 转换成红黑树
    //获取节点
    final Node<K,V> getNode(int hash, Object key) {}
    //删除节点
    final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {}
	// 批量添加Entry
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {}
    public Collection<V> values() {} // 获取所有value


}

最终的简化

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
	/*
	* 成员属性的定义
	* 初始容量16、
	* 扩容因子0.75、
	* 实际存储数据的Node数组，
	* 链表转红黑树长度阈值8、
	* 保持红黑树结构的阈值6
	*/
	
	/*
	* 静态内部类的定义，例如：红黑树节点、节点
	* 
	*/
	
	/*
	* HashMap中定义的方法
	* put、get、putVal、remove、clear等常用方法
	* 
	*/
	

}
诗水人间
关注
  • 14
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
HashMap常见面试题，简述以及对源码操作分析
01-28
HashMap常见面试题，简述以及对源码操作分析 HashMap是我们非常常用的数据结构，由数组和链表组合构成的数据结构。数组里面每个地方都存了Key-Value这样的实例，在Java7之前是Entry，在Java8中叫Node因为它本身所有...
HashMap和HashTable底层原理以及常见面试题
08-26
HashMap和HashTable底层原理以及常见面试题 HashMap和HashTable是Java中两个常用的数据结构，都是基于哈希表实现的，但它们之间存在着一些关键的区别。本文将深入探讨HashMap和HashTable的底层原理，并总结常见的...
史上最全HashMap面试题汇总
一蓑烟雨任平生
07-13 2万+
1.HashMap的数据结构? 哈希表结构(链表散列:数组+链表)实现,结合数组和链表的优点。当链表长度超过8时,链表转换为红黑树。 2.HashMap的工作原理? HashMap底层是hash数组和单向链表实现,数组中的每个元素都是链表,由Node内部类(实现Map.Entry<K,V>接口)实现,HashMap通过put&get方法存储和获取。 存储对象时,将K/V键值传给put()方法: ①、调用hash(K)方法计算K的hash值,然后结合数组长度,计算得数组下标;
Java基础知识面试题（2020最新版）
热门推荐
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
并发编程面试题（2020最新版）
ThinkWon的博客
03-14 36万+
文章目录基础知识并发编程的优缺点为什么要使用并发编程（并发编程的优点）并发编程有什么缺点并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行安全？并行和并发有什么区别？什么是多线程，多线程的优劣？线程和进程区别什么是线程和进程?进程与线程的区别什么是上下文切换?守护线程和用户线程有什么区别呢？如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？什么是线程死锁形成死锁的...
史上最全Hashmap面试总结，51道附带答案，持续更新中...
这个时代，作为程序员可能要学习小程序
04-29 2万+
点击上方关注 “终端研发部”设为“星标”，和你一起掌握更多数据库知识我历经两个工作日晚上总结了50道关于hashmap的面试题，我相信，下面将会是Hashmap最全的面试总结！HashMap的底层数据结构？  HashMap底层实现数据结构为数组+链表的形式，JDK8及其以后的版本中使用了数组+链表+红黑树实现，解决了链表太长导致的查询速度变慢的问题。   简单来说，Ha...
Java基础常见面试题——HashMap最新总结（JDK1.8）
追求幸福，探索未知的博客
02-21 1997
HashMap源码
HashMap面试题
liuerchong的博客
07-04 4338
文章目录综述HashMap什么是拉链法为什么不一开始选择红黑树呢？ 综述 HashMap在实际开发过程中是使用频率最高的用于映射(键值对)处理的数据类型。在JDK1.8中对HashMap底层的底层实现进行了大幅度地优化，比如引入红黑树的数据结构和扩容的优化等等。 HashMap 什么是拉链法 在JDK 1.8 的 HashMap 和 ConcurrentHashMap 都有这样一个同样的特点，那就是最开始的Map是空的，因为里面没有任何元素，往里放元素时会计算 hash值，计算之后，第 1 个 value
Java面试题大全（2021版）
Java笔记
11-25 29万+
发现网上很多Java面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~ 本套Java面试题大全，全的不能再全，哈哈~ 一、Java基础知识面试题 1、Java概述 ①. 何为编程 编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。 为了使计算机能够理解人的意图，人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算机
Hashmap 原理、源码、面试题（史上最全）
架构师尼恩
05-18 1377
文章很长，建议收藏起来慢慢读！疯狂创客圈总目录 语雀版 | 总目录 码云版| 总目录 博客园版 为您奉上珍贵的学习资源 ： 免费赠送 :《尼恩Java面试宝典》持续更新+ 史上最全 + 面试必备 2000页+ 面试必备 + 大厂必备 +涨薪必备 免费赠送 经典图书:《Java高并发核心编程（卷1）》 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领 免费赠送 经典图书:《Java高并发核心编程（卷2）》 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领 免费赠送 经典图书:《Nett
Java最常见面试题
旷野历程
07-07 323
本文分为十九个模块，分别是：Java 基础、容器、多线程、反射、对象拷贝、Java Web 、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM，如下图所示： 共包含 208 道面试题，本文的宗旨是为读者朋友们...
JAVA--HashMap热门面试题
08-19
在这里，我们将讨论一些热门的 HashMap 面试题，以帮助您更好地理解 HashMap 的工作原理和应用。 为什么我们建议在定义 HashMap 的时候指定它的初始化大小？ 在定义 HashMap 时，如果没有指定其初始化大小，那么...
05.HashMap相关面试题
最新发布
02-16
以下是 HashMap 相关的面试题和知识点： 1. HashMap 和 HashTable 的区别 HashMap 和 HashTable都是基于散列表的集合框架，但它们有着不同的设计目标和实现方式。 * HashMap 是非线程安全的，意味着它不能在多...
面试题之详解HashMap
12-21
本文将详细解析HashMap的一些常见面试题，包括HashMap的长度为什么是2的幂次方、多线程操作下的死循环问题、底层实现以及扩容机制。 1. HashMap长度为什么是2的幂次方？ 这个设计主要是为了优化哈希函数的效率。在...
面试时别再回答ArrayList的初始容量为10了！！！这里有更好的答案！
诗水人间
08-04 13万+
使用过ArrayList或者背过面试题的小伙伴都知道ArrayList的初始容量为10。 但这个答案不完全正确，在jdk1.2到jdk1.6中的ArrayList的源码中，在构造方法上的确是创建了一个初始容量为10的容器。 摘录jdk_1.6的源码，1.2到1.6都是直接创建一个长度为10的数组 但是在jdk_1.7中的源码是这样写的 调用构造方法时，如下 说明从jdk_1.7开始，当你进行new ArrayList();创建的是一个空数组初始容量就不是10了，而是一个空数组 从jdk_1.2开始到
ArrayList哪几种情况下会报java.util.ConcurrentModificationException吗？
诗水人间
08-03 11万+
ArrayList是一个很常用的集合类，底层是一个数组，只不过ArrayList封装了数组，实现了一些好用的方法例如add()方法，size()方法，get()方法等一系列的方法，并且实现了动态的扩容数组。 new ArrayList();创建了一个空数组，那么它的容量起始为0，为什么面试过程中很多人都说ArrayList的初始容量为10呢？原因在于当你第一次调用add()方法添加元素的时候会进行一次扩容。这时候就会扩容到默认的初始容量10 在ArrayList中定义了一个常量DEFAULT_CAPACIT
ArrayList扩容机制的发展过程
诗水人间
08-04 11万+
jdk1.2中 扩容算法是这样的。1.5倍+1 public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if
一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之ArrayList
诗水人间
07-29 11万+
一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之ArrayList 一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之LinkedList 一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之HashMap 一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之HashSet 一、ArrayList 源码
2022年Java常见面试题与三大框架面试：作用域和集合类区别
2022年Java常见面试题及三大框架面试 在Java的面试过程中，常常会遇到一些基础知识的问题，这些问题对于应聘者来说非常重要。本文将总结一些2022年Java常见面试题及三大框架面试中的重要内容，并根据题目内容进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

诗水人间

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值