【Java集合-2】HashMap简析

于 2024-09-12 17:57:54 发布
阅读量294 收藏
点赞数 3
文章标签： java windows 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86367115/article/details/142182569
版权 
	// 第二种遍历方式

	for (Entry<String, String> entry : map.entrySet()) {

		System.out.print(entry.getKey() + ":" + entry.getValue() + ",");

	}

	

	// 遍历HashMap的键

	Iterator<String> ite = map.keySet().iterator();

	while (ite.hasNext()) {

		String key = ite.next();

		String value = map.get(key);

		System.out.print(key + ":" + value + ",");

	}



	// 遍历HashMap的值

	Collection<String> values = map.values();

	Iterator<String> ite = values.iterator();

	while (ite.hasNext()) {

		System.out.print(ite.next() + ",");

	}

}

}




[]( )4.2 排序

----------------------------------------------------------------

public class MyTest{

public static void main(String[] args){

	Map<String,String>() map = new HashMap<>();

	map.put("a", "cc");

	map.put("c", "cc");

	map.put("b", "bb");

	

	sort(map);  // 输出结果：a:cc,b:bb,c:cc

	sort2(map);  // 输出结果：c:cc,b:bb,a:cc

}



// 自然排序

public void sort(HashMap<String,String>() map){

	List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());

	Collections.sort(list, new Comparator<Map.Entry<String, String>>() {

		@Override

		public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {

			return mapping1.getKey().compareTo(mapping2.getKey());

		}

	});



	for (Entry<String, String> entry : list) {

		System.out.print(entry.getKey() + ":" + entry.getValue() + ",");

	}

}



// 自定义排序

public void sort2(HashMap<String,String>() map){

	List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());

	Collections.sort(list, new Comparator<Map.Entry<String, String>>() {

		@Override

		public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {

			int i = mapping1.getValue().compareTo(mapping2.getValue());

			if (i > 0) {

				return -1;

			}

			return 1;

		}

	});



	for (Entry<String, String> entry : list) {

		System.out.print(entry.getKey() + ":" + entry.getValue() + ",");

	}

}

}




[]( )5 附：源码

================================================================

package java.util;

import java.io.*;

public class HashMap<K,V>

extends AbstractMap<K,V>

implements Map<K,V>, Cloneable, Serializable

{

// 默认的初始容量是16，必须是2的幂。

static final int DEFAULT_INITIAL_CAPACITY = 16;



// 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）

static final int MAXIMUM_CAPACITY = 1 << 30;



// 默认加载因子

static final float DEFAULT_LOAD_FACTOR = 0.75f;



// 存储数据的Entry数组，长度是2的幂。

// HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表

transient Entry[] table;



// HashMap的大小，它是HashMap保存的键值对的数量

transient int size;



// HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）

int threshold;



// 加载因子实际大小

final float loadFactor;



// HashMap被改变的次数

transient volatile int modCount;



// 指定“容量大小”和“加载因子”的构造函数

public HashMap(int initialCapacity, float loadFactor) {

    if (initialCapacity < 0)

        throw new IllegalArgumentException("Illegal initial capacity: " +

                                           initialCapacity);

    // HashMap的最大容量只能是MAXIMUM_CAPACITY

    if (initialCapacity > MAXIMUM_CAPACITY)

        initialCapacity = MAXIMUM_CAPACITY;

    if (loadFactor <= 0 || Float.isNaN(loadFactor))

        throw new IllegalArgumentException("Illegal load factor: " +

                                           loadFactor);



    // 找出“大于initialCapacity”的最小的2的幂

    int capacity = 1;

    while (capacity < initialCapacity)

        capacity <<= 1;



    // 设置“加载因子”

    this.loadFactor = loadFactor;

    // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。

    threshold = (int)(capacity * loadFactor);

    // 创建Entry数组，用来保存数据

    table = new Entry[capacity];

    init();

}



// 指定“容量大小”的构造函数

public HashMap(int initialCapacity) {

    this(initialCapacity, DEFAULT_LOAD_FACTOR);

}



// 默认构造函数。

public HashMap() {

    // 设置“加载因子”

    this.loadFactor = DEFAULT_LOAD_FACTOR;

    // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。

    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

    // 创建Entry数组，用来保存数据

    table = new Entry[DEFAULT_INITIAL_CAPACITY];

    init();

}



// 包含“子Map”的构造函数

public HashMap(Map<? extends K, ? extends V> m) {

    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,

                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

    // 将m中的全部元素逐个添加到HashMap中

    putAllForCreate(m);

}



static int hash(int h) {

    h ^= (h >>> 20) ^ (h >>> 12);

    return h ^ (h >>> 7) ^ (h >>> 4);

}



// 返回索引值

// h & (length-1)保证返回值的小于length

static int indexFor(int h, int length) {

    return h & (length-1);

}



public int size() {

    return size;

}



public boolean isEmpty() {

    return size == 0;

}



// 获取key对应的value

public V get(Object key) {

    if (key == null)

        return getForNullKey();

    // 获取key的hash值

    int hash = hash(key.hashCode());

    // 在“该hash值对应的链表”上查找“键值等于key”的元素

    for (Entry<K,V> e = table[indexFor(hash, table.length)];

         e != null;

         e = e.next) {

        Object k;

        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

            return e.value;

    }

    return null;

}



// 获取“key为null”的元素的值

// HashMap将“key为null”的元素存储在table[0]位置！

private V getForNullKey() {

    for (Entry<K,V> e = table[0]; e != null; e = e.next) {

        if (e.key == null)

            return e.value;

    }

    return null;

}



// HashMap是否包含key

public boolean containsKey(Object key) {

    return getEntry(key) != null;

}



// 返回“键为key”的键值对

final Entry<K,V> getEntry(Object key) {

    // 获取哈希值

    // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值

    int hash = (key == null) ? 0 : hash(key.hashCode());

    // 在“该hash值对应的链表”上查找“键值等于key”的元素

    for (Entry<K,V> e = table[indexFor(hash, table.length)];

         e != null;

         e = e.next) {

        Object k;

        if (e.hash == hash &&

            ((k = e.key) == key || (key != null && key.equals(k))))

            return e;

    }

    return null;

}



// 将“key-value”添加到HashMap中

public V put(K key, V value) {

    // 若“key为null”，则将该键值对添加到table[0]中。

    if (key == null)

        return putForNullKey(value);

    // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。

    int hash = hash(key.hashCode());

    int i = indexFor(hash, table.length);

    for (Entry<K,V> e = table[i]; e != null; e = e.next) {

        Object k;

        // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！

        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

            V oldValue = e.value;

            e.value = value;

            e.recordAccess(this);

            return oldValue;

        }

    }



    // 若“该key”对应的键值对不存在，则将“key-value”添加到table中

    modCount++;

    addEntry(hash, key, value, i);

    return null;

}



// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置

private V putForNullKey(V value) {

    for (Entry<K,V> e = table[0]; e != null; e = e.next) {

        if (e.key == null) {

            V oldValue = e.value;

            e.value = value;

            e.recordAccess(this);

            return oldValue;

        }

    }

    // 这里的完全不会被执行到!

    modCount++;

    addEntry(0, null, value, 0);

    return null;

}



// 创建HashMap对应的“添加方法”，

// 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap

// 而put()是对外提供的往HashMap中添加元素的方法。

private void putForCreate(K key, V value) {

    int hash = (key == null) ? 0 : hash(key.hashCode());

    int i = indexFor(hash, table.length);



    // 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值

    for (Entry<K,V> e = table[i]; e != null; e = e.next) {

        Object k;

        if (e.hash == hash &&

            ((k = e.key) == key || (key != null && key.equals(k)))) {

            e.value = value;

            return;

        }

    }



    // 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中

    createEntry(hash, key, value, i);

}



// 将“m”中的全部元素都添加到HashMap中。

// 该方法被内部的构造HashMap的方法所调用。

private void putAllForCreate(Map<? extends K, ? extends V> m) {

    // 利用迭代器将元素逐个添加到HashMap中

    for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {

        Map.Entry<? extends K, ? extends V> e = i.next();

        putForCreate(e.getKey(), e.getValue());

    }

}



// 重新调整HashMap的大小，newCapacity是调整后的单位

void resize(int newCapacity) {

    Entry[] oldTable = table;

    int oldCapacity = oldTable.length;

    if (oldCapacity == MAXIMUM_CAPACITY) {

        threshold = Integer.MAX_VALUE;

        return;

    }



    // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，

    // 然后，将“新HashMap”赋值给“旧HashMap”。

    Entry[] newTable = new Entry[newCapacity];

    transfer(newTable);

    table = newTable;

    threshold = (int)(newCapacity * loadFactor);

}



// 将HashMap中的全部元素都添加到newTable中

void transfer(Entry[] newTable) {

    Entry[] src = table;

    int newCapacity = newTable.length;

    for (int j = 0; j < src.length; j++) {

        Entry<K,V> e = src[j];

        if (e != null) {

            src[j] = null;

            do {

                Entry<K,V> next = e.next;

                int i = indexFor(e.hash, newCapacity);

                e.next = newTable[i];

                newTable[i] = e;

                e = next;

            } while (e != null);

        }

    }

}



// 将"m"的全部元素都添加到HashMap中

public void putAll(Map<? extends K, ? extends V> m) {

    // 有效性判断

    int numKeysToBeAdded = m.size();

    if (numKeysToBeAdded == 0)

        return;



    // 计算容量是否足够，

    // 若“当前实际容量 < 需要的容量”，则将容量x2。

    if (numKeysToBeAdded > threshold) {

        int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);

        if (targetCapacity > MAXIMUM_CAPACITY)

            targetCapacity = MAXIMUM_CAPACITY;

        int newCapacity = table.length;

        while (newCapacity < targetCapacity)

            newCapacity <<= 1;

        if (newCapacity > table.length)

            resize(newCapacity);

    }



    // 通过迭代器，将“m”中的元素逐个添加到HashMap中。

    for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {

        Map.Entry<? extends K, ? extends V> e = i.next();

        put(e.getKey(), e.getValue());

    }

}



// 删除“键为key”元素

public V remove(Object key) {

    Entry<K,V> e = removeEntryForKey(key);

    return (e == null ? null : e.value);

}



// 删除“键为key”的元素

final Entry<K,V> removeEntryForKey(Object key) {

    // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算

    int hash = (key == null) ? 0 : hash(key.hashCode());

    int i = indexFor(hash, table.length);

    Entry<K,V> prev = table[i];

    Entry<K,V> e = prev;



    // 删除链表中“键为key”的元素

    // 本质是“删除单向链表中的节点”

    while (e != null) {

        Entry<K,V> next = e.next;

        Object k;

        if (e.hash == hash &&

            ((k = e.key) == key || (key != null && key.equals(k)))) {

            modCount++;

            size--;

            if (prev == e)

                table[i] = next;

            else

                prev.next = next;

            e.recordRemoval(this);

            return e;

        }

        prev = e;

        e = next;

    }



    return e;

}



// 删除“键值对”

final Entry<K,V> removeMapping(Object o) {

    if (!(o instanceof Map.Entry))

        return null;



    Map.Entry<K,V> entry = (Map.Entry<K,V>) o;

    Object key = entry.getKey();

    int hash = (key == null) ? 0 : hash(key.hashCode());

    int i = indexFor(hash, table.length);

    Entry<K,V> prev = table[i];

    Entry<K,V> e = prev;



    // 删除链表中的“键值对e”

    // 本质是“删除单向链表中的节点”

    while (e != null) {

        Entry<K,V> next = e.next;

        if (e.hash == hash && e.equals(entry)) {

            modCount++;

            size--;

            if (prev == e)

                table[i] = next;

            else

                prev.next = next;

            e.recordRemoval(this);

            return e;

        }

        prev = e;

        e = next;

    }



    return e;

}



// 清空HashMap，将所有的元素设为null

public void clear() {

    modCount++;

    Entry[] tab = table;

    for (int i = 0; i < tab.length; i++)

        tab[i] = null;

    size = 0;

}



// 是否包含“值为value”的元素

public boolean containsValue(Object value) {

// 若“value为null”，则调用containsNullValue()查找

if (value == null)

        return containsNullValue();



// 若“value不为null”，则查找HashMap中是否有值为value的节点。

Entry[] tab = table;

    for (int i = 0; i < tab.length ; i++)

        for (Entry e = tab[i] ; e != null ; e = e.next)

            if (value.equals(e.value))

                return true;

return false;

}



// 是否包含null值

private boolean containsNullValue() {

Entry[] tab = table;

    for (int i = 0; i < tab.length ; i++)

        for (Entry e = tab[i] ; e != null ; e = e.next)

            if (e.value == null)

                return true;

return false;

}



// 克隆一个HashMap，并返回Object对象

public Object clone() {

    HashMap<K,V> result = null;

    try {

        result = (HashMap<K,V>)super.clone();

    } catch (CloneNotSupportedException e) {

        // assert false;

    }

    result.table = new Entry[table.length];

    result.entrySet = null;

    result.modCount = 0;

    result.size = 0;

    result.init();

    // 调用putAllForCreate()将全部元素添加到HashMap中

    result.putAllForCreate(this);



    return result;

}



// Entry是单向链表。

// 它是 “HashMap链式存储法”对应的链表。

// 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数

static class Entry<K,V> implements Map.Entry<K,V> {

    final K key;

    V value;

    // 指向下一个节点

    Entry<K,V> next;

    final int hash;



    // 构造函数。

    // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"

    Entry(int h, K k, V v, Entry<K,V> n) {

        value = v;

        next = n;

        key = k;

        hash = h;

    }



    public final K getKey() {

        return key;

    }



    public final V getValue() {

        return value;

    }



    public final V setValue(V newValue) {

        V oldValue = value;

        value = newValue;

        return oldValue;

    }



    // 判断两个Entry是否相等

    // 若两个Entry的“key”和“value”都相等，则返回true。

    // 否则，返回false

    public final boolean equals(Object o) {

        if (!(o instanceof Map.Entry))

            return false;

        Map.Entry e = (Map.Entry)o;

        Object k1 = getKey();

        Object k2 = e.getKey();

        if (k1 == k2 || (k1 != null && k1.equals(k2))) {

            Object v1 = getValue();

            Object v2 = e.getValue();

            if (v1 == v2 || (v1 != null && v1.equals(v2)))

                return true;

        }

        return false;

    }



    // 实现hashCode()

    public final int hashCode() {

        return (key==null   ? 0 : key.hashCode()) ^

               (value==null ? 0 : value.hashCode());

    }



    public final String toString() {

        return getKey() + "=" + getValue();

    }



    // 当向HashMap中添加元素时，绘调用recordAccess()。

    // 这里不做任何处理

    void recordAccess(HashMap<K,V> m) {

    }



    // 当从HashMap中删除元素时，绘调用recordRemoval()。

    // 这里不做任何处理

    void recordRemoval(HashMap<K,V> m) {

    }

}



// 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。

void addEntry(int hash, K key, V value, int bucketIndex) {

    // 保存“bucketIndex”位置的值到“e”中

    Entry<K,V> e = table[bucketIndex];

    // 设置“bucketIndex”位置的元素为“新Entry”，

    // 设置“e”为“新Entry的下一个节点”

    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);

    // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小

    if (size++ >= threshold)

        resize(2 * table.length);

}



// 创建Entry。将“key-value”插入指定位置，bucketIndex是位置索引。

// 它和addEntry的区别是：

// 1.addEntry()一般用在 新增Entry可能导致“HashMap的实际容量”超过“阈值”的情况下。

//   例如，我们新建一个HashMap，然后不断通过put()向HashMap中添加元素；

// put()是通过addEntry()新增Entry的。

//   在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；

//   因此，需要调用addEntry()

// 2.createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。

//   例如，我们调用HashMap“带有Map”的构造函数，它绘将Map的全部元素添加到HashMap中；

// 但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中

// 的全部元素添加到HashMap中，都不会超过HashMap的阈值”。

//   此时，调用createEntry()即可。

void createEntry(int hash, K key, V value, int bucketIndex) {

    // 保存“bucketIndex”位置的值到“e”中

    Entry<K,V> e = table[bucketIndex];

    // 设置“bucketIndex”位置的元素为“新Entry”，

    // 设置“e”为“新Entry的下一个节点”

    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);

    size++;

}



// HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。

// 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。

private abstract class HashIterator<E> implements Iterator<E> {

    // 下一个元素

    Entry<K,V> next;

    // expectedModCount用于实现fast-fail机制。

    int expectedModCount;

    // 当前索引

    int index;

    // 当前元素

    Entry<K,V> current;



    HashIterator() {

        expectedModCount = modCount;

        if (size > 0) { // advance to first entry

            Entry[] t = table;

            // 将next指向table中第一个不为null的元素。

            // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。

            while (index < t.length && (next = t[index++]) == null)

                ;

        }

    }



    public final boolean hasNext() {

        return next != null;

    }



    // 获取下一个元素

    final Entry<K,V> nextEntry() {

        if (modCount != expectedModCount)

            throw new ConcurrentModificationException();

        Entry<K,V> e = next;

        if (e == null)

            throw new NoSuchElementException();



        // 注意！！！

        // 一个Entry就是一个单向链表

        // 若该Entry的下一个节点不为空，就将next指向下一个节点;

        // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。

        if ((next = e.next) == null) {

            Entry[] t = table;

            while (index < t.length && (next = t[index++]) == null)

                ;

        }

        current = e;

        return e;

    }



    // 删除当前元素

    public void remove() {

        if (current == null)

            throw new IllegalStateException();

        if (modCount != expectedModCount)

            throw new ConcurrentModificationException();

        Object k = current.key;

        current = null;

        HashMap.this.removeEntryForKey(k);
2401_86367115
关注
《Java源码分析》：HashMap
wojiushimogui的博客
07-21 6398
《Java源码分析》：HashMap看过很多次HashMap的源码了，但是，每次都没有做记录，因此，每次记忆都不太深，今天在看别人博客时提到Hashtable是线程安全的，Hashtable中的方法都用了synchronized进行了同步，于是就看了下Hashtable的源码，在看的过程中，写了篇博客，现在2016年7月20日22:03:53，还在教研室，感觉回寝室还早，因此，决定再看下HashMa
Java中HashMap的源码简析
qq_44830792的博客
10-31 121
简介 Hashmap是Java中常用的一种集合，文章简单对其源码做了一些简单刨析基于JDK8； HashMap中的初始化参数： public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { //指定序列号，用于序列化 private static final long serialVersionUID = 36249882
HashMap详细介绍(源码解析)和使用示例
dlgdlg_2008的专栏
08-14 518
HashMap详细介绍(源码解析)和使用示例 package java.util; import java.io.*; public class HashMap     extends AbstractMap     implements Map, Cloneable, Serializable {     // 默认的初始容量是16，必须是2的幂。     sta
HashMap 详解
jacket350401的博客
08-09 3762
HashMap 详解
hashmap 详解
huapro.vip的程序人生
02-11 690
hash map
没有比这个更简洁的HashMap 源码分析解读
求关注
03-31 535
HashMap 作为最常用的集合类之一，有必要深入浅出的了解一下。这篇文章会深入到 HashMap 源码，刨析它的存储结构以及工作机制。 1. HashMap 的存储结构 HashMap 的数据存储结构是一个 Node<K,V> 数组，在（Java 7 中是 Entry<K,V> 数组，但结构相同） 存储结构主要是数组加链表，像下面的图。 Has...
java map 实现 序列化_Java集合(九)--基于Map实现的Set简析
weixin_28867333的博客
02-26 1343
HashSet此类由一个哈希表(实际上是一个HashMap实例)支持。 不保证元素的顺序，特别是，它不保证顺序随着时间的推移保持不变。该集合没有重复的元素并且允许使用null元素。另外，跟之前分析的其他集合类一样，它是非同步的。定义及说明定义如下：public class HashSet extends AbstractSetimplements Set, Cloneable, java.io.S...
详解HashMap简析Map其他常用实现子类
weixin_53566169的博客
01-25 585
jdk1.8 文章目录Map接口特点及常用方法结构体系特点Map接口常用方法常见实现子类HashMap底层实现源码解读tableSizeFor()put()方法详解hash()计算原理resize() 扩容机制get()方法Entry、Values、KeySet关系总结Map遍历方式LinkedHashMap基本介绍TreeMap基本介绍Demo源码解析Hashtable基本介绍基层简单了解扩容方式Properties基本介绍基本使用扩容方式总结 Map接口特点及常用方法 结构体系 常用实现类 特点
JDK框架简析--java.util包中的工具类库
Java之旅
10-14 5533
在本节中，简析java.util包所包含的工具类库，主要是集合相关的类库，其次还有正则、压缩解压、并发、日期时间等工具类。
Java中高级核心知识
weixin_70730532的博客
06-02 1481
前言：java是一门面向对象的编程语言，功能强大、简单易用，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。在Java简单入门之后很多人不知道下一阶段该做什么，对自己的学习进程没有一个系统性的规划，或者是知道该学什么，却又找不到对应的内容。在这里我对上述问题做了一个整合，希望对大家有所帮助。目录：一、Java(一).基础1. Java基本功1.1.Java入门（基础概念与常识）1.1.1. Java语言有哪些特点?1.1.2.关于JVMJDK和JRE最详细通俗的解答1.1.2.1.J
Hashmap详解
12-02
Hashmap详解
hashMap具体详解
04-27
哈希MAP的 讲解，讲解的通俗易懂 挺好的
hashmap详解
weixin_34138521的博客
09-04 53
Java中常用的数据结构封装在java.util包下的一些类中，util包中有这样两个接口：这里面都是日常开发所常用的容器，下面以Java7中HashMap源码为参考，分析HashMap的实现过程。一、HashMap介绍Hashmap是基于哈希表的Map接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据has...
HashMap详细介绍
你还有好多未完成的梦，你有什么理由停下？
04-29 781
0、基于jdk1.8源码所分析 1、一些常量 /** * The default initial capacity - MUST be a power of two. 默认的初始容量是2的幂。 默认为2的4次方 16 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // ak...
hashMap详解
随风的博客
05-21 694
HashMap概述HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 　　值得注意的是HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的
hashmap 详解（转载）
QQ：690217293
07-21 88
https://blog.csdn.net/u011240877/article/details/53351188
这可能是迄今为止HashMap详解写的最全的一篇文章
求关注
01-18 1132
什么是 HashMap? HashMap 是基于哈希表的 Map 接口的非同步实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 HashMap 的数据结构 在 Java 编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap 也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值