tonngw's Blog

HashMap 源码精读笔记

2022-07-26T13:11:03.888Z

HashMap 类属性

HashMap 继承于 AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口，是非常常用的一个集合类，同时在 JDK 1.7 和 JDK 1.8 版本的底层实现上也有很大区别。

package java.util;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import sun.misc.SharedSecrets;

/**
 * Hash table based implementation of the Map interface.  This
 * implementation provides all of the optional map operations, and permits
 * null values and the null key.  (The HashMap
 * class is roughly equivalent to Hashtable, except that it is
 * unsynchronized and permits nulls.)  This class makes no guarantees as to
 * the order of the map; in particular, it does not guarantee that the order
 * will remain constant over time.
 *
 * This implementation provides constant-time performance for the basic
 * operations (get and put), assuming the hash function
 * disperses the elements properly among the buckets.  Iteration over
 * collection views requires time proportional to the "capacity" of the
 * HashMap instance (the number of buckets) plus its size (the number
 * of key-value mappings).  Thus, it's very important not to set the initial
 * capacity too high (or the load factor too low) if iteration performance is
 * important.
 *
 * 
An instance of HashMap has two parameters that affect its
 * performance: initial capacity and load factor.  The
 * capacity is the number of buckets in the hash table, and the initial
 * capacity is simply the capacity at the time the hash table is created.  The
 * load factor is a measure of how full the hash table is allowed to
 * get before its capacity is automatically increased.  When the number of
 * entries in the hash table exceeds the product of the load factor and the
 * current capacity, the hash table is rehashed (that is, internal data
 * structures are rebuilt) so that the hash table has approximately twice the
 * number of buckets.
 *
 * 
As a general rule, the default load factor (.75) offers a good
 * tradeoff between time and space costs.  Higher values decrease the
 * space overhead but increase the lookup cost (reflected in most of
 * the operations of the HashMap class, including
 * get and put).  The expected number of entries in
 * the map and its load factor should be taken into account when
 * setting its initial capacity, so as to minimize the number of
 * rehash operations.  If the initial capacity is greater than the
 * maximum number of entries divided by the load factor, no rehash
 * operations will ever occur.
 *
 * 
If many mappings are to be stored in a HashMap
 * instance, creating it with a sufficiently large capacity will allow
 * the mappings to be stored more efficiently than letting it perform
 * automatic rehashing as needed to grow the table.  Note that using
 * many keys with the same {@code hashCode()} is a sure way to slow
 * down performance of any hash table. To ameliorate impact, when keys
 * are {@link Comparable}, this class may use comparison order among
 * keys to help break ties.
 *
 * 
Note that this implementation is not synchronized.
 * If multiple threads access a hash map concurrently, and at least one of
 * the threads modifies the map structurally, it must be
 * synchronized externally.  (A structural modification is any operation
 * that adds or deletes one or more mappings; merely changing the value
 * associated with a key that an instance already contains is not a
 * structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the map.
 *
 * If no such object exists, the map should be "wrapped" using the
 * {@link Collections#synchronizedMap Collections.synchronizedMap}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the map:

 *   Map m = Collections.synchronizedMap(new HashMap(...));
 *
 * The iterators returned by all of this class's "collection view methods"
 * are fail-fast: if the map is structurally modified at any time after
 * the iterator is created, in any way except through the iterator's own
 * remove method, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of concurrent
 * modification, the iterator fails quickly and cleanly, rather than risking
 * arbitrary, non-deterministic behavior at an undetermined time in the
 * future.
 *
 * 
Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.  Fail-fast iterators
 * throw ConcurrentModificationException on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness: the fail-fast behavior of iterators
 * should be used only to detect bugs.
 *
 * 
This class is a member of the
 * @docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework.
 *
 * @param  the type of keys maintained by this map
 * @param  the type of mapped values
 *
 * @author  Doug Lea
 * @author  Josh Bloch
 * @author  Arthur van Hoff
 * @author  Neal Gafter
 * @see     Object#hashCode()
 * @see     Collection
 * @see     Map
 * @see     TreeMap
 * @see     Hashtable
 * @since   1.2
 */
// 这里继承了 AbstractMap，而 AbstractMap 也实现了 Map 接口，所以这里每没必要再去实现 Map 接口，会产生什么影响呢？
// 1. 在 java 文件编译成 class 字节码文件时
// 首先会把 java.util.Map 会被编译到 CONSTANT_UTF8_INFO 中，最终完全字面量的解析
//如果多实现一个接口的情况下，在接口索引集合中会多出一个接口
// 2. class 文件最终会被加载到运行时数据区的方法区形成一个动态数据结构，每次调用 HashMap 时这个 Map 接口都会加载
public class HashMap extends AbstractMap
    implements Map, Cloneable, Serializable { // 实现了 Map、Cloneable、Serializable

    private static final long serialVersionUID = 362498820763181265L; // 随机序列化编号

    /*
     * Implementation notes.
     *
     * This map usually acts as a binned (bucketed) hash table, but
     * when bins get too large, they are transformed into bins of
     * TreeNodes, each structured similarly to those in
     * java.util.TreeMap. Most methods try to use normal bins, but
     * relay to TreeNode methods when applicable (simply by checking
     * instanceof a node).  Bins of TreeNodes may be traversed and
     * used like any others, but additionally support faster lookup
     * when overpopulated. However, since the vast majority of bins in
     * normal use are not overpopulated, checking for existence of
     * tree bins may be delayed in the course of table methods.
     *
     * Tree bins (i.e., bins whose elements are all TreeNodes) are
     * ordered primarily by hashCode, but in the case of ties, if two
     * elements are of the same "class C implements Comparable",
     * type then their compareTo method is used for ordering. (We
     * conservatively check generic types via reflection to validate
     * this -- see method comparableClassFor).  The added complexity
     * of tree bins is worthwhile in providing worst-case O(log n)
     * operations when keys either have distinct hashes or are
     * orderable, Thus, performance degrades gracefully under
     * accidental or malicious usages in which hashCode() methods
     * return values that are poorly distributed, as well as those in
     * which many keys share a hashCode, so long as they are also
     * Comparable. (If neither of these apply, we may waste about a
     * factor of two in time and space compared to taking no
     * precautions. But the only known cases stem from poor user
     * programming practices that are already so slow that this makes
     * little difference.)
     *
     * Because TreeNodes are about twice the size of regular nodes, we
     * use them only when bins contain enough nodes to warrant use
     * (see TREEIFY_THRESHOLD). And when they become too small (due to
     * removal or resizing) they are converted back to plain bins.  In
     * usages with well-distributed user hashCodes, tree bins are
     * rarely used.  Ideally, under random hashCodes, the frequency of
     * nodes in bins follows a Poisson distribution
     * (http://en.wikipedia.org/wiki/Poisson_distribution) with a
     * parameter of about 0.5 on average for the default resizing
     * threshold of 0.75, although with a large variance because of
     * resizing granularity. Ignoring variance, the expected
     * occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
     * factorial(k)). The first values are:
     *
     * 0:    0.60653066
     * 1:    0.30326533
     * 2:    0.07581633
     * 3:    0.01263606
     * 4:    0.00157952
     * 5:    0.00015795
     * 6:    0.00001316
     * 7:    0.00000094
     * 8:    0.00000006
     * more: less than 1 in ten million
     *
     * The root of a tree bin is normally its first node.  However,
     * sometimes (currently only upon Iterator.remove), the root might
     * be elsewhere, but can be recovered following parent links
     * (method TreeNode.root()).
     *
     * All applicable internal methods accept a hash code as an
     * argument (as normally supplied from a public method), allowing
     * them to call each other without recomputing user hashCodes.
     * Most internal methods also accept a "tab" argument, that is
     * normally the current table, but may be a new or old one when
     * resizing or converting.
     *
     * When bin lists are treeified, split, or untreeified, we keep
     * them in the same relative access/traversal order (i.e., field
     * Node.next) to better preserve locality, and to slightly
     * simplify handling of splits and traversals that invoke
     * iterator.remove. When using comparators on insertion, to keep a
     * total ordering (or as close as is required here) across
     * rebalancings, we compare classes and identityHashCodes as
     * tie-breakers.
     *
     * The use and transitions among plain vs tree modes is
     * complicated by the existence of subclass LinkedHashMap. See
     * below for hook methods defined to be invoked upon insertion,
     * removal and access that allow LinkedHashMap internals to
     * otherwise remain independent of these mechanics. (This also
     * requires that a map instance be passed to some utility methods
     * that may create new nodes.)
     *
     * The concurrent-programming-like SSA-based coding style helps
     * avoid aliasing errors amid all of the twisty pointer operations.
     */

    /**
     * The default initial capacity - MUST be a power of two. 必须是 2 的 n 次幂
     */
    // 默认初始容量是 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    // 数组的最大长度是 2^30
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    // 默认装载因子，和默认容量配合 16 * 0.75 = 12，所以真正可以存放元素的大小是 12，当数组中超过这个数之后就要进行一次扩容，精确扩容为 2 倍
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    // 转树，链表转换红黑树的阈值是 8，同时要求 table 的长度也要大于 64（MIN_TREEIFY_CAPACITY）才会转换红黑树
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
    // 解树，红黑树退化为链表的阈值是 6
    // 这里为什么是 6，不是 7 呢？
    // 两层含义
    // 1. 当链表是 8 的时候刚转成红黑树，由于二叉树是一棵自平衡二叉搜索树，所以节点为 8 个时最后一层有一个元素，7 的时候正好是左右对称的，搜索性能最好，到 6 的时候可以考虑再变链表
    // 2. 懒加载的思想，第一次删除元素后我不变链表，第二次删除元素的时候再变，否则刚变成红黑树就要退化成链表，损耗性能。
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
    // 转变红黑树的最小数组容量是 64
    static final int MIN_TREEIFY_CAPACITY = 64;
 
    // ...
    
    /* ---------------- Fields -------------- */

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    // table 桶数组，存放 Node 节点
    // 这里用 transient 修饰，不能被序列化，但它还要被序列化，怎么做的呢？和 ArrayList 一样，都是自己实现了序列化方法 writeObject、readObject
    transient Node[] table;

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    // 存储所有的键值对
    transient Set> entrySet;

    /**
     * The number of key-value mappings contained in this map.
     */
    // HashMap 的 size，记录有元素的节点
    transient int size;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    // 修改次数
    transient int modCount;

    /**
     * The next size value at which to resize (capacity * load factor).
     *
     * @serial
     */
    // (The javadoc description is true upon serialization.
    // Additionally, if the table array has not been allocated, this
    // field holds the initial array capacity, or zero signifying
    // DEFAULT_INITIAL_CAPACITY.)
    // 下一次触发扩容的阈值
    int threshold;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    // 加载因子
    final float loadFactor;
}

【重点】Node 节点

/**
 * Basic hash bin node, used for most entries.  (See below for
 * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
 */
static class Node implements Map.Entry { // 实现了 Map.Entry
    // 为什么 hash 和 key 设置成 final
    final int hash; // 1. hash 值在一定程度上代表了对象的地址，内存地址是不能随便改变的 
    // 2. 同时在 32 位虚拟机的对象头 Mark Word 中有一个 15 位的 hash 值，4 位分代年龄 2 位锁标记位、1 位是否为偏向锁，对象头中的内容是不能改变的
    
    final K key; // 1. 而 key 不能修改，只能通过先删除再添加的方式 曲线救国 2. key 还会用于对比传入的 key 是否已经存在，不能随便修改
    
    V value; // value 可以重新赋值的
    Node next; // next 指针

    Node(int hash, K key, V value, Node next) { // 构造器
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() { // 【重要】当前 node 的 hashCode也做了一次扰动处理，直接调用 Object 的 hashCode() 方法，将 key 的 hashcode 和 value 的 hashcode 做异或
        return Objects.hashCode(key) ^ Objects.hashCode(value); // 异或的好处就是散列更加均匀
    }

    public final V setValue(V newValue) { // 旧值用新值替换
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)  // 如果地址相等说明对象相等，则直接返回 true
            return true;
        if (o instanceof Map.Entry) { // 判断 o 的类型是 Map.Entry
            Map.Entry e = (Map.Entry)o; // 将 o 强转成 Map.Entry，强转之后才能用 HashMap 的方法
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue())) // 然后调用 Objects【不是 Object】 的 equals() 方法判断 key、value 和传入的 key、value 是否相等
                return true;
        }
        return false;
    }
}

// Objects 类
/**
 * Returns {@code true} if the arguments are equal to each other
 * and {@code false} otherwise.
 * Consequently, if both arguments are {@code null}, {@code true}
 * is returned and if exactly one argument is {@code null}, {@code
 * false} is returned.  Otherwise, equality is determined by using
 * the {@link Object#equals equals} method of the first
 * argument.
 *
 * @param a an object
 * @param b an object to be compared with {@code a} for equality
 * @return {@code true} if the arguments are equal to each other
 * and {@code false} otherwise
 * @see Object#equals(Object)
 */
public static boolean equals(Object a, Object b) {
    // 先判断对象地址是否相等，再根据传入的 Object 的具体类型的 equals() 方法进行比较（如果这个类重写了 equals() 那就按重写的逻辑比较
    // 没有重写按 Object 的 equals() 还是比较对象地址）
    return (a == b) || (a != null && a.equals(b)); 
}

【重点】hash(Object key)

注意：==null key 的哈希值是 0，不会调用 hashCode() 方法==

/**
 * Computes key.hashCode() and spreads (XORs) higher bits of hash
 * to lower.  Because the table uses power-of-two masking, sets of
 * hashes that vary only in bits above the current mask will
 * always collide. (Among known examples are sets of Float keys
 * holding consecutive whole numbers in small tables.)  So we
 * apply a transform that spreads the impact of higher bits
 * downward. There is a tradeoff between speed, utility, and
 * quality of bit-spreading. Because many common sets of hashes
 * are already reasonably distributed (so don't benefit from
 * spreading), and because we use trees to handle large sets of
 * collisions in bins, we just XOR some shifted bits in the
 * cheapest possible way to reduce systematic lossage, as well as
 * to incorporate impact of the highest bits that would otherwise
 * never be used in index calculations because of table bounds.
 */
// 求 key 的哈希值，自身和右移 16 位做异或
static final int hash(Object key) {
    int h;
    // null key 的哈希值是 0
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

comparableClassFor(Object x)

/**
 * Returns x's Class if it is of the form "class C implements
 * Comparable", else null.
 */
// 判断当前类 x 是否实现了 Comparable 接口（是否进行比较），如果是返回当前类的 Class 对象，否则返回 null
static Class comparableClassFor(Object x) {
    if (x instanceof Comparable) { // 类型判断
        // c 是 Class 对象，ts、as 是类型数组 (s) 复数，t 是类型并且是 ts 中的元素，p 是参数化类型（ArrayList）
        Class c; Type[] ts, as; Type t; ParameterizedType p;
        
        // 如果 x 的 Class 对象是 String 类型，直接返回类型 c。因为 String 类实现了 Comparable 接口
        if ((c = x.getClass()) == String.class) // bypass checks
            return c;
        // 获取实现的接口是否为空，并赋值给 ts【List, RandomAccess、Cloneable、Seriablizable】
        if ((ts = c.getGenericInterfaces()) != null) {
            for (int i = 0; i < ts.length; ++i) { // 循环每个接口
                if (((t = ts[i]) instanceof ParameterizedType) && // 判断当前接口是否是参数类类型的，即 List 形式
                    ((p = (ParameterizedType)t).getRawType() ==
                     Comparable.class) &&// 且 判断这个参数化类型的外层【List】 是否 是 Comparable.class 类型
                    (as = p.getActualTypeArguments()) != null && // 且 判断这个参数化类型的内层 【Object.class[]】是否为空
                    as.length == 1 && as[0] == c) // type arg is c // 且内层数组的大小必须是 1 且第一个元素的类型是 c 
                    return c; // 才返回类型 c
            }
        }
    }
    return null; // 否则返回 null
}

compareComparables(Class kc, Object k, Object x) {

/**
 * Returns k.compareTo(x) if x matches kc (k's screened comparable
 * class), else 0.
 */
// 对于对象 k，k 的类型是 kc，比较 k 和 x
@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
static int compareComparables(Class kc, Object k, Object x) {
    return (x == null || x.getClass() != kc ? 0 :
            ((Comparable)k).compareTo(x));
}

【重点】tableSizeFor(int cap)

/**
 * Returns a power of two size for the given target capacity.
 */
// 取出一个数字的最接近 2^n 次方的数（向上取整）
static final int tableSizeFor(int cap) {
    int n = cap - 1; // 9
    n |= n >>> 1; // 1001 | 0100 = 1101
    n |= n >>> 2; // 1101 | 0011 = 1111
    n |= n >>> 4; // 1111 | 0000 = 1111
    n |= n >>> 8; // 1111
    n |= n >>> 16;// 1111
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; // n + 1 = 1 0000 = 2^4 = 16
}

HashMap 构造器

/* ---------------- Public operations -------------- */

/**
 * Constructs an empty HashMap with the specified initial
 * capacity and load factor.
 *
 * @param  initialCapacity the initial capacity
 * @param  loadFactor      the load factor
 * @throws IllegalArgumentException if the initial capacity is negative
 *         or the load factor is nonpositive
 */
// 带初始容量和负载因子的构造器
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0) // 初始容量小于 0 直接抛异常
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY) // 初始容量大于 2^30 赋值给 2^30
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor)) // 负载因子小于 0 或传入的不是一个数，直接抛异常
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity); // 否则将初始容量向上取最近的 2^n 次幂
}

/**
 * Constructs an empty HashMap with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param  initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 */
// 只带初始容量的构造器
public HashMap(int initialCapacity) {
    // 调用的还是两个参数的构造器，只不过负载因子指定为默认的 0.75
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * Constructs an empty HashMap with the default initial capacity
 * (16) and the default load factor (0.75).
 */
// 空参构造器没有对 table 赋值（即 threshold 变量）
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

/**
 * Constructs a new HashMap with the same mappings as the
 * specified Map.  The HashMap is created with
 * default load factor (0.75) and an initial capacity sufficient to
 * hold the mappings in the specified Map.
 *
 * @param   m the map whose mappings are to be placed in this map
 * @throws  NullPointerException if the specified map is null
 */
// 带 Map 参数构造器，用另一个 Map 初始化当前 HashMap
public HashMap(Map m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false); // evcit = false 表示第一次构造，否则 true
}

putMapEntries(Map m, boolean evict)

/**
 * Implements Map.putAll and Map constructor
 *
 * @param m the map
 * @param evict false when initially constructing this map, else
 * true (relayed to method afterNodeInsertion).
 */
final void putMapEntries(Map m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        // 如果 table 是 null，则给 threshold 赋值
        if (table == null) { // pre-size
            float ft = ((float)s / loadFactor) + 1.0F; // 通过 元素个数 / 加载因子 反向得到容量，因为不能整除，所以保险起见向上取整
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY); // float 转 int
            if (t > threshold) // 如果 m 需要的空间大小 t > table 的大小 threshold，容量向上取最近的 2^n
                threshold = tableSizeFor(t);
        }
        else if (s > threshold) // 如果 table 不为空且 m 中的元素个数 s 大于table 的大小 threshold，放不下了就进行扩容
            resize();
        for (Map.Entryextends K, ? extends V> e : m.entrySet()) { // 最后就是初始化，把 m 中的每个 key-value 放到 table 数组中
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict); // 调用私有的 putVal()
        }
    }
}

【重点】get(Object key)

/**
 * Returns the value to which the specified key is mapped,
 * or {@code null} if this map contains no mapping for the key.
 *
 * More formally, if this map contains a mapping from a key
 * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
 * key.equals(k))}, then this method returns {@code v}; otherwise
 * it returns {@code null}.  (There can be at most one such mapping.)
 *
 * 
A return value of {@code null} does not necessarily
 * indicate that the map contains no mapping for the key; it's also
 * possible that the map explicitly maps the key to {@code null}.
 * The {@link #containsKey containsKey} operation may be used to
 * distinguish these two cases.
 *
 * @see #put(Object, Object)
 */
// 根据 key 获取值
public V get(Object key) {
    Node e;
    return (e = getNode(hash(key), key)) == null ? null : e.value; // 调用内部的 getNode() 方法
}

/**
 * Implements Map.get and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @return the node, or null if none
 */
// 根据 hash 值和 key 获取 Node 节点
final Node getNode(int hash, Object key) {
    Node[] tab; // 定义的一个临时 Node 数组，用于存放 table 数组
    Node first, e; // first 表示链表的头节点，e 是一个临时节点
    int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 && // table 不为空
        (first = tab[(n - 1) & hash]) != null) { // 且 取出当前的节点 Node 不为空； tab[(n - 1) & hash]，(n - 1) & hash 定位底层数组的索引下标
        // hash 值相等且 key 相等 且 equals() 相等, 直接返回 first，
        // 为什么要三个判断呢？因为根据 hash 值相等不能判断两个对象相等
        if (first.hash == hash && // always check first node 
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 否则比较头节点的下一个节点（可能是 Node、也可能是 TreeNode）
        if ((e = first.next) != null) {
            if (first instanceof TreeNode) // 如果是 TreeNode，则从红黑树中查询 getTreeNode
                return ((TreeNode)first).getTreeNode(hash, key);
            // 否则遍历链表，从链表里找
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // 找不到就返回 null
    return null;
}

containsKey(Object key)

/**
 * Returns true if this map contains a mapping for the
 * specified key.
 *
 * @param   key   The key whose presence in this map is to be tested
 * @return true if this map contains a mapping for the specified
 * key.
 */
// getNode() 返回值是 null 表示不存在，否则存在
public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

【重点】put(K key, V value) 添加和修改方法

通过看源码我们发现，如果 put 是修改的情况则会返回旧值，如果 put 是添加的话，最后添加成功返回 null

根据这个特性，我们在需要确保唯一的 key 的业务场景下，就可以使用这个返回值来判断在业务执行的过程中 key 到底是不是唯一的，如果出现了不唯一的情况抛出异常，排查问题。

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with key, or
 *         null if there was no mapping for key.
 *         (A null return can also indicate that the map
 *         previously associated null with key.)
 */
public V put(K key, V value) {
    // 调用 putVal
    return putVal(hash(key), key, value, false, true);
}

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
// 真正的 put
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    
    Node[] tab; // table 数组的副本
    Node p; // p 是桶下标的头节点
    int n, i; // n 是 table 数组的大小
    
    // 如果 table 是 null 或者 table 没有元素
    if ((tab = table) == null || (n = tab.length) == 0) 
        n = (tab = resize()).length; // 进行一次扩容，第一次就是 16 赋值给 n
    
    // 此时 table 不为 null，定位桶下标
    // 如果当前槽位上没有数据，直接放进去
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 否则说明当前槽位上有数据
    else {
        Node e; K k;
        // 如果头节点的 key 就是就是传入的 key，则直接将头节点 p 赋值给 e
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果头节点 p 是红黑树节点，则需要进行 TreeNode 的添加
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        // 否则那就是链表形式，而且头节点的 key 不是传入的 key
        else {
            // 遍历链表
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) { // 如果当前节点的 next 是空，则尾插法插入传入的节点，结束 put
                    p.next = newNode(hash, key, value, null);
                    // 当链表长度达到 8，执行 treeifyBin() 链表转红黑树，至于最终转不转还要 table 的长度是否大于 64，大于才转，否则执行扩容
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 
                        treeifyBin(tab, hash);
                    break;
                }
                // 否则如果找到了 key 相同的节点，也要结束 put
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e; // 否则 p = (e = p.next) 其实就是 p = p.next
            }
        }
        // 如果 e 不为 null 说明从 HashMap 中找到了这个 key 对应的节点，那么执行修改逻辑，修改 key 对应的值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null) // onlyIfAbsent 如果是 true 则不能修改
                e.value = value;
            afterNodeAccess(e);
            return oldValue; // 修改完返回旧值
        }
    }
    ++modCount; // 修改数 + 1
    
   // 注意：HashMap 是先添加再扩容
    if (++size > threshold) // 如果元素个数超过扩容阈值，进行扩容
        resize();
    afterNodeInsertion(evict);
    return null; // 如果添加成功则返回 null
}

// 如果 put 的 key 存在且 value 不是 null 就不覆盖这个 value
// 如果 key 存在且 value 是 null，则覆盖这个 value
// 如果 key 不存在就直接添加
@Override
public V putIfAbsent(K key, V value) {
    return putVal(hash(key), key, value, true, true);
}

resize() 扩容方法

思考题：HashMap 最多能放多少个元素呢？

和底层数组 table 的大小有关，与 threshold 没有关系，threshold 只有扩容有关，它的大小不会限制其他的操作。

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * @return the table
 */
final Node[] resize() {
    Node[] oldTab = table; // oldTable 表示原来的 table，做一个副本
    int oldCap = (oldTab == null) ? 0 : oldTab.length; // 如果 oldTable 的长度是空容量为 0，否则容量为 length
    int oldThr = threshold; // oldThr 表示原 table 的 threshold (= length * load_factor)
    int newCap, newThr = 0; //定义 新 table 的容量和阈值
    if (oldCap > 0)  // 如果 oldTable 容量 oldCap 大于 0
        if (oldCap >= MAXIMUM_CAPACITY) { // 如果旧容量大于 2^30，放弃扩容，直接修改 threshold
            threshold = Integer.MAX_VALUE; // threshold 直接赋值为 INT_MAX
            return oldTab; // 返回了旧 table
        }
    // 继续扩容
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && // 首先就是扩容为两倍 且 小于 2^30 次方
                 oldCap >= DEFAULT_INITIAL_CAPACITY) // 且 旧容量 大于等于 初始容量
            newThr = oldThr << 1; // double threshold // newThr (新的 threshold) 变成原来 oldThr 的两倍
    }
// 否则 oldTable 容量 oldCap 小于等于 0
    else if (oldThr > 0) // initial capacity was placed in threshold // oldThr 大于 0
        newCap = oldThr; // 新容量 newCap 赋值为 oldThr
// 否则 oldTable 容量 oldCap 小于等于 0 且阈值 oldThr 也是小于等于 0，那么就用默认值
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY; // 新容量 newCap 为默认初始容量 64
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 新阈值 newThr 为默认加载因子 * 默认初始容量
    }

    if (newThr == 0) {// 如果信阈值为 0
        float ft = (float)newCap * loadFactor; // 得到 HashMap 实际可以使用的大小，即阈值
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? 
                  (int)ft : Integer.MAX_VALUE); // 新容量小于最大容量 2^30 且 ft 也要小于 2^30，此时新的阈值 newThr 等于 ft，否则就取 int 最大值
    }

// -------------------

    threshold = newThr; // 真正的给 threshold 进行 newThr 的赋值
    @SuppressWarnings({"rawtypes","unchecked"})
        Node[] newTab = (Node[])new Node[newCap]; // 创建扩容两倍后的 table
    table = newTab; // 真正的给 table 进行 newTab 的赋值

// -----节点的迁移（原位置和新位置）----
// 如果 oldTable 不为空，则进行节点迁移，否则直接返回扩容后的 newTable
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) { // for 循环取每个节点
            Node e;  // e 用于存放 oldTable 的每个节点
            if ((e = oldTab[j]) != null) { // 如果 e 不是空
                oldTab[j] = null; // 则将 oldTable[j] 的内容置空，方便 gc，真正的值已经存到 e 中了
                if (e.next == null) // 如果 e.next 为空，说明 e 是槽位上的头节点
                    newTab[e.hash & (newCap - 1)] = e; // 则直接插入到 newTabale 对应的槽位上
                else if (e instanceof TreeNode) // 否则如果 e 是树节点，则进行【拆分树】
                    // 如果进行 HashMap 扩容，我们的树肯定会被拆掉，会产生一定性能消耗
                    // 实际情况下，我们的 HashMap 很难达到红黑树。1. hash 十分散列 2. 业务中 不可能、不能够、不允许 在一个 map 中放这么多元素
                    // 如果我需要从 db 中取出 2^30 个数据，需要用 HashMap 进行处理，怎么办？
                    // 想到 ArrayList 的 clear() 方法，能够复用，不需要再次扩容
                    // 【重要】HashMap 也是如此，利用 clear() 方法进行分批处理，再 clear() 再放数据，只需要扩容一次
                    ((TreeNode)e).split(this, newTab, j, oldCap);
                else { // preserve order // 否则链表上不止一个节点就需要遍历链表
                    Node loHead = null, loTail = null; // loHead 是 old 链表的头节点，loTail 是 old 链表的尾节点
                    Node hiHead = null, hiTail = null; // hiHead 是 new 链表的头节点，hiTail 是 new 链表的尾节点
                    Node next; // 记录 next 节点
                    
                    // 【创建链表】
                    // do while 循环遍历链表，分别建立了两个链表，一个 old 链表，一个 new 链表
                    // old 链表存的是位置不变的节点，new 链表是需要变化位置的节点
                    do { 
                        next = e.next; // 记录 next 节点
                        if ((e.hash & oldCap) == 0) { // 如果当前节点的 hash 值 & 旧容量 等于 0，则位置不变
                            if (loTail == null) // 如果尾节点是空，说明链表为空，那么 e 就是 old 链表的头节点
                                loHead = e;
                            else
                                loTail.next = e; // 【尾插法】否则将 e 插入尾节点后面
                            loTail = e; // 最后更新尾节点为 e
                        }
                        else { // 否则，变化位置，将该元素放在新链表中
                            if (hiTail == null) // 如果尾节点是空，说明链表为空，那么 e 就是 new 链表的头节点
                                hiHead = e;
                            else
                                hiTail.next = e; // 【尾插法】否则将 e 插入尾节点后面
                            hiTail = e; // 最后更新尾节点为 e
                        }
                    } while ((e = next) != null);
                    
                    // 【真正添加到 newTable 中】
                    // old 链表尾部最终判断
                    if (loTail != null) { // 如果 old 链表的尾节点 loTail 不为空，说明旧链表有元素（里面就是那些位置不变的节点），则将其置为空，并且将旧链表放到 newTable 的对应对应槽位上
                        loTail.next = null;
                        newTab[j] = loHead; // 按照 oldTable 的位置不变，将旧链表的头节点 loHead 挂到 newTable 的槽位 j 上
                    }
                    // new 链表尾部最终判断
                    if (hiTail != null) { // 如果 new 链表的尾节点 loTail 不为空，说明新链表有元素（里面就是位置需要变化的节点），则将其置为空，并且将旧链表放到 newTable 的对应对应槽位上
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead; // 将新链表的头节点 hiHead 挂到 newTable 的 j + oldCap 槽位上，所以位置由原来的 j 变到了 j + oldCap
                    }
                }
            }
        }
    }
// 最后返回 newTable
    return newTab;
}

clear() 清空元素，但容量不变，可以复用

/**
 * Removes all of the mappings from this map.
 * The map will be empty after this call returns.
 */
public void clear() {
    Node[] tab;
    modCount++;
    if ((tab = table) != null && size > 0) {
        size = 0; // 元素个数置为 0，但是容量没变
        for (int i = 0; i < tab.length; ++i)
            tab[i] = null; // 清空每个槽位
    }
}

getOrDefault(key, defaultValue)

Map 接口的 getOrDefault(key, defaultValue) 实现

/**
 * Returns the value to which the specified key is mapped, or
 * {@code defaultValue} if this map contains no mapping for the key.
 *
 * @implSpec
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key the key whose associated value is to be returned
 * @param defaultValue the default mapping of the key
 * @return the value to which the specified key is mapped, or
 * {@code defaultValue} if this map contains no mapping for the key
 * @throws ClassCastException if the key is of an inappropriate type for
 * this map
 * (@docRoot}/java/util/Collection.html#optional-restrictions">optional)
 * @throws NullPointerException if the specified key is null and this map
 * does not permit null keys
 * (@docRoot}/java/util/Collection.html#optional-restrictions">optional)
 * @since 1.8
 */
default V getOrDefault(Object key, V defaultValue) {
    V v;
    // 两个判断：1. 先判断值是否为 null  2. 再判断是否包含 key
    // 这里的 get(key) 调用的是子类的实现
    return (((v = get(key)) != null) || containsKey(key))
        ? v
        : defaultValue;
}

HashMap 接口的 getOrDefault(key, defaultValue) 实现

和 Map 接口的实现不一样，HashMap 直接通过 getNode() 判断节点是否为 null

同时我们的 HashMap 是允许 null key 和 null value 的，但只允许一个 null key，而且 ==null key 的散列位置在 0 号位置==

// Overrides of JDK8 Map extension methods

@Override
public V getOrDefault(Object key, V defaultValue) {
    Node e;
    // 只有一个判断：判断通过 key 获取到的 Node 是否为空，如果是空返回默认值，否则返回 value
    return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}

treeifyBin(Node[] tab, int hash) 链表树化

/**
 * Replaces all linked nodes in bin at index for given hash unless
 * table is too small, in which case resizes instead.
 */
// 树化方法：链表转红黑树，tab 就是底层数组，hash 是当前槽位上的链表 hash 值，它们的哈希值都是相等的
final void treeifyBin(Node[] tab, int hash) {
    int n, index; Node e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) // 如果 table 为空 或者 table 的容量小于 64
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) { // 判断链表头节点是否为空，并把头节点赋值给 e，此时 e 的类型还是链表节点 Node
        TreeNode hd = null, tl = null; // 定义红黑树节点变量 hd：可以理解为树的根节点（双向链表的尾节点），tl：树的尾节点（双向链表的尾节点）
        
        // do while 循环把单链表 Node 替换成 TreeNode，同时把单链表变成了双链表
        do {
            TreeNode p = replacementTreeNode(e, null); // 每次把链表节点 e 转换成 TreeNode
            if (tl == null) // 第一次 do while，tl = null，只会执行一次
                hd = p; // 将链表头节点对应的 TreeNode 赋值给 hd（可以理解为根节点）
            else { // 除了第一次之外，都需要建立前后两个节点之间的关系
                // ------- 卧槽，这是干啥呢？将单链表形式的 TreeNode 转换成双链表形式的 TreeNode
                p.prev = tl; // 当前节点 p 的前一个节点 指向 尾节点 tl
                tl.next = p; // 尾节点 tl 的下一个节点 指向 当前节点 p
            }
            tl = p; // 树的尾节点赋值为当前节点 p
        } while ((e = e.next) != null); // e = e.next 遍历单链表
        
        // 将树根节点 hd 替换到要树化的槽位上
        if ((tab[index] = hd) != null)
            // 传入 table，调用 TreeNode 内部的 treeify 执行真正的树化逻辑
            hd.treeify(tab);
    }
}

// For treeifyBin
TreeNode replacementTreeNode(Node p, Node next) {
    // 通过 hash、key、value、next 创建一个 TreeNode
    // 通过查看源码发现 TreeNode 是 Node 的子类，TreeNode 中没有 next 指针，但是 Node 中有
    // 我们知道二叉树节点只需要一个 left 和 right 就够了，为什么还需要一个 next 指针呢？这样设计的好处是什么？
    // 【重点】这个 next 指针是用来【快速解树】的，从红黑树快速变成链表，通过遍历每个节点的 next 指针马上就可以恢复成一个链表，太妙了！！！！
    return new TreeNode<>(p.hash, p.key, p.value, next);
}

/**
 * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
 * extends Node) so can be used as extension of either regular or
 * linked node.
 */
// TreeNode 的结构，继承 LinkedHashMap.Entry，最终继承了 Node
// 为什么不直接继承 Node？
// 因为 TreeNode 还需要继承 LinkedHashMap.Entry 中的属性方便对 LinkedHashMap 操作。
static final class TreeNode extends LinkedHashMap.Entry {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    
    // 没有 next 指针
    
    TreeNode(int hash, K key, V val, Node next) {
        super(hash, key, val, next);
    }
    
    // ...
    
}

// LinkedHashMap.Entry
static class Entry extends HashMap.Node {
    Entry before, after; // 记录了前驱节点和后继节点
    Entry(int hash, K key, V value, Node next) {
        super(hash, key, value, next);
    }
}

/**
 * Forms tree of the nodes linked from this node.
 * @return root of tree
 */
// TODO
// 将双向链表树化为红黑树 - 简化版：双向链表转换二叉树，LeetCode 类似题目：https://leetcode.cn/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof/
final void treeify(Node[] tab) {
    TreeNode root = null;
    for (TreeNode x = this, next; x != null; x = next) {
        next = (TreeNode)x.next;
        x.left = x.right = null;
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        }
        else {
            K k = x.key;
            int h = x.hash;
            Class kc = null;
            for (TreeNode p = root;;) {
                int dir, ph;
                K pk = p.key;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);

                TreeNode xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    x.parent = xp;
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    root = balanceInsertion(root, x);
                    break;
                }
            }
        }
    }
    moveRootToFront(tab, root);
}

putAll(Map m)

/**
 * Copies all of the mappings from the specified map to this map.
 * These mappings will replace any mappings that this map had for
 * any of the keys currently in the specified map.
 *
 * @param m mappings to be stored in this map
 * @throws NullPointerException if the specified map is null
 */
// put 一个 map 到 map 中
public void putAll(Map m) {
    // 调用的就是 putMapEntries，上面已经分析过了
    putMapEntries(m, true);
}

remove(Object key)

/**
 * Removes the mapping for the specified key from this map if present.
 *
 * @param  key key whose mapping is to be removed from the map
 * @return the previous value associated with key, or
 *         null if there was no mapping for key.
 *         (A null return can also indicate that the map
 *         previously associated null with key.)
 */
// 根据 key 删除一个节点
public V remove(Object key) {
    Node e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

/**
 * Implements Map.remove and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to match if matchValue, else ignored
 * @param matchValue if true only remove if value is equal
 * @param movable if false do not move other nodes while removing
 * @return the node, or null if none
 */
// 删除一个节点
final Node removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node[] tab; Node p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 && // (tab = table) != null && (n = tab.length) > 0 表示 HashMap 不为空，且有元素
        (p = tab[index = (n - 1) & hash]) != null) { // 获取当前槽位上的头节点 p 且 p 不为 null
        Node node = null, e; K k; V v; // node 就是最后要删除的节点
        // 说明头节点 p 就是要删除的节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // 如果不是头节点，继续判断，这里 p.next 既可以得到链表的下一个节点也可以得到红黑树的下一个节点，原因就是 TreeNode 是 Node 子类，同时我们也给 next 赋值了
        else if ((e = p.next) != null) {
            // 如果是树节点，则获取 TreeNode
            if (p instanceof TreeNode)
                node = ((TreeNode)p).getTreeNode(hash, key);
            // 否则就是链表
            else { 
                // do while 遍历链表，如果 e 是待删除节点则赋值给 node，直接 break
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e; // p 最终指向待删除的节点 e 的上一个节点
                } while ((e = e.next) != null);
            }
        }
        
        // ----- 真正的删除 node 节点
        // node 不为空，说明找到了 node，上面 remove() 方法传入的 matchValue = false
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 如果 node 是树节点，则调用 removeTreeNode 删除树节点
            if (node instanceof TreeNode)
                ((TreeNode)node).removeTreeNode(this, tab, movable);
            // 否则如果 node 是槽位上的链表的头节点 p，则头节点替换为下一个节点
            else if (node == p)
                tab[index] = node.next;
            // 否则如果 node 不是链表头节点，则一步操作单链表删除 node
            else
                p.next = node.next;
            ++modCount; // 修改次数 + 
            --size; // 元素个数 - 1
            afterNodeRemoval(node); // LinkedHashMap 的模板方法，对 HashMap 不起作用
            return node; // 返回删除的值
        }
    }
    return null; // 不存在返回 null
}

containsValue(Object value)

/**
 * Returns true if this map maps one or more keys to the
 * specified value.
 *
 * @param value value whose presence in this map is to be tested
 * @return true if this map maps one or more keys to the
 *         specified value
 */
public boolean containsValue(Object value) {
    Node[] tab; V v;
    if ((tab = table) != null && size > 0) { // 保证 table 不为空，有元素
        for (int i = 0; i < tab.length; ++i) { // 遍历数组
            for (Node e = tab[i]; e != null; e = e.next) { // 遍历每个槽位上的节点（可能是链表、可能是树）都可以通过 next 指针遍历
                if ((v = e.value) == value ||
                    (value != null && value.equals(v))) // 如果值相等返回 true
                    return true;
            }
        }
    }
    return false;
}

keySet() 和 values()

/**
 * Returns a {@link Set} view of the keys contained in this map.
 * The set is backed by the map, so changes to the map are
 * reflected in the set, and vice-versa.  If the map is modified
 * while an iteration over the set is in progress (except through
 * the iterator's own remove operation), the results of
 * the iteration are undefined.  The set supports element removal,
 * which removes the corresponding mapping from the map, via the
 * Iterator.remove, Set.remove,
 * removeAll, retainAll, and clear
 * operations.  It does not support the add or addAll
 * operations.
 *
 * @return a set view of the keys contained in this map
 */
// 获取 HashMap 的所有 key，是通过继承类 AbstractMap 的属性赋值的
// 这里的 key 都是指向 HashMap 的一个引用，而不存储真正的值，所以当 HashMap 中删除了某个键值对，keySet() 也就没有了这个 key
// 根据注释可以看到不支持 add() 和 addAll()，因为 KeySet 没有实现 add() 和 addAll() 调用父类的实现就是抛出异常
public Set keySet() {
    Set ks = keySet;
    if (ks == null) {
        ks = new KeySet(); // KeySet 是内部类，有 remove() 方法
        keySet = ks;
    }
    return ks;
}

/**
 * Returns a {@link Collection} view of the values contained in this map.
 * The collection is backed by the map, so changes to the map are
 * reflected in the collection, and vice-versa.  If the map is
 * modified while an iteration over the collection is in progress
 * (except through the iterator's own remove operation),
 * the results of the iteration are undefined.  The collection
 * supports element removal, which removes the corresponding
 * mapping from the map, via the Iterator.remove,
 * Collection.remove, removeAll,
 * retainAll and clear operations.  It does not
 * support the add or addAll operations.
 *
 * @return a view of the values contained in this map
 */
public Collection values() {
    Collection vs = values;
    if (vs == null) {
        vs = new Values(); // Values 是内部类，没有 remove() 方法，所以不能删除值，只能删除 key
        values = vs;
    }
    return vs;
}

// AbstractMap
transient Set        keySet;
transient Collection values;

entrySet()

/**
 * Returns a {@link Set} view of the mappings contained in this map.
 * The set is backed by the map, so changes to the map are
 * reflected in the set, and vice-versa.  If the map is modified
 * while an iteration over the set is in progress (except through
 * the iterator's own remove operation, or through the
 * setValue operation on a map entry returned by the
 * iterator) the results of the iteration are undefined.  The set
 * supports element removal, which removes the corresponding
 * mapping from the map, via the Iterator.remove,
 * Set.remove, removeAll, retainAll and
 * clear operations.  It does not support the
 * add or addAll operations.
 *
 * @return a set view of the mappings contained in this map
 */
// 获取 HashMap 的键值对
public Set> entrySet() {
    Set> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}

// HashMap
/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 */
transient Set> entrySet;

// EntrySet 是内部类

remove(Object key, Object value)

// 只有 key 和 value 都匹配才去删除节点 
@Override
public boolean remove(Object key, Object value) {
    // 第一个 true 表示 matchValue = true，调用 removeNode() 的时候会判断
    return removeNode(hash(key), key, value, true, true) != null; 
}

replace()

@Override
public boolean replace(K key, V oldValue, V newValue) {
    Node e; V v;
    if ((e = getNode(hash(key), key)) != null &&
        ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) { // getNode 获取匹配的节点，匹配就修改返回 true，否则返回 false
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}

@Override
public V replace(K key, V value) {
    Node e;
    if ((e = getNode(hash(key), key)) != null) { // getNode 获取匹配的节点，匹配就修改返回 true，否则返回 false
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

clone() 浅克隆

/**
 * Returns a shallow copy of this HashMap instance: the keys and
 * values themselves are not cloned.
 *
 * @return a shallow copy of this map
 */
@SuppressWarnings("unchecked")
@Override
public Object clone() { // 调用方式 B = A.clone() 克隆 A 赋值给 B
    HashMap result;
    try {
        result = (HashMap)super.clone(); // 调用的就是 Object 的 clone()
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
    result.reinitialize(); // result 重新初始化
    result.putMapEntries(this, false); // 将 A 的键值对 put 到 result 里
    return result;
}

loadFactor() 和 capacity() 获取两个属性值

// These methods are also used when serializing HashSets
final float loadFactor() { return loadFactor; }
final int capacity() {
    return (table != null) ? table.length : // table 不为空容量就是 length
        (threshold > 0) ? threshold :
        DEFAULT_INITIAL_CAPACITY;
}

writeObject() 序列化和 readOject() 反序列化

/**
 * Save the state of the HashMap instance to a stream (i.e.,
 * serialize it).
 *
 * @serialData The capacity of the HashMap (the length of the
 *             bucket array) is emitted (int), followed by the
 *             size (an int, the number of key-value
 *             mappings), followed by the key (Object) and value (Object)
 *             for each key-value mapping.  The key-value mappings are
 *             emitted in no particular order.
 */
// 序列化
private void writeObject(java.io.ObjectOutputStream s)
    throws IOException {
    int buckets = capacity(); // 获取容量
    // Write out the threshold, loadfactor, and any hidden stuff
    s.defaultWriteObject(); // 设置 输出流
    s.writeInt(buckets); // 先写容量
    s.writeInt(size); // 再写大小
    internalWriteEntries(s); // 再遍历 HashMap 一个一个的序列化键值对，空位置不处理
}

// Called only from writeObject, to ensure compatible ordering.
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
    Node[] tab;
    if (size > 0 && (tab = table) != null) { // table 不为空
        for (int i = 0; i < tab.length; ++i) { // 遍历每个槽位
            for (Node e = tab[i]; e != null; e =  e.next) { // 遍历每个槽位上的键值对
                s.writeObject(e.key); // 写 key
                s.writeObject(e.value); // 写 value
            }
        }
    }
}

/**
 * Reconstitute the {@code HashMap} instance from a stream (i.e.,
 * deserialize it).
 */
// 反序列化
private void readObject(java.io.ObjectInputStream s)
    throws IOException, ClassNotFoundException {
    // Read in the threshold (ignored), loadfactor, and any hidden stuff
    s.defaultReadObject(); // 设置输入流
    reinitialize(); // 重新初始化
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new InvalidObjectException("Illegal load factor: " +
                                         loadFactor);
    // --- 读取 容量
    s.readInt();                // Read and ignore number of buckets
    // -- 读取元素个数
    int mappings = s.readInt(); // Read number of mappings (size)
    if (mappings < 0) // 没元素抛异常
        throw new InvalidObjectException("Illegal mappings count: " +
                                         mappings);
    else if (mappings > 0) { // (if zero, use defaults)
        // Size the table using given load factor only if within
        // range of 0.25...4.0
        float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
        float fc = (float)mappings / lf + 1.0f;
        // 计算容量
        int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                   DEFAULT_INITIAL_CAPACITY :
                   (fc >= MAXIMUM_CAPACITY) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor((int)fc));
        float ft = (float)cap * lf;
        // 计算 threshold
        threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                     (int)ft : Integer.MAX_VALUE);

        // Check Map.Entry[].class since it's the nearest public type to
        // what we're actually creating.
        SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
        @SuppressWarnings({"rawtypes","unchecked"})
        Node[] tab = (Node[])new Node[cap];
        table = tab;

        // Read the keys and values, and put the mappings in the HashMap
        // 遍历 size 次，每次读取一个 key 和 value，put 到 table 中
        for (int i = 0; i < mappings; i++) {
            @SuppressWarnings("unchecked")
                K key = (K) s.readObject();
            @SuppressWarnings("unchecked")
                V value = (V) s.readObject();
            putVal(hash(key), key, value, false, false);
        }
    }
}

ArrayList 源码精读笔记

2022-07-26T13:09:32.074Z

ArrayList 类属性

ArrayList 实现了 RandomAccess 接口，RandomAccess 接口没有内容只是一个标记，对于实现了 RandomAccess 接口的类支持通过索引/下标访问。

对于实现了 RandomAccess 接口的类使用 for 循环遍历效率高，没有实现的类尽量使用迭代器遍历

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import sun.misc.SharedSecrets;

/**
 * Resizable-array implementation of the List interface.  Implements
 * all optional list operations, and permits all elements, including
 * null.  In addition to implementing the List interface,
 * this class provides methods to manipulate the size of the array that is
 * used internally to store the list.  (This class is roughly equivalent to
 * Vector, except that it is unsynchronized.)
 *
 * The size, isEmpty, get, set,
 * iterator, and listIterator operations run in constant
 * time.  The add operation runs in amortized constant time,
 * that is, adding n elements requires O(n) time.  All of the other operations
 * run in linear time (roughly speaking).  The constant factor is low compared
 * to that for the LinkedList implementation.
 *
 * 
Each ArrayList instance has a capacity.  The capacity is
 * the size of the array used to store the elements in the list.  It is always
 * at least as large as the list size.  As elements are added to an ArrayList,
 * its capacity grows automatically.  The details of the growth policy are not
 * specified beyond the fact that adding an element has constant amortized
 * time cost.
 *
 * 
An application can increase the capacity of an ArrayList instance
 * before adding a large number of elements using the ensureCapacity
 * operation.  This may reduce the amount of incremental reallocation.
 *
 * 
Note that this implementation is not synchronized.
 * If multiple threads access an ArrayList instance concurrently,
 * and at least one of the threads modifies the list structurally, it
 * must be synchronized externally.  (A structural modification is
 * any operation that adds or deletes one or more elements, or explicitly
 * resizes the backing array; merely setting the value of an element is not
 * a structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the list.
 *
 * If no such object exists, the list should be "wrapped" using the
 * {@link Collections#synchronizedList Collections.synchronizedList}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the list:

 *   List list = Collections.synchronizedList(new ArrayList(...));
 *
 * 
 * The iterators returned by this class's {@link #iterator() iterator} and
 * {@link #listIterator(int) listIterator} methods are fail-fast:
 * if the list is structurally modified at any time after the iterator is
 * created, in any way except through the iterator's own
 * {@link ListIterator#remove() remove} or
 * {@link ListIterator#add(Object) add} methods, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of
 * concurrent modification, the iterator fails quickly and cleanly, rather
 * than risking arbitrary, non-deterministic behavior at an undetermined
 * time in the future.
 *
 * 
Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.  Fail-fast iterators
 * throw {@code ConcurrentModificationException} on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness:  the fail-fast behavior of iterators
 * should be used only to detect bugs.
 *
 * 
This class is a member of the
 * @docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework.
 *
 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see     Collection
 * @see     List
 * @see     LinkedList
 * @see     Vector
 * @since   1.2
 */

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable
{ // 实现了 RandomAccess 接口支持随机访问，实现了 Cloneable 接口，是浅克隆的，实现了序列化接口 Serializable
    // 每次用于网络传输的类都需要生成了随机序列化，是书写规范，如果不写其实也会自动加上
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10; // 默认容量

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {}; // 初始化空数组

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 和 EMPTY_ELEMENTDATA 做区分

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    // 真正存放数据的数组，transient 防止进行序列化，既然元素不支持序列化，那么类上为什么又实现了 Serilizable 接口呢
    // 这里是自己重写了序列化方法，节省了 50% 序列化的空间
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    // ArrayList 中包含的元素个数
    private int size;

    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    // 带初始容量的构造器
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    // 空参构造期
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    // ...
    
    
}

add(E e) 以及扩容机制

当我们初始化一个容量为 0 的 ArrayList 的容量 ArrayList list = new ArrayList<>(0);

如果往集合中添加 10 个元素，则会扩容 7 次。这样做的效率非常低

所以如果我们知道需要多大的容量，则尽量在初始化的时候指定具体的容量，否则可以使用默认构造器，避免使用 0 参数。

List list = new ArrayList<>(0);
list.add("a"); // 第 1 次 add
list.add("b"); list.add("c"); list.add("d"); list.add("e"); 
list.add("f"); list.add("g"); list.add("h");list.add("i");
list.add("j"); // 第 10 次 add

下面时执行流程：

执行带参数构造器，创建 ArrayList 对象

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) { // 如果初始容量大于 0，则直接创建一个 initialCapacity 的 Object 数组赋值给 elementData
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) { // 如果初始容量为 0 走这里，将 EMPTY_ELEMENTDATA 赋值给 elementData
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

首先执行第一步 add(E e)

/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return true (as specified by {@link Collection#add})
 */
public boolean add(E e) {
    // 1. 确保内部容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 2. 添加元素到 elementData 中，同时 size + 1
    elementData[size++] = e;
    return true;
}

确保内部容量

private void ensureCapacityInternal(int minCapacity) {
    // 1. 先计算容量大小 calculateCapacity(elementData, minCapacity)
    // 2. 确保具体容量
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 判断 elementData 是不是 默认容量空数组（和空数组 EMPTY_ELEMENTDATA 做区分）
        return Math.max(DEFAULT_CAPACITY, minCapacity); // 是的话，返回当前容量为 默认容量 和 用户自己传入的最小容量 的最大值
    }
    return minCapacity; // 走这里，否则返回 用户自己传入的最小容量
}

确保具体容量

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 首先并发修改数 + 1，定义在 AbstractList 中，protected transient int modCount = 0; 用于是否出现了判断修改

    // overflow-conscious code
    // 如果我们传入的最小容量 - elementData 数组长度 > 0，则进行扩容
    if (minCapacity - elementData.length > 0)
        // 扩容方法
        grow(minCapacity);
}

扩容

/**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    // 旧容量
    int oldCapacity = elementData.length;
    // 新容量，扩容为旧容量的 近似 1.5 倍【注意】
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 扩容之后的新容量还是 小于 我们传入的最小容量，那把 minCapacity 作为我们的新容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果 新容量 大于 最小数组大小（int 最大值 - 8），那么执行 hugeCapacity(minCapacity); 扩容为 int 最大值
    if (newCapacity - MAX_ARRAY_SIZE > 0) // Integer.MAX_VALUE - 8;
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 开辟新数组，并将原数组的内容拷贝到新数组中，最后再赋值给 elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

最大化扩容

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    // 如果我们传入的最小容量 大于 最大数组大小，就扩容为 int 最大值
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

当我们使用空参构造器时，ArrayList list = new ArrayList<>();

List list = new ArrayList<>();
list.add("a"); // 第 1 次 add
list.add("b"); list.add("c"); list.add("d"); list.add("e"); 
list.add("f"); list.add("g"); list.add("h");list.add("i");
list.add("j"); // 第 10 次 add

执行空参构造器，创建 ArrayList 对象

/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // DEFAULTCAPACITY_EMPTY_ELEMENTDATA 赋值给 elementData
}

执行第一步 add(E e)

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

确保内部容量

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 走这里
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 判断 elementData 是不是 默认容量空数组（和空数组 EMPTY_ELEMENTDATA 做区分）
        return Math.max(DEFAULT_CAPACITY, minCapacity); // 是的话，返回当前容量为 默认容量 和 用户自己传入的最小容量 0 + 1 的最大值，那么就是 10
    }
    return minCapacity; // 否则返回 用户自己传入的最小容量
}

确保具体容量
然后执行一次扩容，扩容为 10，可以容量 10 个数，所以只会进行一次扩容

关于创建 ArrayList 的几种方式常见问题

第一种：new 对象，调用 ArrayList 的构造器，这个没啥说法

第二种：调用 Arrays 工具类的 asList() 方法，可以初始化一个 List

1 2	List list2 = Arrays.asList("a", "b", "c"); // 创建方式没有问题 list2.add("d"); // 但是不能调用 add() 方法，为什么？

为什么通过 Arrays 创建的 List 不能调用 add 方法呢？同时 remove() 方法也不能调用。

下面看源码：

asList() 方法

1
2
3

public static  List asList(T... a) {
    return new ArrayList<>(a);
}

ArrayList 的构造器

/**
 * @serial include
 */
private static class ArrayList extends AbstractList
    implements RandomAccess, java.io.Serializable
{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }
    
    // ...
    
}

发现调用的是 Arrays 类自己创建的内部类 ArrayList 的构造器，而这个 ArrayList 中并没有重写 add() 方法，虽然它继承了 AbstractList 抽象类，但是 AbstractList 中的抽象类的 add() 方法的默认实现是直接抛异常，同理 remove() 方法也没有重写，继承抽奖类的也是直接抛异常，而 get()、set() 获取和修改可以使用，原因就是重写了对应方法。

public boolean add(E e) {
    add(size(), e);
    return true;
}

public void add(int index, E element) {
    // 添加直接抛异常
    throw new UnsupportedOperationException();
}

public E remove(int index) {
    // 删除直接抛异常
    throw new UnsupportedOperationException();
}

那什么时候会用这种方式创建 List 呢？

当我们使用固定大小的 List 且不做增加和删除，只做修改的时候可以使用这种方式。

第三种：调用 Collections 工具类的 emptyList() 方法，初始化一个空的 List【基本不用】

1 2	ArrayList list = Collections.emptyList(); // 创建一个 EmptyList，空的 List list.add("a"); // 不能调用 add() 方法

不能调用 add() 的原因和第二种方式的原因时类似的

看源码：

emptyList() 方法，直接返回一个 EMPTY_LIST

public static final  List emptyList() {
    return (List) EMPTY_LIST;
}

public static final List EMPTY_LIST = new EmptyList<>();

再看 EmptyList 类

/**
  * @serial include
  */
private static class EmptyList
    extends AbstractList
    implements RandomAccess, Serializable {
    private static final long serialVersionUID = 8842843931221139166L;

    public Iterator iterator() {
        return emptyIterator();
    }
    public ListIterator listIterator() {
        return emptyListIterator();
    }

    public int size() {return 0;}
    public boolean isEmpty() {return true;}

    // ...

}

它也是一个内部类，同样的继承了 AbstractList，但是没有重写 add()、set()、remove()，所以无法添加元素，什么都不能干，还真就是一个空的 List，没什么用。

使用场景？

当我们代码中要返回空 List 的时候才会用到，public static final List EMPTY_LIST = new EmptyList<>(); 在 javac 编译成 class 文件的时候就已经初始化了，比 new ArrayList() 每次返回空 List 要好，因为不需要重新创建对象。

trimToSize()

剪切 ArrayList 让它的容量变成 size，将没有元素的位置删掉，底层还是 Arrays.copy()

/**
     * Trims the capacity of this ArrayList instance to be the
     * list's current size.  An application can use this operation to minimize
     * the storage of an ArrayList instance.
     */
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
            ? EMPTY_ELEMENTDATA
            : Arrays.copyOf(elementData, size);
    }
}

contains(Object o)、indexOf(int index)、lastIndexOf(int index)

contains(Object o) 源码

/**
     * Returns true if this list contains the specified element.
     * More formally, returns true if and only if this list contains
     * at least one element e such that
     * (o==null ? e==null : o.equals(e)).
     *
     * @param o element whose presence in this list is to be tested
     * @return true if this list contains the specified element
     */
public boolean contains(Object o) {
    return indexOf(o) >= 0; // 这里调用 indexOf(o)，判断返回索引是否 大于等于 0，如果是则包含，否则不包含
}

indexOf(int index) 源码

/**
     * Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))),
     * or -1 if there is no such index.
     */
public int indexOf(Object o) {
    if (o == null) { // 如果是空，遍历等于空的位置，找到第一个返回
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else { // 如果不是空，同样是 for 循环遍历，找到第一个返回
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1; // 找不到返回 -1
}

lastIndexOf(int index) 源码

/**
     * Returns the index of the last occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the highest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))),
     * or -1 if there is no such index.
     */
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

clone()

ArrayList 的克隆方法，用的是父类 Object 的 clone() 方法，所以是浅拷贝，只拷贝值，不创建对象。

/**
     * Returns a shallow copy of this ArrayList instance.  (The
     * elements themselves are not copied.)
     *
     * @return a clone of this ArrayList instance
     */
public Object clone() {
    try {
        ArrayList v = (ArrayList) super.clone(); // 调用父类 clone()
        v.elementData = Arrays.copyOf(elementData, size); // Arrays.copy 拷贝
        v.modCount = 0; // 克隆之后认为是一个新的 ArrayList，没有被修改过
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

toArray()

/**
     * Returns an array containing all of the elements in this list
     * in proper sequence (from first to last element).
     *
     * The returned array will be "safe" in that no references to it are
     * maintained by this list.  (In other words, this method must allocate
     * a new array).  The caller is thus free to modify the returned array.
     *
     * 
This method acts as bridge between array-based and collection-based
     * APIs.
     *
     * @return an array containing all of the elements in this list in
     *         proper sequence
     */
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

// 泛型实现 T 是类型，E 是元素，U 是
public  T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    // 调用的也是 System.arraycopy
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Arrays.copy()

public static  T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static  T[] copyOf(U[] original, int newLength, Classextends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    // 真正执行 copy 的是这句话，System.arraycopy
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

// native 实现，底层可能是 C++ 写的
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

get(index)

对通过下标取数组元素做的一个封装 elementData(index)

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index]; // 底层还是数组访问
}

get(index)

/**
     * Returns the element at the specified position in this list.
     *
     * @param  index index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
public E get(int index) {
    rangeCheck(index); // 索引范围检查，不合法抛出下标越界异常

    return elementData(index); // 返回索引对应的值
}

/**
     * Checks if the given index is in range.  If not, throws an appropriate
     * runtime exception.  This method does *not* check if the index is
     * negative: It is always used immediately prior to an array access,
     * which throws an ArrayIndexOutOfBoundsException if index is negative.
     */
private void rangeCheck(int index) {
    if (index >= size) // 索引不合法抛出 IndexOutOfBoundsException 异常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

set(index)

/**
     * Replaces the element at the specified position in this list with
     * the specified element.
     *
     * @param index index of the element to replace
     * @param element element to be stored at the specified position
     * @return the element previously at the specified position
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
public E set(int index, E element) {
    rangeCheck(index); // 索引范围检查

    E oldValue = elementData(index); // 先获取旧值
    elementData[index] = element; // 再赋新值
    return oldValue; // 返回旧值
}

add(index, E) 插入

每插入一次都会触发一次 arraycopy 数组移动，O(n) 的复杂度，比较耗费性能。

/**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
public void add(int index, E element) {
    rangeCheckForAdd(index); // 插入索引范围检查

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index); // [index, size) 往后移动一位
    elementData[index] = element; // 插入到 index 位置上
    size++; // 容量 + 1
}

/**
     * A version of rangeCheck used by add and addAll.
     */
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0) // 插入索引范围检查，这里有一个优化的地方：把常用的判断条件放前边，提高性能
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

/**
     * Constructs an IndexOutOfBoundsException detail message.
     * Of the many possible refactorings of the error handling code,
     * this "outlining" performs best with both server and client VMs.
     */
private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size; // 对于短字符串用 + 号最快，对于大量字符串拼接用 StringBuilder
}

remove(int index)、remove(Object o)

/**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).
     *
     * @param index the index of the element to be removed
     * @return the element that was removed from the list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
// 根据索引删除
public E remove(int index) {
    rangeCheck(index); // 索引范围检查

    modCount++; // 修改次数 + 1
    E oldValue = elementData(index); // 先获取旧值用于返回

    int numMoved = size - index - 1; // numMoved 是删除 index 上的数后需要移动的元素的个数
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved); // 又是一个 arraycopy
    elementData[--size] = null; // clear to let GC do its work，容量 - 1 并且最后一个元素指向空，表示不可达，等待下次垃圾回收

    return oldValue;
}

/**
     * Removes the first occurrence of the specified element from this list,
     * if it is present.  If the list does not contain the element, it is
     * unchanged.  More formally, removes the element with the lowest index
     * i such that
     * (o==null ? get(i)==null : o.equals(get(i)))
     * (if such an element exists).  Returns true if this list
     * contained the specified element (or equivalently, if this list
     * changed as a result of the call).
     *
     * @param o element to be removed from this list, if present
     * @return true if this list contained the specified element
     */
// 删除指定对象，如果有多个，删除第一个
public boolean remove(Object o) { // 这里和 contains(Object o) 实现类似
    // for 循环遍历，找到第一个相等的元素删除
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index); // 这里调用 fastRemove() 方法进行删除当前元素
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

/*
     * Private remove method that skips bounds checking and does not
     * return the value removed.
     */
// 发现和 remove(index) 思路一样啊，也是 arraycopy 移动元素，
// 然名字是 fastRemove() 但是实现上并没有变快，就是一个名字而已，因为要多次调用，所以抽取成了一个方法
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

clear()

/**
     * Removes all of the elements from this list.  The list will
     * be empty after this call returns.
     */
// 清空 List
public void clear() {
    modCount++; // 清空也是一次修改

    // 将每个元素置空，等待 GC 回收
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0; // size 置为 0
}

延伸：下面这段代码扩容几次？

List list = new ArrayList<>();
list.add("a"); 
list.clear();
list.add("a");

答案：扩容 1 次，创建空的 ArrayList()，第一次添加元素会进行 1 次扩容，扩容为 10，然后 clear() 清空 List 之后，只是把数组中的元素个数 size 置为 0，再次添加此时 elementData 数组的长度还是 10，所以不会执行扩容。

所以当我们还要复用这个 List 的时候，就可以使用 clear()，而不建议使用 new ArrayList() 的方式，因为它每次会进行一次扩容。

addAll(Collection c)、addAll(int index, Collection c)

/**
     * Appends all of the elements in the specified collection to the end of
     * this list, in the order that they are returned by the
     * specified collection's Iterator.  The behavior of this operation is
     * undefined if the specified collection is modified while the operation
     * is in progress.  (This implies that the behavior of this call is
     * undefined if the specified collection is this list, and this
     * list is nonempty.)
     *
     * @param c collection containing elements to be added to this list
     * @return true if this list changed as a result of the call
     * @throws NullPointerException if the specified collection is null
     */
// 向 List 中添加一个 List
public boolean addAll(Collection c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保内部容量
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew); // 数组拷贝，把 a 数组放到 elementData 数组后面
    size += numNew; // 元素个数 + numNew
    return numNew != 0; // 如果不是 0 就可以添加成功
}

/**
     * Inserts all of the elements in the specified collection into this
     * list, starting at the specified position.  Shifts the element
     * currently at that position (if any) and any subsequent elements to
     * the right (increases their indices).  The new elements will appear
     * in the list in the order that they are returned by the
     * specified collection's iterator.
     *
     * @param index index at which to insert the first element from the
     *              specified collection
     * @param c collection containing elements to be added to this list
     * @return true if this list changed as a result of the call
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @throws NullPointerException if the specified collection is null
     */
// 向 List 的某个位置上插入一个 List
public boolean addAll(int index, Collection c) {
    rangeCheckForAdd(index); // 插入索引范围检查

    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保内部容量
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index; // 要往后移动的元素个数
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved); // arraycopy 移动数组

    System.arraycopy(a, 0, elementData, index, numNew); // 将 a 数组插入到 index 位置上
    size += numNew; // 更新 size
    return numNew != 0; // true or false
}

延伸：向一个空的 List 中添加一个空的 List，以下代码输出是什么？

1
2
3

List list = new ArrayList<>();
List list2 = new ArrayList<>();
System.out.println(list.addAll(list2));

答案：false，添加的时候执行第一句话 c.toArray()，返回的 a 就是一个空数组（toArray() 方法转换的时候看的是 size 而不是数组的 length，size = 0, length = 10），所以 a.length = 0，那么最后返回的就是 false。

public Object[] toArray() {
    return Arrays.copyOf(elementData, size); // size = 0
}

public static  T[] copyOf(T[] original, int newLength) { // newLength = 0
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static  T[] copyOf(U[] original, int newLength, Classextends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength)); // newLength = 0 
    return copy;
}

removeRange(fromIndex, toIndex)

/**
     * Removes from this list all of the elements whose index is between
     * {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
     * Shifts any succeeding elements to the left (reduces their index).
     * This call shortens the list by {@code (toIndex - fromIndex)} elements.
     * (If {@code toIndex==fromIndex}, this operation has no effect.)
     *
     * @throws IndexOutOfBoundsException if {@code fromIndex} or
     *         {@code toIndex} is out of range
     *         ({@code fromIndex < 0 ||
     *          fromIndex >= size() ||
     *          toIndex > size() ||
     *          toIndex < fromIndex})
     */
// 范围删除
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex; // 要移动的元素个数
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved); // 将 [toIndex, size) 拷贝到从 fromIndex 开始

    // clear to let GC do its work
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) { // 删除后面的元素
        elementData[i] = null;
    }
    size = newSize; // 更新 size
}

removeAll(Collection c)

/**
     * Removes from this list all of its elements that are contained in the
     * specified collection.
     *
     * @param c collection containing elements to be removed from this list
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException if the class of an element of this list
     *         is incompatible with the specified collection
     * (optional)
     * @throws NullPointerException if this list contains a null element and the
     *         specified collection does not permit null elements
     * (optional),
     *         or if the specified collection is null
     * @see Collection#contains(Object)
     */
// 从 List 中删除集合 c 中的所有元素
public boolean removeAll(Collection c) {
    Objects.requireNonNull(c); // 判断是否为空，调用的是 Object 的方法
    return batchRemove(c, false); // 批量删除
}

// Object.class
public static  T requireNonNull(T obj) {
    if (obj == null) // 只判断了是否为 null，没有判断空 List
        throw new NullPointerException();
    return obj;
}

private boolean batchRemove(Collection c, boolean complement) {
    final Object[] elementData = this.elementData; // 复制一份 elementData
    int r = 0, w = 0; // 定义两个指针
    boolean modified = false;
    try {
        // complement = false，所以 for 循环的含义就是将不在 c 集合中的元素放到数组的前面，并且记录个数 w
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) { // 正常情况下上面循环执行结束 r = size
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) { // w == size 表示 elementData 全删
            // clear to let GC do its work
            for (int i = w; i < size; i++) // 将 [w, size) 后面的元素全部删掉
                elementData[i] = null;
            modCount += size - w; // 更新 modCount
            size = w; // 更新 size
            modified = true; // 修改成功
        }
    }
    return modified;
}

writeObject(java.io.ObjectOutputStream s)、readObject(java.io.ObjectInputStream s) 序列化和反序列化

序列化：

我们的 elementData transient Object[] elementData; // non-private to simplify nested class access 是被 transient 修饰的，所以不能被序列化，那具体是怎么序列化的呢，同时这样做的好处是什么？
看源码之后发现，是通过 for 循环 elementData 数组中的元素，对每个元素进行序列化，我不对整个数组序列化，因为 elementData 的容量通常情况下是比 size 大的，扩容的时候每次大约 1.5 倍，那么就有 1 / 3 的空间是空的，空的数据没必要序列化。
好处：1. 不浪费序列化的内容 2. 无需考虑 null 序列化的问题，因为有的序列化方式序列化 null 会报错

/**
 * Save the state of the ArrayList instance to a stream (that
 * is, serialize it).
 *
 * @serialData The length of the array backing the ArrayList
 *             instance is emitted (int), followed by all of its elements
 *             (each an Object) in the proper order.
 */
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount; // 将 modCount 存一份，用于判断在 List 序列化的过程中是否有其他线程进行了修改
    s.defaultWriteObject(); // 对 ObjectOutputStream 做一个初始化

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size); // 先把 size 序列化

    // Write out all elements in the proper order.
    for (int i=0; i// for 循环序列每个元素，这里太妙了！！！
        s.writeObject(elementData[i]);
    }

    // 最后判断是否有并发修改异常，如果出现异常则序列化失败
    // 那么如果有修改，序列化就白做了，但其实这也符合实际场景：一切对于我们的 list 的业务上的修改级别高于序列化。
    if (modCount != expectedModCount) { 
        throw new ConcurrentModificationException();
    }
}

/**
 * Reconstitute the ArrayList instance from a stream (that is,
 * deserialize it).
 */
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored // 先读取 List 的大小

    if (size > 0) { // 如果有数据再反序列化
        // be like clone(), allocate array based upon size not capacity
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size); // 先保证容量

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i// 每次读一个对象存到 elementData 中
            a[i] = s.readObject();
        }
    }
}

迭代器相关

TODO

剑指 Offer 63. 股票的最大利润

2022-07-09T01:56:19.202Z

题目描述

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

1
2
3

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

限制：

$0 <= 数组长度 <= 10^5$

注意： 本题与主站 121 题相同：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/

算法

(贪心,线性扫描) $O(n)$

$minv$ 表示前 $i - 1$ 天中的买入的最低价格，假设初始值为 $prices[0]$，定义变量 $res$ 表示利润
从第二天开始枚举，计算并更新利润 $res$，更新 $minv$

时间复杂度

$O(n)$

空间复杂度

$O(1)$

代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.empty()) return 0;
        int minv = prices[0], res = 0;
        for (int i = 1; i < prices.size(); i ++ ) {
            res = max(res, prices[i] - minv);
            minv = min(minv, prices[i]);
        }
        return res;
    }
};

剑指 Offer 60. n个骰子的点数

2022-07-09T01:53:53.601Z

题目描述

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。

你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

示例 1:

1 2	输入: 1 输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]

示例 2:

1 2	输入: 2 输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

限制：

$1 <= n <= 11$

算法

(动态规划) $O(n^2)$

状态表示：f[i][j]，表示投 $i$ 次总和为 $j$ 的方案数
状态计算：按照第 $i$ 次投掷的点数为 $1，2，3，4，5，6$ 划分成六个集合
假设第 $i$ 次投掷的点数为 $k$，则状态转移方程为 $f[i][j] = f[i - 1][j - k]$，对于每种情况计算方案数，最后求和。

边界：

初始值：$f[0][0] = 1$，由 $f[1][1] = 1$ 可以推出
答案：$f[n][n]、f[n][2n]、…、f[n][6n]$，分别除以总方案数 $6^n$，最后就是每种和出现的概率值。

时间复杂度

状态数量有 $6n^2$ 个，状态转移时间为 $O(1)$，所以时间复杂度为 $O(n^2)$。
状态数量 * 状态转移所需时间 = $n^2 * O(1)$ = $O(n^2)$。

空间复杂度

$O(n^2)$

C++ 代码

class Solution {
public:
    vector<double> dicesProbability(int n) {
        vectorint>> f(n + 1, vector<int>(6 * n + 1));
        f[0][0] = 1;

        for (int i = 1; i <= n; i ++ ) // 骰子个数
            for (int j = i * 1; j <= i * 6; j ++ ) // 第 i 个骰子投出后可能出现的总和
                for (int k = 1; k <= 6; k ++ ) // 按照 6 个点进行划分集合
                    if (k <= j)
                        f[i][j] += f[i - 1][j - k]; // 状态转移

        vector<double> res;           
        double tot = pow(6.0, n);
        for (int i = n; i <= 6 * n; i ++ ) res.push_back(f[n][i] / tot); // 求每种和的概率
        return res;
    }
};

剑指 Offer 47. 礼物的最大价值

2022-07-09T01:53:17.221Z

题目描述

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

示例 1:

输入: 
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

提示：

$0 < grid.length <= 200$
$0 < grid[0].length <= 200$

算法

(动态规划) $O(n^2)$

状态表示：$f[i][j]$，表示走到第 $(i, j)$ 这个格子时能拿到礼物的最大价值

状态计算：
每次只能向右或向下走，所以只能从左边或上边到达 $(i, j)$

左边，f[i][j] = f[i][j - 1]
右边，f[i][j] = f[i - 1][j]

两者取 $max$

边界：f[n][m] 就是答案

时间复杂度

状态数量 $n^2$ 个，状态转移所需时间是 $O(1)$，所以总时间复杂度为 $O(n^2)$

空间复杂度

$O(n^2)$

C++ 代码

class Solution {
public:
    int maxValue(vectorint>>& grid) {
        // n 是行 m 是列
        int n = grid.size(), m = grid[0].size();
        vectorint>> f(n + 1, vector<int>(m + 1));

        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
                f[i][j] = max(f[i - 1][j], f[i][j - 1]) + grid[i - 1][j - 1];
        
        return f[n][m];
    }
};

剑指 Offer 46. 把数字翻译成字符串

2022-07-09T01:52:44.915Z

题目描述

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

1
2
3

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"

提示：

$0 <= num < 2^{31}$

算法

(动态规划) $O(n)$

状态表示：$f[i]$，表示将前 $i$ 个数字翻译成字符串的方案数
状态计算

将当前数字翻译成单个字母，此时 $f[i]$ 等于将前 $i - 1$ 个数字翻译成字符串的方案数，f[i] = f[i - 1]
如果当前数字和前一个数字构成的两位数 $val$ 满足 $10 <= val <= 25$，则可以将前一个数字和当前数字翻译成一个字母，此时 $f[i]$ 等于将前 $i - 2$ 个数字翻译成字符串的方案数，f[i] = f[i - 2]

边界

f[0] = 1，0 个数字方案数为 1，可以通过 $f[1]$ 推出，$1$ 个数字的翻译方式只有一种（将当前数字翻译成单个字母），所以由 f[i] = f[i - 1] 知 f[0] = 1。
$f[n]$ 就是答案

注意：枚举字符串时 $i$ 从 $1$ 开始，所以下标应该往前移一位，即第 $i$ 个字符 $s[i - 1]$。

时间复杂度

整个字符串被遍历一次，所以时间复杂度为 $O(n)$

空间复杂度

$O(n)$

C++ 代码

class Solution {
public:
    int translateNum(int num) {
        string s = to_string(num);
        int n = s.size();
        vector<int> f(n + 1);
        f[0] = 1;
        for (int i = 1; i <= n; i ++ ) {
            f[i] = f[i - 1];
            if (i >= 2) {
                int val = (s[i - 2] - '0') * 10 + (s[i - 1] - '0');
                if (val >= 10 && val <= 25)
                    f[i] += f[i - 2];
            }
        }
        return f[n];
    }
};

剑指 Offer 42. 连续子数组的最大和

2022-07-09T01:52:15.065Z

题目描述

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

示例1:

1
2
3

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

提示：

$1 <= arr.length <= 10^5$
$-100 <= arr[i] <= 100$

注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/

算法

(动态规划,DP)) $O(n)$

状态表示：$f[i]$ 表示以 $nums[i]$ 结尾的连续子数组的最大和
状态计算：

包含 $nums[i]$，$f[i] = f[i - 1] + nums[i]$
以 $nums[i]$ 开始，$f[i] = nums[i]$

$f[i]$ 两者取最大值

最后遍历 $f$ 数组取最大值

时间复杂度

$O(n)$

空间复杂度

$O(n)$

C++ 代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n + 1);
        int res = INT_MIN;
        for (int i = 1; i <= n; i ++ ) {
            f[i] = max(f[i - 1] + nums[i - 1], nums[i - 1]);
            res = max(res, f[i]);
        }
        return max(res, nums[0]);
    }
};

剑指 Offer 19. 正则表达式匹配

2022-07-09T01:50:54.887Z

题目描述

请实现一个函数用来匹配包含$’. ‘$和$’‘$的正则表达式。模式中的字符$’.’$表示任意一个字符，而$’‘$表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串$”aaa”$与模式$”a.a”$和$”abaca”$匹配，但与$”aa.a”$和$”ab*a”$均不匹配。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

$s$ 可能为空，且只包含从 $a-z$ 的小写字母。
$p$ 可能为空，且只包含从 $a-z$ 的小写字母以及字符 $.$ 和 $$，无连续的 $’‘$。

注意：本题与主站 10 题相同：https://leetcode-cn.com/problems/regular-expression-matching/

算法

(动态规划) $O(n^2)$

状态表示：$s$ 的前 $i$ 个字母 s[1~i] 和 $p$ 的前 $j$ 个字母是否匹配（下标从 $1$ 开始比较方便）
状态计算：根据 p[j + 1] 是否为 * 分情况讨论，因为如果 p[j +1] = * 时那么 p[j-j+1] 是一个整体。（$*$ 表示前面的一个字符可以出现任意多次）

特判：如果 $p[j + 1]$ 是 $*$ 的话那么不处理当前字符 $p[j]$，continue，将它们作为一个整体处理，

如果当前字符 $p[j]$ 不是 *，则 f[i][j] = true 当且仅当 s[1~i-1] 和 p[1~j-1] 匹配且 s[i] 和 p[j] 匹配（或者 p[j] == '.' 也是匹配的）f[i][j] = f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.');
如果当前字符 $p[j]$ 是 *，则遍历 $*$ 号前面的字符出现从 $0$ 次到任意多次与 $s[i]$ 进行匹配。f[i][j] = f[i][j - 2] || (i && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));，这里经过了状态转移优化，这个优化类似于完全背包优化，都是用 f[i - 1][j] 替换了除出现 $0$ 次以外的循环遍历。

时间复杂度

$O(n^2)$

空间复杂度

$O(n^2)$

C++ 代码

class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size(), m = p.size();
        s = ' ' + s, p = ' ' + p;
        vectorbool>> f(n + 1, vector<bool>(m + 1));

        // 两个空串匹配
        f[0][0] = true;
        // i 从 0 开始，因为 s[i] 是空串的时候可能会和 p[j] 匹配成功（当 j + 1 是 *，可以表示 p[j] 出现 0 次，此时两个串匹配成功）
        for (int i = 0; i <= n; i ++ ) {
            // j 从 1 开始，i = 0、j = 0 已经初始化过了，而对于 i != 0、j = 0，空串都不会匹配成功
            for (int j = 1; j <= m; j ++ ) {
                // 如果 p[j] 的下一个字符是 * 就不处理当前字符，因为 p[j] 和 * 在一块才能整体才能表示一个含义
                if (j + 1 <= m && p[j + 1] == '*') continue;
                // p[j + 1] 不是 *，那就看 f[i - 1][j - 1] 是否匹配且当前字符是否匹配
                if (i && p[j] != '*') {
                    f[i][j] = f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.');
                } else if (p[j] == '*') {
                    // 与 0 个第 j - 1 个字母匹配 || 【1 个 || 2 个 ... 进行了状态转移优化（完全背包优化）】
                    f[i][j] = f[i][j - 2] || (i && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));
                }
            }
        }

        return f[n][m];
    }
};

剑指 Offer 38. 字符串的排列

2022-07-09T01:49:24.382Z

题目描述

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例:

1 2	输入：s = "abc" 输出：["abc","acb","bac","bca","cab","cba"]

限制：

$1 <= s 的长度 <= 8$

算法

(回溯) $O(n! * n)$

和 46. 全排列的唯一区别就是这道题目存在重复答案，所以需要去重，去重的思路首先将数组排序，让相同的数相邻，如果当前数等于前一个数且前一个数没有被使用过，则跳过当前数，继续查找下一个要放在当前位置上的数，始终保证排列后的序列相同数的相对顺序不变。

时间复杂度

全排列总共有 $A^n_n$ 种方案，即 $n!$，记录每种方案需要 $O(n)$ 的时间，所以总时间复杂度为 $O(n!*n)$。

空间复杂度

额外空间复杂度 $O(n)$

C++ 代码

class Solution {
public:
    vector res;
    string path;
    vector<bool> st;

    void dfs(int u, string& s) {
        if (u == s.size()) {
            res.push_back(path);
            return;
        }

        for (int i = 0; i < s.size(); i ++ ) {
            // 如果当前数等于前一个数且前一个数没用过，则使用前一个数
            if (i && !st[i - 1] && s[i - 1] == s[i]) continue;
            if (!st[i]) {
                path += s[i];
                st[i] = true;
                dfs(u + 1, s);
                st[i] = false;
                path.pop_back();
            }
        }
    }

    vector permutation(string s) {
        sort(s.begin(), s.end());
        st = vector<bool>(s.size());
        dfs(0, s);
        return res;
    }
};

剑指 Offer 13. 机器人的运动范围

2022-07-09T01:48:24.912Z

题目描述

地上有一个m行n列的方格，从坐标 $[0,0]$ 到坐标 $[m-1,n-1]$ 。一个机器人从坐标 $[0, 0]$ 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

示例 1：

1 2	输入：m = 2, n = 3, k = 1 输出：3

示例 2：

1 2	输入：m = 3, n = 1, k = 0 输出：1

提示：

$1 <= n,m <= 100$
$0 <= k <= 20$

算法

(BFS)) $O(nm)$

$BFS$ 搜索所有可以到达的格子，初始状态将起点加入队列中，如果队列不为空，则弹出队头作为新的起点，如果当前点可以走，则枚举四个方向扩展下一层，将所有没有越界的点加入队列中，直到队列为空所有点就都被遍历完了。

哪些点可以走呢？

没有走过的点
当前点横纵坐标每位之和小于等于 $k$

时间复杂度

最坏情况下每个点都会被遍历一次，所以时间复杂度为 $O(nm)$。

空间复杂度

$O(nm)$

C++ 代码

class Solution {
public:
    int get(int x) {
        int res = 0;
        while (x) {
            res += x % 10;
            x /= 10;
        }
        return res;
    }

    int movingCount(int m, int n, int k) {
        vectorbool>> st(m, vector<bool>(n, false));
        int res = 0;

        queueint, int>> q;
        q.push({0, 0});

        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
        while (q.size()) {
            auto t = q.front();
            q.pop();
            
            int x = t.first, y = t.second;
            if (st[x][y] || get(x) + get(y) > k) continue;

            res ++ ;
            st[x][y] = true;

            for (int i = 0; i < 4; i ++ ) {
                int a = x + dx[i], b = y + dy[i];
                if (a < 0 || a >= m || b < 0 || b >= n) continue;
                q.push({a, b});
            }
        }

        return res;
    }
};

剑指 Offer 58 - I. 翻转单词顺序

2022-07-09T01:41:52.878Z

题目描述

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串”I am a student. “，则输出”student. a am I”。

示例 1：

1 2	输入: "the sky is blue" 输出: "blue is sky the"

示例 2：

1
2
3

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

1
2
3

输入: "a good   example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

注意： 本题与主站 151 题相同：https://leetcode-cn.com/problems/reverse-words-in-a-string/

注意： 此题对比原题有改动

算法

(字符串翻转) $O(n)$

使用双指针算法先翻转每个单词
然后翻转整个字符串

但在字符串的开头、中间、结尾都可能会有空格，我们需要把这三部分多余的空格去掉，只保留每个单词之间的空格。而且题目要求使用 $O(1)$ 的空间完成，所以只能复用字符串，用一个指针 $k$ 从前往后存储有效的字符部分，翻转结束后 $k$ 后面多余的字符都删掉。

$[i, j]$ 单词部分放到 $[k, t]$ 位置上

时间复杂度

整个字符串需要被扫描两遍，所以时间复杂度为 $O(n)$

空间复杂度

$O(1)$

代码

class Solution {
public:
    string reverseWords(string s) {
        int k = 0;
        for (int i = 0; i < s.size(); i ++ ) {
            if (s[i] == ' ') continue;
            // k 指向单词的开头，t 指向这个单词末尾的下一个位置
            int j = i, t = k;
            while (j < s.size() && s[j] != ' ') s[t ++ ] = s[j ++ ];
            // 翻转单词 $s[k]~s[t - 1]$
            reverse(s.begin() + k, s.begin() + t);
            s[t ++ ] = ' ';
            i = j, k = t;
        }
        // 翻转结束后 k 指向的是下一个单词的开头，现在让它指向前一个位置的空格
        if (k) k -- ;
        // 删除空格以及下标 k 后面的字符
        s.erase(s.begin() + k, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

剑指 Offer 48. 最长不含重复字符的子字符串

2022-07-09T01:40:51.626Z

题目描述

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

1
2
3

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

1
2
3

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

$s.length <= 40000$

注意：本题与主站 3 题相同：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

算法

(哈希表，双指针算法) $O(n)$

用哈希表存储每个字符出现的次数，且保证区间 $[i, j]$ 内没有重复元素，每个字符只出现一次；$res$ 记录答案。

双指针扫描字符串

每次将 $s[i]$ 加入到哈希表中
如果 $s[i]$ 出现的次数超过 1，说明在 $[j, i - 1]$ 中有重复元素，此时移动 $j$ 指针直到区间 $[j, i]$ 中没有重复元素为止。
计算区间长度即当前不含重复字符的字符串的长度，更新 res，res = max(res, i - j + 1)。

时间复杂度

$i, j$ 最多扫描一遍字符串，所以时间复杂度为 $O(n)$

空间复杂度

$O(n)$

C++ 代码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<int, int> cnt;
        int res = 0;
        for (int i = 0, j = 0; i < s.size(); i ++ ) {
            cnt[s[i]] ++ ;
            while (cnt[s[i]] > 1) cnt[s[j ++ ]] -- ;
            res = max(res, i - j + 1);
        }
        return res;
    }
};

剑指 Offer 48. 最长不含重复字符的子字符串

2022-07-09T01:40:12.086Z

题目描述

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

1
2
3

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

1
2
3

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

$s.length <= 40000$

注意：本题与主站 3 题相同：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

算法

(哈希表，双指针算法) $O(n)$

用哈希表存储每个字符出现的次数，且保证区间 $[i, j]$ 内没有重复元素，每个字符只出现一次；$res$ 记录答案。

双指针扫描字符串

每次将 $s[i]$ 加入到哈希表中
如果 $s[i]$ 出现的次数超过 1，说明在 $[j, i - 1]$ 中有重复元素，此时移动 $j$ 指针直到区间 $[j, i]$ 中没有重复元素为止。
计算区间长度即当前不含重复字符的字符串的长度，更新 res，res = max(res, i - j + 1)。

时间复杂度

$i, j$ 最多扫描一遍字符串，所以时间复杂度为 $O(n)$

空间复杂度

$O(n)$

C++ 代码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<int, int> cnt;
        int res = 0;
        for (int i = 0, j = 0; i < s.size(); i ++ ) {
            cnt[s[i]] ++ ;
            while (cnt[s[i]] > 1) cnt[s[j ++ ]] -- ;
            res = max(res, i - j + 1);
        }
        return res;
    }
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

2022-07-09T01:33:00.162Z

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。

示例：

1
2
3

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

提示：

$0 <= nums.length <= 50000$
$0 <= nums[i] <= 10000$

算法

(双指针,位运算)) $O(n)$

使用两个指针 $l、r$，$l$ 从前往后扫描找到偶数时停止，$r$ 从后往前扫描找到奇数时停止，此时如果 $l < r$ 则交换两个数，循环以上过程直到 $l >= r$ 为止。

小技巧：使用位运算和 $1$ 取 & 的结果判断是奇数还是偶数，在计算机中 $%$ 运算是非常慢的。

时间复杂度

$O(n)$

空间复杂度

$O(1)$

C++ 代码

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            while (l < r && (nums[l] & 1) == 1) l ++ ;
            while (l < r && (nums[r] & 1) == 0) r -- ;
            if (l < r) swap(nums[l], nums[r]);
        }
        return nums;
    }
};

剑指 Offer 16. 数值的整数次方

2022-07-09T01:32:08.239Z

题目描述

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^{n}）。不得使用库函数，同时不需要考虑大数问题。

示例 1：

1 2	输入：x = 2.00000, n = 10 输出：1024.00000

示例 2：

1 2	输入：x = 2.10000, n = 3 输出：9.26100

示例 3：

1
2
3

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

$-100.0 < x < 100.0$
$-2^{31} <= n <= 2^{31}-1$
$-10^{4} <= x^{n} <= 10^{4}$

注意：本题与主站 50 题相同：https://leetcode-cn.com/problems/powx-n/

算法

(快速幂) $O(logn))$

思路还是比较直接的，如果指数是负数，先不管负号，按正数来计算乘法的结果，最后再判断如果指数是负数的话，返回用 $1$ 除以答案的结果，否则直接返回即可。

注意：直接计算乘法会超时，需要用快速幂。

时间复杂度

$O(logn))$

空间复杂度

$O(1)$

C++ 代码

写法 1

class Solution {
public:
    double myPow(double x, int _n) {
        if (!x || x == 1) return x;
        long long n = _n;
        bool is_minus = _n < 0;
        n = is_minus ? -n : n;
        
        // 快速幂
        double res = 1;
        while (n) {
            if (n & 1) res = res * x;
            x *= x;
            n >>= 1; 
        }

        return is_minus ? 1 / res : res;
    }
};

写法 2

class Solution {
public:
    double myPow(double x, int n) {
        typedef long long LL;
        double res = 1;
        bool is_minus = n < 0;

        for (LL k = abs(LL(n)); k; k >>= 1) {
            if (k & 1) res *= x;
            x *= x;
        }

        if (is_minus) res = 1 / res;
        return res;
    }
};

剑指 Offer 11. 旋转数组的最小数字

2022-07-09T01:31:24.406Z

题目描述

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

1 2	输入: [0,1,3] 输出: 2

示例 2:

1 2	输入: [0,1,2,3,4,5,6,7,9] 输出: 8

限制：

$1 <= 数组长度 <= 10000$

算法

(二分) $O(logn)$

已知每个数字在 0 ~ n - 1 之间，但里面少一个数，观察数组的特点可以发现少的那个数一定是第一个大于当前下标的数，即 nums[i] > i，因此可以通过二分 $[0, n - 1]$ 区间寻找答案。

如果二分没有找到答案那么说明缺少的那个数就是 n - 1。

注意：分析的时候长度是 n - 1，代码实现 n 代表的就是数组的长度。

时间复杂度

$O(logn)$

空间复杂度

$O(1)$

代码

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size(); // n = 5, n - 1= 4;
        int l = 0, r = n;
        while (l < r) {
            int mid = (l + r) >> 1;
            if (nums[mid] > mid) r = mid;
            else l = mid + 1;
        }
        if (l == n) return n;
        return l;
    }
};

剑指 Offer 53 - I. 在排序数组中查找数字 I

2022-07-09T01:30:23.088Z

题目描述

统计一个数字在排序数组中出现的次数。

示例 1:

1 2	输入: nums = [5,7,7,8,8,10], target = 8 输出: 2

示例 2:

1 2	输入: nums = [5,7,7,8,8,10], target = 6 输出: 0

提示：

$0 <= nums.length <= 10^{5}$
$-10^{9} <= nums[i] <= 10^{9}$
$nums$ 是一个非递减数组
$-10^{9} <= target <= 10^{9}$

注意： 本题与主站 34 题相同（仅返回值不同）：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/

算法

(二分) $O(logn)$

在排序数组中快速找一个数可以用二分，题目要求找出连续的一段数 $target$ 的个数，可以做两次二分，二分左端点和二分右端点。

算法步骤：

二分左端点的条件：找到第一个大于等于 $target$ 的数的位置 $left$
二分结束，如果左端点对应的值不是 $target$，说明 $target$ 不存在，直接返回 $0$，否则继续二分右端点
二分右端点的条件：找到最后一个个小于等于 $target$ 的数的位置 $right$

最后返回出现的次数 $right - left + 1$。

时间复杂度

二分的时间复杂度为 $O(logn)$

空间复杂度

$O(1)$

C++ 代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.empty()) return 0;
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }

        if (nums[l] != target) return 0;

        int left = l;
        l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r + 1ll >> 1;
            if (nums[mid] <= target) l = mid;
            else r = mid - 1;
        }

        return r - left + 1;
    }
};

剑指 Offer 64. 求1+2+…+n

2022-07-09T01:28:01.288Z

题目描述

求 $1+2+…+n$ ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

示例 1：

1 2	输入: n = 3 输出: 6

示例 2：

1 2	输入: n = 9 输出: 45

限制：

$1 <= n <= 10000$

算法

(递归) $O(n)$

递归求解替换 $for$ 循环 $1 + 2 + … + n$
只不过需要将 $if$ 替换掉，依据 A && B 的性质，如果 A 为 false，B 就不执行，如果 A 是 true，B 还要进行判断。同样的对于 A || B 依然有类似的性质，如果 A 是 true，B 就不执行，如果 A 是 false，B 还要进行判断。

因此我们可以用逻辑与 && 运算符将 if 完美替换
if (n > 0) res += getSum(n - 1) -> n > 0 && (res += getSum(n - 1))

时间复杂度

递归 $n$ 次，时间复杂度为 $O(n)$

时间复杂度

递归系统调用栈的空间为 $O(n)$

C++ 代码

class Solution {
public:
    int sumNums(int n) {
        int res = n;
        n > 0 && (res += sumNums(n - 1));
        return res;
    }
};

剑指 Offer 65. 不用加减乘除做加法

2022-07-09T01:23:54.501Z

题目描述

写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。

示例:

1 2	输入: a = 1, b = 1 输出: 2

提示：

$a$, $b$ 均可能是负数或 0
结果不会溢出 32 位整数

算法

(位运算) $O(logn)$

首先我们可以将 $num1 + num2 = A + B$，A 是 $num1 + num2$ 做不进位加法的结果，B 是 $num1 + num2$ 产生的进位结果，两部分加起来就是 $num1 + num2$
不进位加法可以用异或 ^，计算进位可以用与 &，对每一位进行这两种操作
因为不能用加法，所以 $A + B$ 可以用 whlie 循环代替
循环终止条件：由于每次计算进位的结果 $carry$ 会左移 1 位，后面补 0，再计算新的进位做 & 运算时后面的 0 还是 0 不会出现 1，所以在不断的移位后 $carry$ 必然会变成 0，循环可以结束
循环内部：每次 $num1$ 和 $num2 / carry$ 做不进位加法，计算新产生的进位（为什么会有新的进位，因为 $sum$ 的结果和进位结果做不进位加法后可能还会出现新的进位），直到没有进位为止计算结束，$num1$ 中存的就是 num1 + num2 的结果
!注意：此做法只能做正数加法

时间复杂度

进位 $carry$ 每次左移 $1$ 位相当于除以 $2$，$logn$ 次 $carry$ 为 $0$，所以时间复杂度为 $O(logn)$

空间复杂度

$O(1)$

代码

class Solution {
public:
    int add(int a, int b) {
        while (b) {
            int sum = a ^ b;
            int carry = (unsigned int) (a & b) << 1;
            a = sum;
            b = carry;
        }
        return a;
    }
};

剑指 Offer 56 - II. 数组中数字出现的次数 II

2022-07-09T01:22:37.587Z

题目描述

在一个数组 $nums$ 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

示例 1：

1 2	输入：nums = [3,4,3,3] 输出：4

示例 2：

1 2	输入：nums = [9,1,7,9,7,9,7] 输出：1

限制：

$1 <= nums.length <= 10000$
$1 <= nums[i] < 2^31$

算法

(位运算) $O(32n)$

枚举每个数的每一位，用 $one$ 记录每一位 $1$ 出现的个数，如果 one % 3 == 1 说明答案中的当前位是 $1$，否则 one % 3 == 0 说明答案中的当前位不是 $1$，只有这两种情况，因为剩下的数都出现了三次，只有答案是出现一次的数字，所以处理完每一位之后就可以得到答案，这个方法还是比较好理解的。

时间复杂度

枚举数字的每一位，每个数字 $32$ 位，总共 $n$ 个数，所以时间复杂度为 $O(32n)$，但这个算法其实不是 $O(n)$ 的，假设 n 的范围是 $10^6$，则 $ logn < 32 $，所以此算法时间复杂度是大于 $O(nlogn)$ 的。

空间复杂度

$O(1)$

C++ 代码

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res = 0;
        for (int i = 0; i < 32; i ++ ) {
            int one = 0;
            for (auto x : nums)
                if (x >> i & 1)
                    one ++ ;
            if (one % 3 == 1) res += (1 << i);
        }
        return res;
    }
};