SOURCE CODE

java.lang.Integer文件里,判断一个int的位数

计算十进制的位数

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                  99999999, 999999999, Integer.MAX_VALUE };

// Requires positive x
static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

HashMap.put

默认equals方法是比较地址return (this == obj); hashcode方法是native方法，注释是说把对象地址转换成integer。

实现equals不实现hashcode会导致equals判定相等的两个对象放在map里是不同的key。

HashMap原理以及为什么需要同时实现equals和hashcode

HashMap源码之hash()函数分析

两个key是否相等 (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))

hashcode判相等貌似只在散列表里用到？普通的调a.equals(b)不会管hashcode？

由此可见先比hash(hashcode)再比equals，java只强制1. 根据equals()进行比较，相等的两个对象，hashCode()的值也必须相同； 2. 根据equals()进行比较，不相等的两个对象，hashCode()的值可以相同，也可以不同；

对Java8中distinct()的思考

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// hashcode与其本身右移16位相异或，所以这个hash()函数对于非null的hash值，仅在其大于等于216的时候才会重新调整其值。
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


//table这个长度永远是2的次方
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;//不存在table，创建
        if ((p = tab[i = (n - 1) & hash]) == null)//table  (table.length - 1) & hash 保证不会越界，只取hash的后面几位
            tab[i] = newNode(hash, key, value, null);// table数组改位置不存在元素就直接插入
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))//hash要相等，且要么引用相等要么equals方法相等（可能重写了equals方法） 这种应该是假设存的是链表node，待研究为啥treenode不能判断是否key重复？这个应该是treenode能判断，如果第一个相等了就不用判断，不相等再tree查找
                e = p;//key重复了，先保存
            else if (p instanceof TreeNode)//这样看是Table可能有两种Node，一种链表，一种tree，如果是TreeNode的话，则：
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//放进去了（即不重复）则返回null，放不进去就找到位置
            else {
                for (int binCount = 0; ; ++binCount) {//如果是linkNode的话，则遍历该bin（table[]， 链表）看是否存在重复
                    if ((e = p.next) == null) {//没找到重复的，e还是=null
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // TREEIFY_THRESHOLD=8，如果binCount=7则将linknode转成treenode
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))//找到重复了
                        break;
                    p = e;//链表向后
                }
            }
            if (e != null) { // existing mapping for key  存在重复
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null) //不知道啥时候e为空还到了这一步
                    e.value = value; //onlyIfAbsent=false 表示要改变重复key对应的value
                afterNodeAccess(e); //TODO: afterNodeAccess和afterNodeInsertion到底是怎么插进去的，干啥的？
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)//元素大小超过阈值 改变Table大小
            resize();
        afterNodeInsertion(evict);
        return null;
    }

/**
     * Replaces all linked nodes in bin at index for given hash unless
     * table is too small, in which case resizes instead.
     */
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)//MIN_TREEIFY_CAPACITY=64  tab就是table，即table为空resize
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

hashcode & equals

默认equals方法是比较地址return (this == obj); hashcode方法是native方法，注释是说把对象地址转换成integer。

hashcode是否真的用地址？

官方注释里说 hashcode方法默认是把对象地址转换成integer，但是有人分析实际的实现不是这样

Java Object.hashCode()返回的是对象内存地址？

How does the default hashCode() work?

hashcode是否从创建开始就保持不变？

官方注释里说 只要equals用来比较的信息不变，hashcode就应该不变。而且无论如何都不保证两次运行应用的hashcode相同。

在使用hash类型的集合时，最好保证用作key的对象不变。

When using a hash-based Collection or Map such as HashSet, LinkedHashSet, HashMap, Hashtable, or WeakHashMap, make sure that the hashCode() of the key objects that you put into the collection never changes while the object is in the collection. The bulletproof way to ensure this is to make your keys immutable, which has also other benefits.

https://stackoverflow.com/questions/27581/what-issues-should-be-considered-when-overriding-equals-and-hashcode-in-java

判断两个对象是否相等 java.util.Collections#eq

/**
 * Returns true if the specified arguments are equal, or both null.
 *
 * NB: Do not replace with Object.equals until JDK-8015417 is resolved.
 */
static boolean eq(Object o1, Object o2) {
    return o1==null ? o2==null : o1.equals(o2);
}

乘以100

    q = i / 100;
// really: r = i - (q * 100);
    r = i - ((q << 6) + (q << 5) + (q << 2));

想半天没想明天为什么((q << 6) + (q << 5) + (q << 2))就是乘100，原来这个就相当于q * (2^6 + 2^5 + 2^2) = q * 100

https://stackoverflow.com/a/2777225/5646921

21 * 5 = 10101_2 * 101_2             (Initial step)
       = 10101_2 * (1 * 2^2  +  0 * 2^1  +  1 * 2^0)
       = 10101_2 * 2^2 + 10101_2 * 2^0 
       = 10101_2 << 2 + 10101_2 << 0 (Decomposed)
       = 10101_2 * 4 + 10101_2 * 1
       = 10101_2 * 5
       = 21 * 5                      (Same as initial expression)

把两位数转为char

int x = 19;

DigitTens[x] 等于 '1'
DigitOnes[x] 等于 '9'


final static char [] DigitTens = {
    '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
    '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
    '2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
    '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
    '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
    '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
    '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
    '7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
    '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
    '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
    } ;

final static char [] DigitOnes = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    } ;