jdk 源码阅读（主要：util，lang，concurrent）（一）

绝地灬酷狼 2022-01-26 03:15 118阅读 0赞

1，PriorityQueue 添加元素，向上调整堆 ( 小根堆 )。

private void siftUp(int k, E x) {                  // 插入元素 向上调整
            if (comparator != null)
                siftUpUsingComparator(k, x);
            else
                siftUpComparable(k, x);
        }
    
        @SuppressWarnings("unchecked")
        private void siftUpComparable(int k, E x) {
            Comparable<? super E> key = (Comparable<? super E>) x;
            while (k > 0) {
                int parent = (k - 1) >>> 1;
                Object e = queue[parent];
                if (key.compareTo((E) e) >= 0)   // 小根堆，当 待插入元素 比 当前位置的父元素 大的时候，代表 待插入元素 可以插入到当前位置。
                    break;
                queue[k] = e;
                k = parent;
            }
            queue[k] = key;
        }
    
        @SuppressWarnings("unchecked")
        private void siftUpUsingComparator(int k, E x) {
            while (k > 0) {
                int parent = (k - 1) >>> 1;
                Object e = queue[parent];
                if (comparator.compare(x, (E) e) >= 0)
                    break;
                queue[k] = e;
                k = parent;
            }
            queue[k] = x;
        }

private void siftDown(int k, E x) {                  // 删除元素 向下调整
            if (comparator != null)
                siftDownUsingComparator(k, x);
            else
                siftDownComparable(k, x);
        }
    
        @SuppressWarnings("unchecked")
        private void siftDownComparable(int k, E x) {
            Comparable<? super E> key = (Comparable<? super E>)x;
            int half = size >>> 1;        // loop while a non-leaf
            while (k < half) {
                int child = (k << 1) + 1; // assume left child is least
                Object c = queue[child];
                int right = child + 1;
                if (right < size &&
                    ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                    c = queue[child = right];
                if (key.compareTo((E) c) <= 0)         // 比子节点小，插入当前位置即可
                    break;
                queue[k] = c;
                k = child;
            }
            queue[k] = key;
        }
    
        @SuppressWarnings("unchecked")
        private void siftDownUsingComparator(int k, E x) {
            int half = size >>> 1;
            while (k < half) {
                int child = (k << 1) + 1;
                Object c = queue[child];
                int right = child + 1;
                if (right < size &&
                    comparator.compare((E) c, (E) queue[right]) > 0)
                    c = queue[child = right];
                if (comparator.compare(x, (E) c) <= 0)
                    break;
                queue[k] = c;
                k = child;
            }
            queue[k] = x;
        }

2，Objects ： 对 object 的一些静态方法，有趣。

public final class Objects { // 不能继承
        private Objects() { // 不能实例化
            throw new AssertionError("No java.util.Objects instances for you!"); // 这样有趣

}

public static boolean deepEquals(Object a, Object b) {
            if (a == b)
                return true;
            else if (a == null || b == null)
                return false;
            else
                return Arrays.deepEquals0(a, b);
        }

static boolean deepEquals0(Object e1, Object e2) {
            assert e1 != null;
            boolean eq;
            if (e1 instanceof Object[] && e2 instanceof Object[])
                eq = deepEquals ((Object[]) e1, (Object[]) e2);
            else if (e1 instanceof byte[] && e2 instanceof byte[])
                eq = equals((byte[]) e1, (byte[]) e2);
            else if (e1 instanceof short[] && e2 instanceof short[])
                eq = equals((short[]) e1, (short[]) e2);
            else if (e1 instanceof int[] && e2 instanceof int[])
                eq = equals((int[]) e1, (int[]) e2);
            else if (e1 instanceof long[] && e2 instanceof long[])
                eq = equals((long[]) e1, (long[]) e2);
            else if (e1 instanceof char[] && e2 instanceof char[])
                eq = equals((char[]) e1, (char[]) e2);
            else if (e1 instanceof float[] && e2 instanceof float[])
                eq = equals((float[]) e1, (float[]) e2);
            else if (e1 instanceof double[] && e2 instanceof double[])
                eq = equals((double[]) e1, (double[]) e2);
            else if (e1 instanceof boolean[] && e2 instanceof boolean[])
                eq = equals((boolean[]) e1, (boolean[]) e2);
            else
                eq = e1.equals(e2);
            return eq;
        }

public static boolean deepEquals(Object[] a1, Object[] a2) {
            if (a1 == a2)
                return true;
            if (a1 == null || a2==null)
                return false;
            int length = a1.length;
            if (a2.length != length)
                return false;
    
            for (int i = 0; i < length; i++) {
                Object e1 = a1[i];
                Object e2 = a2[i];
    
                if (e1 == e2)
                    continue;
                if (e1 == null)
                    return false;
    
                // Figure out whether the two elements are equal
                boolean eq = deepEquals0(e1, e2);                      // 这个地方把 数组 里面存放的还是 数组 都考虑到了，赞
    
                if (!eq)
                    return false;
            }
            return true;
        }

3，String ：字符串类

public int indexOf(int ch, int fromIndex) {
            final int max = value.length;
            if (fromIndex < 0) {
                fromIndex = 0;
            } else if (fromIndex >= max) {
                // Note: fromIndex might be near -1>>>1.
                return -1;
            }
    
            if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {             // 字符还分两种
                // handle most cases here (ch is a BMP code point or a
                // negative value (invalid code point))
                final char[] value = this.value;
                for (int i = fromIndex; i < max; i++) {
                    if (value[i] == ch) {
                        return i;
                    }
                }
                return -1;
            } else {
                return indexOfSupplementary(ch, fromIndex);
            }
        }
    
        /**
         * Handles (rare) calls of indexOf with a supplementary character.
         */
        private int indexOfSupplementary(int ch, int fromIndex) {
            if (Character.isValidCodePoint(ch)) {
                final char[] value = this.value;
                final char hi = Character.highSurrogate(ch);
                final char lo = Character.lowSurrogate(ch);
                final int max = value.length - 1;
                for (int i = fromIndex; i < max; i++) {
                    if (value[i] == hi && value[i + 1] == lo) {
                        return i;
                    }
                }
            }
            return -1;
        }

public String replace(char oldChar, char newChar) {
            if (oldChar != newChar) {
                int len = value.length;
                int i = -1;
                char[] val = value; /* avoid getfield opcode */
    
                while (++i < len) {                    // 如果原始字符串中没有 oldChar ，就直接结束了
                    if (val[i] == oldChar) {
                        break;
                    }
                }
                if (i < len) {
                    char buf[] = new char[len];
                    for (int j = 0; j < i; j++) {
                        buf[j] = val[j];
                    }
                    while (i < len) {
                        char c = val[i];
                        buf[i] = (c == oldChar) ? newChar : c;
                        i++;
                    }
                    return new String(buf, true);
                }
            }
            return this;
        }

public char[] toCharArray() {                
            // Cannot use Arrays.copyOf because of class initialization order issues
            char result[] = new char[value.length];             // 返回一个新的 字符 数组，而非原 value 
            System.arraycopy(value, 0, result, 0, value.length);
            return result;
        }

public static String valueOf(int i) {
            return Integer.toString(i);                        // Integer 类中也有静态方法 可以把 数值 转变为 字符串，而不需要先建立 Integer 对象
        }

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                          99999999, 999999999, Integer.MAX_VALUE };
    
        // Requires positive x
        static int stringSize(int x) {                        // Integer 中用这种方法返回一个数有多少位，赞
            for (int i=0; ; i++)
                if (x <= sizeTable[i])
                    return i+1;
        }

static void getChars(int i, int index, char[] buf) {       // 数值 变 字符
            int q, r;
            int charPos = index;   // 从后向前 添加
            char sign = 0;
    
            if (i < 0) {
                sign = '-';
                i = -i;
            }
    
            // Generate two digits per iteration
            while (i >= 65536) {                            // 大数字
                q = i / 100;
            // really: r = i - (q * 100);
                r = i - ((q << 6) + (q << 5) + (q << 2));
                i = q;
                buf [--charPos] = DigitOnes[r];
                buf [--charPos] = DigitTens[r];
            }
    
            // Fall thru to fast mode for smaller numbers
            // assert(i <= 65536, i);
            for (;;) {
                q = (i * 52429) >>> (16+3);
                r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
                buf [--charPos] = digits [r];
                i = q;
                if (i == 0) break;
            }
            if (sign != 0) {
                buf [--charPos] = sign;
            }
        }

4，Void ： 类 也很有趣

public final
    class Void {
    
        /**
         * The {@code Class} object representing the pseudo-type corresponding to
         * the keyword {@code void}.
         */
        @SuppressWarnings("unchecked")
        public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");
    
        /*
         * The Void class cannot be instantiated.
         */
        private Void() {}
    }

/*
         * Return the Virtual Machine's Class object for the named
         * primitive type.
         */
        static native Class<?> getPrimitiveClass(String name);      // 返回虚拟机的 class object