자바 HashMap의 확장 프로세스 분석

 

  . (1)  최종 노드 <K, V> 리사이즈 () {
   2  
  3.      // 재 해시를 저장하기위한 배열 
  (4).      노드 <K, V> [] newtab]
   . 5      
  . 6      // 원의 배열이 비어있는 경우, 리사이즈 초기화 동작 대신 확장 동작을 수행한다 
  (7).      IF (표 == 널 ) {
   8.          // (16)의 초기 용량을 
  구.          INT CAP = DEFAULT_CAPACITY; // .. 1 <<< 4
 10  
. 11          // 초기 하중 인자 0.75, 재 팽창 할 때 3/4 필요한 용량을 사용하여 
12 인          loadFactor = DEFAULT_LOADFACTOR;
 13 것은  
14          // 설정된 확장 액 
15          (= 임계INT ) (* CAP loadFactor)
 16  
. 17          newtab = (노드 <K는, V는> [])는 ( 신규의 새로운 노드 [CAP]);
 (18)는          복귀 newtab]
 . 19      }
 20  
21      // 상세 설명은 생략 ... 프로세스, 예를 들어 용량 나는이 최대 값에 도달 할 방법, 프로그램 세그먼트는 확장 프로세스에 초점을 맞추고
 (22)  
(23)      // 원래의 배열, 첫 번째 확장을 비어 있지 않은 경우, 다음의 새로운 확장 후 배열에 원본 데이터의 해시 다시 
24      INT를 OLDCAP = table.length;
 25      INT newCap = OLDCAP << 1이다. ]
 (26)은      임계 값 = newCap * ; loadFactor
 27      newtab = (노드 <K, V> []) ( 새로운 새 노드 [newCap]);
 28  
(29)     // 루프는 원래의 배열을 통해 재 해시 
30      대를 ( INT I = 0; I <table.length; I ++ ) {
 31 인  
32          IF ([표 I] == 널 ) {
 33은              계속 ;
 34이다          }
 35  
36          노드 <K, V> E = 표 [I]는,
 37 [          표 [I] = 널 ;
 38 인  
39          // 각 요소의 배열은리스트는
 40          // 새로운 직접 한 다음,리스트의 한 요소가 있다면 위치 
(41)는          IF (e.next == 널 ) {
 42이다              newtab는 - [e.hash (1 -newCap.)] = E;
(43)은              계속 ;
 (44)가          }
 (45)  
(46)는          // 리스트의 여러 요소가있는 경우, 당신은 두 개의 목록으로 구분 될 필요가
 47 개          // 왜 두 목록이? 해시 및 (. -OLDCAP 1) == I이 시간 이후에
 48          // I + OLDCAP 및 I : 해시 및 (. -newCap 1) 두 개의 값을 갖는
 49          @ 증명 :
 50          //     가정 = 16 = 0b10000 OLDCAP
 51입니다          //     . <<< 1 = 16 = newCap 0b100000
 52 인          //     OLDCAP -. = 0b1111 1
 53 인          //          newCap -. 1 = 0b11111을 만든다
 (54)가          //     해시 및 (oldCap-1) 해시 및 (newCap-1) 만 ED 행 다섯째로부터 다른 남은
 55          //     때문에 0b10000 = oldCap 
56          //     그래서 및 해시 (-newCap. 1) == 해시 및 (-OLDCAP. 1) == I 
 57          //           또는 해시 (-newCap. 1) == 해시 및 (-OLDCAP. 1) + I + OLDCAP OLDCAP ==
 58  
59          @ 목록 1 : 현장에서, 즉, 해시 및은 (newCap-1) = 해시 앤 (OLDCAP-1) = I 
(60)          노드가 <K는, V가> hiHead, hiTail;
 61이다          // 목록 2 : I + oldCap 장소, 즉 해시 및 ( .. -1- newCap)는 제 1 해시 및 (-OLDCAP를 =) + I + = OLDCAP OLDCAP 
62          노드 <K, V> loHead, loTail;
 63 IS가          수행 {
 64              // 원래 목록 1로 분류 가능한 요소들의리스트 및 2
 65              
66              // 원래의 해쉬 값과 동일하다면 (I) 
(67)              IF ((e.hash (-OLDCAP. 1)) == (e.hash(1 newCap))) {
 68                  IF (loHead == 널 ) {
 69                      loHead = E;
 70                  } 다른 {
 71은                      loTail.next = E,
 72                  }
 (73)이다                  loTail = E;
 74              } 다른 {
 75                  // 만약 해쉬 값이 아닌 원래 (I + OLDCAP)로서 
76                  IF (hiHead == 널 ) {
 77                      hiHead = ; E
 78                  } 다른 {
79                      hiTail.next = E;
 80                  }
 81                  hiTail = E;
 82              }
 83              E = e.next;
 84          } 그동안 (E =! 널 );
 85  
(86)          IF (hiHead =! 널 ) {
 87              hiTail.next = 널 ;
 88              
(89)              // 새로운 위치에서 
90              newtab [I + OLDCAP = hiHead;
 91이다          }
 92          IF (loHead =!널 ) {
 93              loTail.next = 널 ;
 94  
(95)              // 제자리 
96              newtab [I] = loHead;
 97          }
 98      }
 99  
100      복귀 newtab;
 101 }