Java Improvement Chapter (35) -----Java Collection Details (1): Please specify the initial capacity for the collection

Collections are very widely used in Java programming. They are like the sea, which contains all rivers, and are like universal containers that contain all things. Moreover, this sea and universal container can grow infinitely (if conditions permit). When the volume of this sea or container becomes very large, its initial capacity will become very important, because digging and expanding the sea requires a lot of manpower, material and financial resources. In the same way, the initial capacity of Collection is also extremely important. So: For known scenarios, specify an initial capacity for the collection.

public static void main(String[] args) {
        StudentVO student = null;
        long begin1 = System.currentTimeMillis();
        List<StudentVO> list1 = new ArrayList<>();
        for(int i = 0 ; i < 1000000; i++){
            student = new StudentVO(i,"chenssy_"+i,i);
            list1.add(student);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("list1 time：" + (end1 - begin1));
        
        long begin2 = System.currentTimeMillis();
        List<StudentVO> list2 = new ArrayList<>(1000000);
        for(int i = 0 ; i < 1000000; i++){
            student = new StudentVO(i,"chenssy_"+i,i);
            list2.add(student);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("list2 time：" + (end2 - begin2));
    }

Both lists of the above codes are Insert 1,000,000 pieces of data, but list1 has not applied for initialization capacity, while list2 has an initialization capacity of 1,000,000. The running results are as follows:

##

list1 time：1638
list2 time：921

We can see from the above running results The speed of outputting list2 is about twice that of list1. LZ mentioned before that the expansion mechanism of ArrayList is relatively resource-consuming. Let’s first look at the add method of ArrayList:

public boolean add(E e) {  
        ensureCapacity(size + 1);   
        elementData[size++] = e;  
        return true;  
    }  
    
    public void ensureCapacity(int minCapacity) {  
        modCount++;         //修改计数器
        int oldCapacity = elementData.length;    
        //当前需要的长度超过了数组长度，进行扩容处理
        if (minCapacity > oldCapacity) {  
            Object oldData[] = elementData;  
            //新的容量 = 旧容量 * 1.5 + 1
            int newCapacity = (oldCapacity * 3)/2 + 1;  
                if (newCapacity < minCapacity)  
                    newCapacity = minCapacity;  
          //数组拷贝，生成新的数组 
          elementData = Arrays.copyOf(elementData, newCapacity);  
        }  
    }

Every time ArrayList is added An element will detect whether the current capacity of ArrayList has reached the critical point. If it reaches the critical point, it will expand the capacity by 1.5 times. However, the expansion of ArrayList and the copying of arrays to generate new arrays are quite resource-intensive. So if we know the usage scenario of the collection in advance and know the approximate range of the collection, we'd better specify the initialization capacity, so that the utilization of resources will be better, especially under the premise of large data volume, the efficiency will be improved and the utilization of resources will be improved. will appear more advantageous.

##The above is the content of Java, collection details, and initial capacity. For more related content, please pay attention to the PHP Chinese website (www .php.cn)!