java_hashmap（1）-CSDN博客

本文链接：https://blog.csdn.net/xjdkxnhcoskxbco/article/details/142910433

介绍（重点）

HashMap 是一个散列表，它存储的内容是键值对（key-value）映射。

HashMap实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null, 不支持线程同步。

扩展：线程同步的map类型

在 Java 中，为了保证多线程环境下对 Map 的操作是线程安全的，提供了几种不同的解决方案。这些解决方案包括使用内置线程安全的 Map 实现，或者通过外部手段来确保线程安全。

内置线程安全的 Map 实现

ConcurrentHashMap：ConcurrentHashMap 是 Java 5 引入的一种高效的线程安全 Map 实现。它使用了分段锁技术来提高并发性能。相比于 HashMap，ConcurrentHashMap 在多线程环境下表现更好，因为它的读操作是不需要加锁的，只有写操作才会加锁。从 Java 8 开始，ConcurrentHashMap 改进了设计，使用了 CAS 加 volatile 的技术来进一步提升性能。

外部线程安全的解决方案

Collections.synchronizedMap()：如果你有一个普通的 Map 实现（如 HashMap），并且希望让它变得线程安全，可以使用 Collections.synchronizedMap(Map map) 方法。这个方法返回一个线程安全的 Map，但需要注意的是，每次操作都需要同步整个 Map，这可能会降低性能。
```
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());
```
Hashtable：Hashtable 是 Java 最早提供的线程安全的 Map 实现。它与 HashMap 很相似，但所有的公共方法都是同步的。然而，由于 Hashtable 的历史原因，它的性能不如 ConcurrentHashMap，并且它不允许 null 键和 null 值。

特点比较

ConcurrentHashMap：适合于高并发环境下的使用，提供了较好的并发性能。它可以容忍 null 值，但不允许 null 键。
Hashtable：虽然线程安全，但由于它的所有方法都同步，所以在高并发情况下性能较差。
Collections.synchronizedMap()：可以将任何 Map 实例转换为线程安全的版本，但在多线程环境下可能会因为整体同步而降低性能

HashMap是无序的,即不会记录插入的顺序。 HashMap 继承于AbstractMap（抽象类）,实现了Map、Cloneable、java. io. Serializable 接口。

扩展

HashMap 是 Java 集合框架的一部分，它是一个实现了 Map 接口的数据结构。HashMap 允许我们以键值对的形式存储数据，并且它允许一个 null 键和多个 null 值。

实现的接口

HashMap 实现了以下接口：

Map<K, V>：这是 HashMap 的主要接口，定义了所有基本的操作，如 put、get、remove 等。
Cloneable：此接口允许 HashMap 实例支持克隆操作。
Serializable：此接口意味着 HashMap 可以被序列化，从而可以保存到磁盘或在网络上传输。

继承自的父类

HashMap 没有直接继承自任何父类，因为它本身就是顶级类。不过，它内部使用了一些抽象类来帮助实现其功能，如 AbstractMap，但这并不是继承关系，而是内部实现细节。

用途

HashMap 的主要用途如下：

快速查找：HashMap 使用哈希表实现，因此它提供了平均时间复杂度为 O(1) 的查找性能，这对于频繁的查找操作非常有效。
键值对存储：HashMap 是一种关联数组或字典类型的数据结构，适合存储具有唯一键的对象。
灵活性：HashMap 允许存储 null 键和 null 值，这增加了它的灵活性。
并发访问：需要注意的是，HashMap 不是线程安全的。如果多个线程同时写入 HashMap，则需要外部同步机制，否则可能导致数据不一致或其他并发问题。

示例

下面是一个简单的 HashMap 使用示例：

java

深色版本

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        // 创建 HashMap 实例
        HashMap<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // 获取值
        Integer value = map.get("Two");
        System.out.println(value); // 输出 2

        // 删除键值对
        map.remove("One");

        // 遍历 HashMap
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

HashMap 是 Java 中最常用的 Map 实现之一，它适用于大多数需要键值对存储的应用场景。然而，对于需要线程安全或有序存储的情况，可能需要考虑使用其他类型的 Map，如 ConcurrentHashMap 或 LinkedHashMap。

散列表

散列表（Hash Table），也称为哈希表或哈希表（Hash Map），是一种常用的数据结构，用于快速查找、插入和删除元素。它通过将键映射到数组索引上来实现快速操作。以下是关于散列表的一些基本概念、工作原理以及其实现方面的详细介绍。

散列表的基本概念

键值对：散列表存储的是键值对，键（Key）是唯一的，用来标识一个特定的元素，而值（Value）则是与键关联的数据。
散列函数：散列函数（Hash Function）是散列表的核心组件之一，它接受一个键作为输入，并输出一个散列值（Hash Value），这个散列值通常是数组的一个索引。
散列表（数组）：散列表通常是一个数组，用来存储键值对。散列函数将键映射到数组的一个索引上，从而实现快速访问。
冲突处理：由于不同的键可能映射到同一个数组索引，这种情况称为冲突（Collision）。解决冲突的方法包括开放寻址法（Open Addressing）和链地址法（Separate Chaining）。

工作原理

散列函数的设计：好的散列函数应当计算简单，并且使得关键字在地址空间中的分布尽可能均匀，以减少冲突的发生。常见的散列函数构造方法包括直接定址法、除留取余法等
1
。
冲突处理方法：
- 开放寻址法：当发生冲突时，开放寻址法会在散列表中寻找下一个可用的位置。常见的方法包括线性探测（Linear Probing）、平方探测（Quadratic Probing）和双散列（Double Hashing）等
  1
  。
- 链地址法：另一种常见的冲突解决方法是链地址法，即在每个散列地址上维护一个链表。所有映射到同一索引的键值对都被插入到该链表中
  12
  。

性能分析

散列表的性能主要取决于以下几个因素：

散列函数的均匀性：散列函数应当尽可能均匀地分布关键字，以减少冲突。
处理冲突的方法：不同的冲突处理方法会影响查找、插入和删除的效率。
装填因子（Load Factor）：装填因子 α = n/m，其中 n 是散列表中的元素数量，m 是散列表的大小。一般来说，α 应保持在 0.5 到 0.8 之间
1
。随着 α 的增大，冲突的概率增加，操作效率下降。

动态扩容

当散列表的装填因子过高时，可能会导致大量的冲突，从而影响性能。此时，通常会进行动态扩容（Dynamic Resizing），即创建一个更大的散列表，并将旧散列表中的所有元素重新散列到新表中。扩容后的新散列表大小通常是原来的两倍

实现示例

以下是一个简单的散列表实现示例：

import java.util.LinkedList;

public class SimpleHashTable<K, V> {
    private LinkedList<Entry<K, V>>[] table;
    private int size;
    private int capacity;

    public SimpleHashTable(int capacity) {
        this.capacity = capacity;
        table = new LinkedList[capacity];
        size = 0;
    }

    private int hash(K key) {
        return Math.abs(key.hashCode() % capacity);
    }

    public void put(K key, V value) {
        int index = hash(key);
        if (table[index] == null) {
            table[index] = new LinkedList<>();
        }
        LinkedList<Entry<K, V>> bucket = table[index];
        for (Entry<K, V> entry : bucket) {
            if (entry.getKey().equals(key)) {
                entry.setValue(value);
                return;
            }
        }
        bucket.add(new Entry<>(key, value));
        size++;
    }

    public V get(K key) {
        int index = hash(key);
        LinkedList<Entry<K, V>> bucket = table[index];
        if (bucket != null) {
            for (Entry<K, V> entry : bucket) {
                if (entry.getKey().equals(key)) {
                    return entry.getValue();
                }
            }
        }
        return null;
    }

    private static class Entry<K, V> {
        private K key;
        private V value;

        public Entry(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }
}

这个示例展示了如何使用链地址法来解决冲突，并提供了基本的 put 和 get 方法。实际应用中，还需要考虑更多的细节，如负载因子的控制、散列函数的选择等。

总结

散列表是一种非常高效的数据结构，通过合理的设计散列函数和冲突解决策略，可以在大多数情况下实现 O(1) 的平均时间复杂度。它广泛应用于现代软件系统中，是程序员必备的知识之一。

基本类型引用类型：

在编程语言中，数据类型通常分为两大类：基本数据类型（primitive types）和引用数据类型（reference types）。这两种类型的处理方式有所不同，了解它们之间的区别对于编写高效且无错误的代码至关重要。

基本数据类型

基本数据类型是直接存储实际值的数据类型。这些类型的变量直接包含数据，并且通常占用固定的内存空间。不同的编程语言可能有不同的基本数据类型，但是常见的包括：

- 整型（如 `int`）
- 浮点型（如 `float`, `double`）
- 字符型（如 `char`）
- 布尔型（如 `boolean`）

例如，在 Java 中，如果你声明一个 `int` 类型的变量并赋值 `5`，那么这个变量将直接保存数字 `5`。

引用数据类型

引用数据类型则不同，它们不直接存储值，而是存储指向实际数据的引用（或指针）。这意味着变量本身包含的是数据在内存中的地址，而不是数据本身。

例如，在 Java 中创建一个 `ArrayList<Integer>` 并向其中添加元素，那么声明的变量实际上是一个指向该列表对象的引用。

Hashmap

区别

1. 内存分配：基本类型直接在栈中分配内存，而引用类型则是在堆上分配内存空间，变量存储的是指向该空间的地址。
2. 复制行为：当复制基本类型变量时，会创建一个新的副本；而对于引用类型，复制的是引用，因此两个变量指向同一个对象。
3. 生命周期：基本类型的生命周期与它们所在的函数或者作用域相同；而引用类型的生命周期更长，通常由垃圾回收机制管理。

理解这些差异有助于更好地管理程序中的内存使用，并避免一些常见的编程错误。不同的编程语言可能会对这些概念有不同的实现细节，所以最好参照具体语言的文档来学习如何正确地使用基本类型和引用类型。