HashMap学习

erfenjiao

已于 2024-03-22 10:12:55 修改

阅读量1.1k

点赞数 27

分类专栏： java 文章标签：学习 java 开发语言

于 2024-02-25 22:48:29 首次发布

本文链接：https://blog.csdn.net/Daisy_G_Jasmine/article/details/136283704

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

hashmap

1、hashmap 与 hashtable 的区别
2、hashmap
参考文章

1、hashmap 与 hashtable 的区别

线程安全
null值
执行效率

2、hashmap

hashmap是java中常用的集合类之一，

继承自AbstractMap类，实现了 Map、Cloneable、java.io.Serializable 接口。
使用哈希表来存储键值对（key-value），通过将键值映射成哈希码来进行高效的插入、删除操作。
具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

java.lang.Object
	java.util.AbstractMap<K,V>
		java.util.HashMap<K,V>
Type Parameters:
	K - the type of keys maintained by this map
	V - the type of mapped values
All Implemented Interfaces:
	Serializable, Cloneable, Map<K,V>
Direct Known Subclasses:
	LinkedHashMap, PrinterStateReasons

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

基本类型与包装类

HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

基本类型对应的包装类表如下：

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

常用实现

1、创建

import java.util.HashMap; // 引入 HashMap 类
HashMap<Integer, String> A = new HashMap<Integer, String>();

2、添加元素 put() 方法：
当调用put方法的时候，先通过hashCode() 获取key 的hashCode,然后找到bucket位置，将Entry对象存储到bucket上面。

public class Test {
	public static void main(Strings[] args) {
		// 创建 HashMap 对象 A
		HashMap<Integer, String> A = new HashMap<Integer, String>();
		// 添加键值对
		A.put(1, "apple");
		A.put(2, "banana");
		System.out.println(A);
	}
}

3、访问元素 get(key) 方法：
通过get(key)获取对象时，也是通过hashCode()方法获取key的hashCode,然后得到Entry对象。

public class Test{
	public static void main(String[] args) {
		// 创建 HashMap 对象 A
		HashMap<Integer, String> A = new HashMap<Integer, String>();
		// 添加键值对
		A.put(1, "apple");
		A.put(2, "banana");
		// 访问
		System.out.println(A.get(1));
	}
}

4、删除元素 remove(key)方法：
5、删除所有元素：clear()方法

public class Test{
	public static void main(String[] args) {
		// 创建 HashMap 对象 A
		HashMap<Integer, String> A = new HashMap<Integer, String>();
		// 添加键值对
		A.put(1, "apple");
		A.put(2, "banana");
		// 删除
		A.remove(1);
		// 删除所有元素
		A.clear();
	}
}

6、计算 HashMap 中元素的数量：size() 方法

7、遍历

可以使用 for-each 来迭代 HashMap 中的元素
只想获得 key ，使用 KeySet() 方法，然后通过 get(key) 获取对应的 value
指向获得value，有getValue() 方法.

// 方法一:
      Iterator iterator = hashMap.keySet().iterator();
       while (iterator.hasNext()){
           String key = (String)iterator.next();
           System.out.println(key+"="+hashMap.get(key));
       }
// 方法二:
	Iterator iterator1 = hashMap.entrySet().iterator();
    while (iterator1.hasNext()){
        Map.Entry entry = (Map.Entry) iterator1.next();
        String key = (String) entry.getKey();
        Integer value = (Integer) entry.getValue();
        System.out.println(key+"="+value);
    }

变量介绍

该类提供了四种构造方法：
（1）HashMap()
Constructs an empty HashMap with the default initial capacity (16) and the default load factor (0.75).

public HashMap(){
	this.loadFactor = DEFAULT_LOAD_FACTOR; //all other fields defaulted
}

这是我们用的比较频繁的一个构造方法了，没有特殊的写法，所有变量均是默认值

(2) HashMap(int initialCapacity)
Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75).

public HashMap(int initialCapacity) {
	this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

该构造方法传入一个指定容量，然后调用另外一个重载的构造方法

(3) HashMap(int initialCapacity, float loadFactor)
Constructs an empty HashMap with the specified initial capacity and load factor.

public HashMap(int initialCapacity, float loadFactor) {
	if(initialCapacity < 0)
		throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity");
    if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
    if(loadFactor <= 0 || Float.isNaN(loadFactor))
    	throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

该构造方法指定一个容量值和一个负载因子；从方法内部逻辑可以看出容量值小于0将会抛出异常，大于最大容量值就重置为最大值；负载因子如果小于等于0或者是个非法数字也将会抛出异常；最后一句代码的意思是计算HashMap下次扩容时的阈值，也就是说HashMap并不会等被填满时才会进行扩容，而是达到这个阈值时就开始提前扩容

（4) HashMap(Map<? extends K,? extends V> m)
Constructs a new HashMap with the same mappings as the specified Map.

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        // 将m中的所有键值对添加到HashMap
        putMapEntries(m, false);
    }

    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
            	//数组没有初始化 重新计算阈值
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
               //已经初始化 如果大小大于阈值 需要扩容
                resize();
            //将m中所有键值对添加到本HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }