平时发现的一些有意思的小知识

平时遇到的一些自己开始不懂，后来看了下原理，豁然开朗的问题：

1.

package day1226;

/**
 * @author : hao
 * @project : StudySjms
 * @description :
 * @time : 2018/12/26 15:54
 */
public class IntegerTest {

    public static void main(String[] args) {
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i1==i2);    //true
        System.out.println(i3==i4);　　//false
    }
}

这是为什么呢？ 开始我以为只是false就好了

这里面体现了 原生类型和包装类型的装箱和拆箱。 

自动装箱的时候 实际上调用了Interger.valueOf(int)  ，拆箱的时候用的是initValue(Integer)

    public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }

可以发现如果值是-128-127范围内是返回缓存里的引用，如果不是新建一个对象，返回引用。所有上面200两个引用是两个对象的，所以false。

2.你了解可变参数和数据参数吗？

package day1227;

/**
 * @author : hao
 * @project : StudySjms
 * @description :
 * @time : 2018/12/27 15:48
 */
public class KbArrayTest {


    public static void main(String[] args) {
        KbArrayTest test = new KbArrayTest();
        int[] array = new int[]{1,2,3};

        test.printA(array);
        test.printB(array);

        test.printA(new int[]{3,4,5});
        test.printA(3,5,7);
        
        test.printB(new int[]{3,4,5});
        //test.printB(3,5,7); 不通过，   int...num参数可以接受数组，反之int[] array 不接受1,2,3这种参数
    }



    private void printA(int... num){
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }

    private void printB(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

这里面看一下编译后的class 有意思的地方：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package day1227;

public class KbArrayTest {
    public KbArrayTest() {
    }

    public static void main(String[] args) {
        KbArrayTest test = new KbArrayTest();
        int[] array = new int[]{1, 2, 3};
        test.printA(array);
        test.printB(array);
        test.printA(new int[]{3, 4, 5});
        test.printA(new int[]{3, 5, 7});
        test.printB(new int[]{3, 4, 5});
    }

    private void printA(int... num) {
        for(int i = 0; i < num.length; ++i) {
            System.out.println(num[i]);
        }

    }

    private void printB(int[] array) {
        for(int i = 0; i < array.length; ++i) {
            System.out.println(array[i]);
        }

    }
}

调用 int... num 形参的方法，不管你参数怎么写，编译后都变成了 new int[]{} 数组参数的形式

3. ArrayList里面的elementData [] 为什么用transient修饰。Arraylist不是支持序列化吗？

　　应该知道transient修饰的变量内容是不参与自动序列化，即使实现了Serialiazble接口

　　因为Arraylist里面数组的长度不是固定的，如果扩容后，这个data数据里面会有很多空的内容，这个就不需要去序列化了，

　　ArrayList里面有两个类来实现序列化，writeObject和readObject 里面都是先写或者先读容量，然后挨个节点读或者写

4.ArrayList 在多线程里面 如果后续用Iterator迭代器遍历，如果一个线程正在遍历，两一个线程修改了，那么会出现ConcurrentModificationException?知道原因吗？知道怎么解决吗？原理知道吗？

　　首先ArrayList的父类AbstractList里面实现乐迭代器接口并且在hasNext和next()方法里都做了判断，是否抛这个异常，有一个modCount,和Iterator也有个ExpectedModCount,

然后每次ArrayList改变数组大小操作的时候，都是modCount+1，但是new Itreator的时候给的初始值是原来的，这样就导致可能出现不一致的情况。

　　然后解决这个问题可以用CopyOnWriteArrayList来解决。

　　为什么可以呢？ 因为这个类所有写操作都加锁，然后每次操作都会复制一份原来的数组，改好了在把新数组的引用指向原来的，数组，而且这个array是用volatile修饰的，内存可见性。而且他的iterator是自己实现的。数组也是备份了一份，所以遍历的时候不会影响的。因为Iterator操作的还是老的数组，