자바 에서 Array List 집합 저층 의 확장 원리

제1장 서론 개술
제1 1 절 개술
기본 설명
ArrayList 는 List 의 실현 클래스 입 니 다.밑 에 Object 배열 로 저장 되 어 있 습 니 다.스 레 드 가 안전 하지 않 습 니 다.
후기 응용
잦 은 조회 작업 에 적합 합 니 다.바 텀 은 배열 이기 때문에 배열 아래 표 시 를 통 해 빠르게 찾 을 수 있 습 니 다.
제 02 절 구별
방향 을 구별 하 다
ArrayList 집합
LinkedList 집합
스 레 드 보안
안전 하지 않다
안전 하지 않다
기본 원리
Object 형식 배열
양 방향 링크
임 의 접근
지원(RandomAccess 인터페이스 구현)
지지 하지 않 음
메모리 사용량
Array List 는 공간 을 낭비 하고 밑 은 배열 이 며 끝 은 일부 용량 공간 을 남 깁 니 다.
LinkedList 는 ArrayList 보다 공간 을 많이 차지 하고 머리 끝 주소 값 이 공간 을 차지 합 니 다.
작은 매듭
ArrayList 집합의 특징:
1.라인 이 안전 하지 않 음
2.바 텀 데이터 구 조 는 배열(조회 가 빠 르 고 삭제 가 느 리 며 빠 른 랜 덤 접근 을 지원 합 니 다)
3.메모리 사용량 은 일부 낭비 가 있 을 수 있 고 끝 에 일부 용량 공간 을 남 길 수 있 습 니 다.
제2 장 핵심 코드
제 01 절 멤버 변수
코드

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ 

	/**
	 *         ,         10
	 */
	private static final int DEFAULT_CAPACITY = 10;

	/**
	 *    。          ，         
	 */
	private static final Object[] EMPTY_ELEMENTDATA = {};

	/**
	*          ，       ，        。
	*         EMPTY_ELEMENTDATA       ，            ，      
	*/
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

	/**
	 *   ArrayList     ，          ，      final              
	 */
	transient Object[] elementData; // non-private to simplify nested class access

	/**
	 * ArrayList         ，     ArrayList     ，   size()  ，        
	 */
	private int size; 
}

보충 하 다

1. ArrayList       6     
	     private static final long serialVersionUID = 8683452581122892189L;  
	     ,               ,         。

2. ArrayList              
	A.         		transient Object[] elementData;
	B.        		private int size; 

제 02 절 구조 방법
코드

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ 

    /**
     *          0    。
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     *        ，        c，    c         
	 * elementData      ，          
     * c.toArray             
	 *                 ，        c   elementData   
	 *                ，         EMPTY_ELEMENTDATA 
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) { 
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else { 
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
	
	 /**
     *          
	 *           0，       
	 *           0，              this.elementData = EMPTY_ELEMENTDATA;
	 *           0，         
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }
}

추가(1)무 참 구조 생 성 대상

보충(2)참조 구조 생 성 대상,int 형식 매개 변수 가 있 습 니 다.

보충(3)대 참 구조 생 성 대상,집합 유형 파라미터 포함

제3 장 용량 확대 작업
제 01 절 용량 확장 코드
핵심 방법 소개

    ArrayList        ：
	1. public boolean add(E e){ ... }
	2. private void add(E e, Object[] elementData, int s){ .... }
	3. private Object[] grow()
	4. private Object[] grow(int minCapacity)

           
	1. Arrays.copyOf(elementData, newCapacity);              Arrays     copyOf()        System.arraycopy()   
	2. Math.max(DEFAULT_CAPACITY, minCapacity)               Math     max()   ，         ，    ，  

핵심 코드 해석

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ 

    /**
     *                  
     *
     * modCount         AbstractList        
     * add(e, elementData, size)            
	 * return true         ，        ，  List                 true    Set     false
     */
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
	
	
	/**
     *          ，        。         。      add()        
	 *   1:             E e
	 *   2:         ,              Object[] elementData
     *   3:         , size    elementData               
	 *        :  size          elementData      ，          ，     grow()   
	 *               ，                  ，    elementData[s] = e;
	 *            size           ，  1，           ，     ，   1
     */
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }
	
	
	/**
     *          ，        。         。      add()      
	 *          ArrayList           grow(size + 1)        。
	 *        ，             size + 1      size     1 
	 *              ，          
     */
	private Object[] grow() {
        return grow(size + 1);
    }


    /**
     *          ，        。         。      grow()      
	 *       minCapacity ，          size + 1，         minCapacity = size + 1
	 *           :
	 * 		1.               int oldCapacity = elementData.length;         oldCapacity
	 *      2.       oldCapacity     0，    else    ，
	 *				     if      ，              ，                     
	 *					  :              DEFAULTCAPACITY_EMPTY_ELEMENTDATA     
	 *					      ，     1.5        ，    Arrays.copyOf()      ，       
	 * 				     else      ，    DEFAULT_CAPACITY   minCapacity    。
	 * 					  : DEFAULT_CAPACITY          ，    10   
	 *					  : minCapacity    10   ，            1,2,3..9.10.11..
     */
    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }
}

자바 에서 Array List 집합 저층 의 확장 원리 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 Array List 집합 확장 원리 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!