java集合框架

java集合框架

java中的设计

1. 为什么接口下常常有一个抽象类，这是使用了缺省适配器模式，就是接口要求实现所有的方法，但是有时候我们只是想使用其中几种方法，这时就可以用一个抽象类来实现接口，提供默认实现，我们可以使用具体类来继承抽象类，从而实现我们要的特定方法。参考文章看这里和这里

杂记

推荐的博客

这里

1. map和dictionary的区别
2. hashtable和hashmap的区别
3. properties和hashtable的关系
4. toArray返回的是一个全新的数组，因为toArray会新建一个数组，并将元素存入，因此返回安全的数组

abstractCollection

1. abstractCollection实现了collection接口的大部分方法，使用者只需要实现iterator和size方法
2. toArray保证了当多个线程操作此对象时，保证正常运行，比如当遍历集合时对元素进行增删，任然能够正确返回

//这种是无参的，返回的数组长度=iterator的个数，因此可以处理并发情况
public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];//构建新数组，这个size()只是暂时的量，因为可能在遍历过程中元素个数增加或减少
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected ，这种情况表明在遍历的过程中元素减少了，就使用copyof构建一个长度为i的数组
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r; //如果超出预定长度之后迭代器中还有元素，此时进入finishToArray方法进行处理
    }



private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) { //如果当前容量=数组的最大值，就要给数组进行扩容，第一次传入的时候就已经容量相等了，肯定是要扩容的，就像c中的listsize和length一样
                int newCap = cap + (cap >> 1) + 1;// cap>>1，右移移位相当于/2.左移一位相当于*2，这个是动态数组的默认扩容方式，扩容50%
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);//处理超出int范围之后的值
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);//将新数组的多余空间裁剪掉，保证长度是和原集合中元素的个数是相等的
    }


    //这个值是比int的最大值小8，因为不同jvm会留一部分空间作为关键字
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;


    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow ，<0表明已经溢出，新容量是否超出了int的范围，因为一旦超出int范围之后，由于补码的缘故，会将最高位挤出去，就会变为负值，
            throw new OutOfMemoryError 
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ? 
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }




//如果传入的数组a的长度大于集合中的元素个数，就将所有元素存入数组中，空余的置null，否则就会返回一个类型相同的，且长度=集合长度的数组。
public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

集合的有序性

1. 详细看这里
2. 简而言之，有序性有两种不同的不同的角度。第一个角度，是插入元素的有序性，从这个角度来所，ArrayList和LinkedList都是有序的。set是无序的。从另一个角度(元素在集合中的存储顺序)来说，list是无序的。TreeSet是有序的。而hashset无论怎样都是无序的

collections工具类

设置集合只读

1. 详情看这里
2. Collections.unmodifiableMap

项目中的数据结构

1. HashSet可以用来解决下面的结构，比list多了个索引。方便查找

{
    "s": [
        {},
        {},
        {}
    ]
}