此处没有分析的

​在new是第一步是到这，我没看懂。。。。
 private void checkPackageAccess(Class<?> cls, ProtectionDomain pd) {
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            if (ReflectUtil.isNonPublicProxyClass(cls)) {
                for (Class<?> intf: cls.getInterfaces()) {
                    checkPackageAccess(intf, pd);
                }
                return;
            }

            final String name = cls.getName();
            final int i = name.lastIndexOf('.');
            if (i != -1) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        sm.checkPackageAccess(name.substring(0, i));
                        return null;
                    }
                }, new AccessControlContext(new ProtectionDomain[] {pd}));
            }
        }
    }
这是自动装包，int ，double那些
​public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
这是自己定义类型会出现的，没理解，
public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

 解读：

​
​
import java.util.ArrayList;
import java.util.List;

public class Main
{
    public static void main(String[] args)
    {
        List list = new ArrayList();
        list.add(new Dog("大壮", 10));
        list.add(new Dog("小黑", 9));
        list.add(new Dog("小黄", 100));
        list.add(new Dog("小黄", 100));
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        System.out.println(list);
        /*
        源码解读：
        1.ArrayList()初始化(没有指定长度)
            public ArrayList() {
                this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
            }
            DEFAULTCAPACITY_EMPTY_ELEMENTDATA是private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
            一个空数组；
            也就是说在newArrayList（）时调用无参构造器初始化时是给的空数组
        2.添加元素
            public boolean add(E e) {
                ensureCapacityInternal(size + 1); //size private int size;默认为0，意思为想加入元素最少要size+1个空间，
                //这是判断是否要扩容.
                //之后进入此方法：
                     private void ensureCapacityInternal(int minCapacity) {//minCapacity为size + 1，即表示最少所需的空间
                        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
                        //在此会先进入calculateCapacity(elementData, minCapacity)：
                        //此方法会接收当前的储存数组Object[] elementData，和最少所需空间数minCapacity
                                    private static int calculateCapacity(Object[] elementData, int minCapacity) {
                                        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                                        //判断数组是否为空
                                            return Math.max(DEFAULT_CAPACITY, minCapacity);
                                            //private static final int DEFAULT_CAPACITY = 10;
                                            //因为初始化没有给定长度所以数组都是空的在此条件下创建的ArrayList只有第一次添加
                                           //元素会进入if判断然后返回DEFAULT_CAPACITY，进行第二次数组赋值，变为有十个元素的数组
                                        }
                                        return minCapacity;
                                    }
                      //之后进入ensureExplicitCapacity方法：
                                    private void ensureExplicitCapacity(int minCapacity) {
                                        modCount++;//记录对数组操作的次数


                                        if (minCapacity - elementData.length > 0)
                                        //判断最小元素与数组长度的差如果大于0，表示所需空间，数组满足不了，就进入grow方法去扩容
                                        //第一次注意一下 minCapacity是10， elementData.length是0，elementData现在还是空数组
                                        //之后minCapacity都是数组已经存入元素加一，即存下此元素后数组里的元素个数
                                        //
                                            grow(minCapacity);
                                            //如果要扩容就进入grow方法：
                                            //minCapacity是最少所需元素个数，第一次是默认10（当然是new ArrayList()才是10，没参数）
                                                     private void grow(int minCapacity) {

                                                        int oldCapacity = elementData.length;
                                                        //记录数组长度存入oldCapacity
                                                        int newCapacity = oldCapacity + (oldCapacity >> 1);
                                                        //上面意思是按原来的1.5倍扩容
                                                        if (newCapacity - minCapacity < 0)
                                                        //这个if是专门为了第一次添加元素而存在的
                                                        //只有第一次添加会进入，因为elementData为空所以oldCapacity为0
                                                        //0的1.5倍还是0，所以就将空间大小设置为默认minCapacity = 10
                                                            newCapacity = minCapacity;
                                                        if (newCapacity - MAX_ARRAY_SIZE > 0)
                                                     //private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
                                                     //@Native public static final int   MAX_VALUE = 0x7fffffff;
                                                        //这个判断是如果要扩容空间超过正常的大小，即要很大后的操作，没遇到过
                                                            newCapacity = hugeCapacity(minCapacity);

                                                        elementData = Arrays.copyOf(elementData, newCapacity);
                                                        //这就是扩容了，它会将之前的元素都放入
                                                    }
                                    }
                     }

                elementData[size++] = e;
                //最后就是加入元素了
                 return true;
             }
            //最后提一句，这解读只是粗略的，没有去追更深层次的，因为只是初学，会有如果之后在扩容就按原来数组长度的1.5倍扩，不是
            size+1即minCapacity
         */
//上面是没有指定长度的现在试试指定长度的
        List list = new ArrayList(8);

        for (int i = 0; i < 12; i++)
        {
            list.add(i);
        }
         /*
        1.初始化 （new ArrayList(8)）
             public ArrayList(int initialCapacity) {//有参构造器initialCapacity初始值为指定个数在此是8
                 //此处判断initialCapacity的合法性如果小于0抛异常，等于0就和上面一样了
                if (initialCapacity > 0) {
                    this.elementData = new Object[initialCapacity];//大于0就创建你所指定大小的数组
                } else if (initialCapacity == 0) {
                    this.elementData = EMPTY_ELEMENTDATA;
                } else {
                    throw new IllegalArgumentException("Illegal Capacity: "+
                                                       initialCapacity);
                }
            }
         2.添加元素
            public boolean add(E e) {
                ensureCapacityInternal(size + 1);  //之后方式与无参初始化一样
                elementData[size++] = e;
                return true;
            }
         */

    }

}

class Dog
{
    private String name;
    private int age;

    @Override
    public String toString()
    {
        return "Dog{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public Dog(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public Dog()
    {
    }
}

​

​