1.奇怪,为什么 ArrayList 初始化容量大小为 10?HashMap 的初始化容量为 16?
2.arraylist为ä»ä¹çº¿ç¨ä¸å®å
¨
3.ArrayList 从源码角度剖析底层原理
4.å¦ä½èªå·±å®ç°ä¸ä¸ªç®åçArrayList
奇怪,为什么 ArrayList 初始化容量大小为 10?HashMap 的初始化容量为 16?
看ArrayList源码时,无意中发现其初始化容量大小为,这与我们熟知的ArrayList和HashMap底层基于数组的特性大相径庭,为何ArrayList不采用如HashMap所用的liteos源码下载作为初始容量,而是选择?
探讨HashMap的初始化容量,以Java 8源码为例,HashMap的默认初始化容量为,当数据填充至容量的%时,会进行2倍扩容。若用户自定义容量,需保证为2的游资低吸源码n次方数值,否则,HashMap会自动调整,增加额外步骤。而关于HashMap计算Key值坐标的哈希算法,其效果依赖于数组的大小,确保容量为2的n次方能实现更高效的位操作,减少哈希碰撞。
通常,选择作为默认值,不仅减少哈希碰撞,也提升了效率,这是网校源码搭建原理HashMap采用2的n次方,且默认值为的原因。而ArrayList的初始化容量为何设定为?答案其实颇为“直觉”,是一个平衡内存使用与性能损失的“感觉”值。在不考虑算法优化的前提下,ArrayList的容量应是任何正值,而选择作为默认值,可能是出于性能与空间损失之间的最佳平衡考量。这使得ArrayList在创建时无需消耗过多内存,同时保持较低的性能开销。
通过对比不同集合类的初始化容量,如ArrayList与Vector的,HashSet与HashMap的源码偏辑器,以及独树一帜的HashTable的,我们能更好地理解不同设计决策背后的考量。在实际编程中,选择合适的数据结构不仅取决于其初始容量,更应综合考虑应用需求、性能预期以及资源限制。
arraylist为ä»ä¹çº¿ç¨ä¸å®å ¨
é¦å 说ä¸ä¸ä»ä¹æ¯çº¿ç¨ä¸å®å ¨ï¼çº¿ç¨å®å ¨å°±æ¯å¤çº¿ç¨è®¿é®æ¶ï¼éç¨äºå éæºå¶ï¼å½ä¸ä¸ªçº¿ç¨è®¿é®è¯¥ç±»çæ个æ°æ®æ¶ï¼è¿è¡ä¿æ¤ï¼å ¶ä»çº¿ç¨ä¸è½è¿è¡è®¿é®ç´å°è¯¥çº¿ç¨è¯»åå®ï¼å ¶ä»çº¿ç¨æå¯ä½¿ç¨ãä¸ä¼åºç°æ°æ®ä¸ä¸è´æè æ°æ®æ±¡æã线ç¨ä¸å®å ¨å°±æ¯ä¸æä¾æ°æ®è®¿é®ä¿æ¤ï¼æå¯è½åºç°å¤ä¸ªçº¿ç¨å åæ´æ¹æ°æ®é ææå¾å°çæ°æ®æ¯èæ°æ®ã å¦å¾ï¼Listæ¥å£ä¸é¢æ两个å®ç°ï¼ä¸ä¸ªæ¯ArrayListï¼å¦å¤ä¸ä¸ªæ¯vectorã ä»æºç çè§åº¦æ¥çï¼å 为Vectorçæ¹æ³åå äºï¼synchronized å ³é®åï¼ä¹å°±æ¯åæ¥çææï¼sunå ¬å¸å¸æVectoræ¯çº¿ç¨å®å ¨çï¼èå¸æarraylistæ¯é«æçï¼ç¼ºç¹å°±æ¯å¦å¤çä¼ç¹ã 说ä¸åçï¼ç¾åº¦çï¼å¾å¥½ç解ï¼ï¼ ä¸ä¸ª ArrayList ï¼å¨æ·»å ä¸ä¸ªå ç´ çæ¶åï¼å®å¯è½ä¼æ两æ¥æ¥å®æï¼
1. å¨ Items[Size] çä½ç½®åæ¾æ¤å ç´ ï¼
2. å¢å¤§ Size çå¼ã
å¨å线ç¨è¿è¡çæ åµä¸ï¼å¦æ Size = 0ï¼æ·»å ä¸ä¸ªå ç´ åï¼æ¤å ç´ å¨ä½ç½® 0ï¼èä¸ Size=1ï¼
èå¦ææ¯å¨å¤çº¿ç¨æ åµä¸ï¼æ¯å¦æ两个线ç¨ï¼çº¿ç¨ A å å°å ç´ åæ¾å¨ä½ç½® 0ãä½æ¯æ¤æ¶ CPU è°åº¦çº¿ç¨Aæåï¼çº¿ç¨ B å¾å°è¿è¡çæºä¼ã线ç¨Bä¹åæ¤ ArrayList æ·»å å ç´ ï¼å 为æ¤æ¶ Size ä»ç¶çäº 0 ï¼æ³¨æå¦ï¼æ们å设çæ¯æ·»å ä¸ä¸ªå ç´ æ¯è¦ä¸¤ä¸ªæ¥éª¤å¦ï¼è线ç¨Aä» ä» å®æäºæ¥éª¤1ï¼ï¼æ以线ç¨Bä¹å°å ç´ åæ¾å¨ä½ç½®0ãç¶å线ç¨Aå线ç¨Bé½ç»§ç»è¿è¡ï¼é½å¢å Size çå¼ã
é£å¥½ï¼ç°å¨æ们æ¥çç ArrayList çæ åµï¼å ç´ å®é ä¸åªæä¸ä¸ªï¼åæ¾å¨ä½ç½® 0ï¼è Size å´çäº 2ãè¿å°±æ¯â线ç¨ä¸å®å ¨âäºã
示ä¾ç¨åºï¼
package test;
import java.util.ArrayList;
import java.util.List;
public class ArrayListInThread implements Runnable {
List<String> list1 = new ArrayList<String>();// not thread safe
// List<String> list1 = Collections.synchronizedList(new ArrayList<String>());// thread safe
public void run() {
try {
Thread.sleep((int)(Math.random() * 2));
}
catch (InterruptedException e) {
e.printStackTrace();
}
list1.add(Thread.currentThread().getName());
}
public static void main(String[] args) throws InterruptedException {
ThreadGroup group = new ThreadGroup("mygroup");
ArrayListInThread t = new ArrayListInThread();
for (int i = 0; i < ; i++) {
Thread th = new Thread(group, t, String.valueOf(i));
th.start();
}
while (group.activeCount() > 0) {
Thread.sleep();
}
System.out.println();
System.out.println(t.list1.size()); // it should be if thread safe collection is used.
}
}
ArrayList 从源码角度剖析底层原理
本文深入剖析了ArrayList的底层实现,重点关注了add和remove方法的源码,以及如何指定元素位置的add操作。
在add默认添加元素中,我们通过ensureCapacityInternal方法确保数组不会越界,且实现自动扩容。p32源码此方法通过minCapacity参数记录在执行完当前add操作后的数组元素数量,从而决定是否扩容。对于数组扩容,核心逻辑为新数组长度等于旧数组长度加旧数组长度的一半,每次扩容1.5倍。然而,当调用addAll方法传入大量元素时,若数组容量不足以容纳所有元素,newCapacity会小于minCapacity。这时,会直接将minCapacity赋值给newCapacity以避免扩容不足。对于极端情况,如传入Integer.MAX_VALUE个元素,会触发hugeCapacity函数处理,确保容量不超过Integer.MAX_VALUE并抛出OOM异常。
在add指定位置添加元素的操作中,方法首先检查传入的数组下标是否合法,接着通过ensureCapacityInternal方法对数组进行扩容,以确保有足够的空间容纳新元素。随后,调用System.arraycopy方法实现元素移动,即将指定位置后的元素向后移动一位,以为空出位置添加新元素。简单而言,System.arraycopy方法实现了元素的移动逻辑,通过传入数组、源起始索引、目标起始索引和元素个数等参数实现元素的高效复制。
在remove方法中,根据下标移除元素时,会先检查传入的index是否合法,即确保index不超过数组元素个数。完成元素移除后,会更新modCount的值,验证了删除操作对数组状态的影响。在移动元素时,通过System.arraycopy方法将需要移动的元素向后挪动,以释放被移除元素的位置,最后将该位置设置为null并交给GC回收。
根据值移除元素时,ArrayList允许传入null值,并通过遍历数组寻找匹配的第一个元素进行移除。无论传入的值是否为null,都会调用fastRemove方法,执行与remove方法类似的逻辑,实现元素的删除。
综上所述,ArrayList底层基于数组实现,支持动态扩容,每次扩容1.5倍。然而,频繁的随机插入和删除操作会带来性能影响,因此,ArrayList更适合读多写少的场景。值得注意的是,ArrayList非线程安全,多线程环境下可能会导致数据不一致或抛出ConcurrentModificationException异常。
通过理解add、remove以及指定位置添加元素的源码实现,可以更好地理解ArrayList的操作机制。例如,了解remove方法的遍历逻辑,可以帮助直观理解indexOf和lastIndexOf方法的工作原理。
å¦ä½èªå·±å®ç°ä¸ä¸ªç®åçArrayList
ArrayListæ¯Javaéåæ¡æ¶ä¸ä¸ä¸ªç»å ¸çå®ç°ç±»ãä»æ¯èµ·å¸¸ç¨çæ°ç»èè¨ï¼ææ¾çä¼ç¹å¨äºï¼å¯ä»¥éæçæ·»å åå é¤å ç´ èä¸éèèæ°ç»ç大å°ãå®ç°ä¸ä¸ªç®åçArrayListï¼å®ç°çè¿ç¨ï¼
å®ç°çArrayList主è¦çåè½å¦ä¸ï¼
é»è®¤æé å¨åä¸ä¸ªåæ°çæåæé å¨
addæ¹æ³
getæ¹æ³
indexOfæ¹æ³
containsæ¹æ³
sizeæ¹æ³
isEmptyæ¹æ³
removeæ¹æ³
è¿ä¸ªç®åçArrayListç±» åå为SimpleArrayListï¼å ¨é¨ç代ç æ¥çSimpleArrayList代ç
æé å¨
æºç ArrayListä¸å ±æä¸ä¸ªæé å¨ï¼ä¸ä¸ªæ åæé å¨ï¼ä¸ä¸ªåæ°ä¸ºintåæåæé å¨ï¼ä¸ä¸ªåæ°ä¸ºCollectionåçæåæé å¨ãåæ°ä¸ºCollectionåçæé å¨ç¨æ¥å®ç°å°å ¶ä»ç»§æ¿Collectionç±»ç容å¨ç±»è½¬æ¢æArrayListãSimpleArrayListç±»å 为è¿æ²¡ææå¨å®ç°å ¶ä»ç容å¨ç±»ï¼æ以å®ç°çæé æ¹æ³åªæ2个ã代ç å¦ä¸ï¼
public SimpleArrayList(){ this(DEFAULT_CAPACITY);} public SimpleArrayList(int size){ if (size < 0){ throw new IllegalArgumentException("é»è®¤ç大å°" + size);
}else{
elementData = new Object[size];
}
}
æ åæé å¨ä¸ç DEFAULT_CAPACITYæ¯å®ä¹çç§æåéï¼é»è®¤å¼æ¯ï¼ç¨æ¥å建ä¸ä¸ªå¤§å°ä¸ºçæ°ç»ãæåæé å¨ä¸ï¼intåæ°æ¯ç¨æ¥çæä¸ä¸ªæå®å¤§å°çObjectæ°ç»ãå°å建好çæ°ç»ä¼ ç»elementDataãelementDataæ¯çæ£çç¨æ¥åå¨å ç´ çæ°ç»ãaddæ¹æ³
add æ¹æ³ç¨æ¥å¾å®¹å¨ä¸æ·»å å ç´ ï¼addæ¹æ³æ两个éè½½æ¹æ³ï¼ä¸ä¸ªæ¯add(E e),å¦ä¸ä¸ªæ¯add(int index, E e)ãaddæ¬èº«å¾ç®åï¼ä½æ¯è¦å¤çå¨ææ°ç»ï¼å³æ°ç»å¤§å°ä¸æ»¡è¶³çæ¶åï¼æ©å¤§æ°ç»çå åãå ·ä½ç代ç å¦ä¸ï¼
public void add(E e){isCapacityEnough(size + 1);
elementData[size++] = e;
}
æ¹æ³isCapacityEnoughå°±æ¯æ¥å¤ææ¯å¦éè¦æ©å®¹ï¼ä¼ å ¥çåæ°å°±æ¯æå°çæ©å®¹ç©ºé´ãå 为addä¸ä¸ªå ç´ ï¼æ以æå°çæ©å®¹ç©ºé´ï¼å³æ°çé¿åº¦æ¯ææå ç´ + 1ãè¿éçsizeå°±æ¯çæ£çå ç´ ä¸ªæ°ã private void isCapacityEnough(int size){ if (size > DEFAULT_CAPACITY){explicitCapacity(size);
} if (size < 0){ throw new OutOfMemoryError();
}
}
å¤ææ©å®¹çæ¹æ³ä¹å¾ç®åï¼å¤æéè¦æ©å®¹ç空é´æ¯ä¸æ¯æ¯é»è®¤ç空é´å¤§ãå¦æéè¦ç空é´æ¯é»è®¤ç空é´å¤§ï¼å°±è°ç¨explicitCapacityè¿è¡æ©å®¹ãè¿éæ个sizeå°äº0çå¤æï¼åºç°sizeå°äº0主è¦æ¯å 为å½sizeè¶ è¿Integer.MAX_VALUEå°±ä¼åæè´æ°ã private final static int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8; private void explicitCapacity(int capacity){ int newLength = elementData.length * 2; if (newLength - capacity < 0){newLength = capacity;
} if (newLength > (MAX_ARRAY_LENGTH)){
newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);
}
elementData = Arrays.copyOf(elementData, newLength);
}
ä¸é¢ç代ç æ¯æ©å®¹ç代ç ï¼é¦å ï¼å®ä¹ä¸ä¸ªæ°ç»æ大ç容éç常é为æ大å¼ï¼è¿ä¸ªå¼æç §å®æ¹çæºç ä¸ç解éæ¯è¦æäºVMä¿çäºæ°ç»ç头é¨ä¿¡æ¯å¨æ°ç»ä¸ï¼å æ¤å®é åæ¾æ°æ®ç大å°å°±æ¯æ´æ°çæå¤§å¼ - 8ç¶å设å®ä¸ä¸ªè¦æ©å®¹çæ°ç»ç大å°ï¼è½ç¶ä¸é¢è¯´äºæä¸ä¸ªæ©å®¹ç©ºé´çå¼ size + 1 ï¼è¿ä¸ªæ¯å®é æ们æå°éè¦æ©å®¹ç大å°ãä½ä¸ºäºç»§ç»å¢å å ç´ ï¼èä¸é¢ç¹çæ©å®¹ï¼å æ¤ä¸æ¬¡æ§çç³è¯·å¤ä¸äºçæ©å®¹ç©ºé´ãè¿énewLength æç®ç³è¯·ä¸º æ°ç»é¿åº¦ç2åï¼ç¶åå»å¤æè¿ä¸ªé¿åº¦æ¯å¦æ»¡è¶³éè¦çæ©å®¹ç©ºé´çå¼ã å³æäºåç»ç两段代ç
if (newLength - capacity < 0){ newLength = capacity;} if (newLength > (MAX_ARRAY_LENGTH)){ newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);
}
å¦æ2åçé¿åº¦ä»ç¶ä¸æ»¡è¶³ï¼åç³è¯·å°éè¦çæ©å®¹é¿åº¦ãå¨æ们åªå¢å ä¸ä¸ªå ç´ çæ åµä¸ï¼è¿ä¸ªå¤ææ¯æ°¸è¿ä¸ä¼çæçï¼ä½æ¯å¦ææaddAllæ¹æ³ï¼åå¢å çå ç´ å¾å¤ï¼å°±è¦å¯¼è´ä¸æ¬¡ç³è¯·2åçé¿åº¦æ¯ä¸å¤çã第äºä¸ªå¤ææ¯å¤ænewLengthçé¿åº¦å¦æè¶ è¿ä¸é¢å®ä¹çæ°ç»æ大é¿åº¦åå¤æè¦éè¦çæ©å®¹ç©ºé´æ¯å¦å¤§äºæ°ç»æ大é¿åº¦ï¼å¦æ大äºånewLength为 MAX_VALUE ï¼å¦å为 MAX_ARRAY_LENGTHãæåï¼çæ£å®ç°æ°ç»æ©å®¹å°è®¾å®é¿åº¦çæ¹æ³å°±æ²¡ææäºï¼è°ç¨Arrays.copyOf(elementData, newLength)å¾å°ä¸ä¸ªæ©å®¹åçæ°ç»ã
addçå¦ä¸ä¸ªéè½½æ¹æ³ä¹å¾ç®åã
public void add(int index, E e) {//å¤ææ¯ä¸æ¯è¶ç
checkRangeForAdd(index);
//å¤æéä¸éè¦æ©å®¹
isCapacityEnough(size + 1);
//å°indexçå ç´ å以åçå ç´ åå移ä¸ä½
System.arraycopy(elementData,index,elementData,index + 1,size - index);
//å°indexä¸æ çå¼è®¾ä¸ºe
elementData[index] = e; size++;
}
private void checkRangeForAdd(int index){ //è¿éindex = sizeæ¯è¢«å 许çï¼å³æ¯æ头ï¼ä¸é´ï¼å°¾é¨æå ¥
if (index < 0 || index > size){ throw new IndexOutOfBoundsException("æå®çindexè¶ è¿çé");
}
}
è³æ¤ï¼ä¸ä¸ªç®åçaddæ¹æ³å°±å®ç°å®äºãgetæ¹æ³
getæ¹æ³ç¨æ¥å¾å°å®¹å¨ä¸æå®ä¸æ çå ç´ ãæ¹æ³å®ç°æ¯è¾ç®åï¼ç´æ¥è¿åæ°ç»ä¸æå®ä¸æ çå ç´ å³å¯ã
private void checkRange(int index) { if (index >= size || index < 0){throw new IndexOutOfBoundsException("æå®çindexè¶ è¿çé");
}
} public E get(int index){
checkRange(index); return (E)elementData[index];
}
indexOfæ¹æ³indexOfæ¹æ³ç¨æ¥å¾å°æå®å ç´ çä¸æ ãå®ç°èµ·æ¥æ¯è¾ç®åï¼éè¦å¤æä¼ å ¥çå ç´ ï¼ä»£ç å¦ä¸ï¼
public int indexOf(Object o){ if (o != null) { for (int i = 0 ; i < size ; i++){ if (elementData[i].equals(o)){ return i;}
}
}else { for (int i = 0 ; i < size ; i++){ if (elementData[i] == null) { return i;
}
}
} return -1;
}
å¤æä¼ å ¥çå ç´ æ¯å¦ä¸ºnullï¼å¦æ为nullï¼åä¾æ¬¡ä¸nullãå¦æä¸ä¸ºç©ºï¼åç¨equalsä¾æ¬¡æ¯è¾ãå¹é æåå°±è¿åä¸æ ï¼å¹é 失败就è¿å-1ãcontainsæ¹æ³
containsç¨æ¥å¤æ该容å¨ä¸æ¯å¦å å«æå®çå ç´ ãå¨æäºindexOfæ¹æ³çåºç¡ä¸ï¼containsçå®ç°å°±å¾ç®åäºã
public boolean contains(Object o){ return indexOf(o) >= 0;}
sizeæ¹æ³sizeæ¹æ³ç¨æ¥å¾å°å®¹å¨ç±»çå ç´ ä¸ªæ°ï¼å®ç°å¾ç®åï¼ç´æ¥è¿åsizeç大å°å³å¯ã
public int size(){ return size;}
isEmptyæ¹æ³isEmptyæ¹æ³ç¨æ¥å¤æ容å¨æ¯å¦ä¸ºç©ºï¼å¤æsizeæ¹æ³çè¿åå¼æ¯å¦ä¸º0å³å¯ã
public boolean isEmpty(){ return size() == 0;}
removeæ¹æ³removeæ¹æ³æ¯ç¨æ¥å¯¹å®¹å¨ç±»çå ç´ è¿è¡å é¤ï¼ä¸addä¸æ ·ï¼removeæ¹æ³ä¹æ两个éè½½æ¹æ³ï¼åå«æ¯
remove(Object o)åremove(int index)
public E remove(int index) {E value = get(index); int moveSize = size - index - 1; if (moveSize > 0){
System.arraycopy(elementData,index + 1, elementData,index,size - index - 1);
}
elementData[--size] = null; return value;
}
public boolean remove(Object o){ if (contains(o)){
remove(indexOf(o)); return true;
}else { return false;
}
}
第ä¸ä¸ªremoveæ¹æ³æ¯æ ¸å¿æ¹æ³ï¼é¦å å¾å°è¦å é¤çä¸æ å ç´ çå¼ï¼ç¶åå¤æindexåé¢çè¦å移çå ç´ ç个æ°ï¼å¦æ个æ°å¤§äºé¶ï¼åè°ç¨åºæ¹æ³ï¼å°indexåé¢çå ç´ åå移ä¸ä½ãæåelementData[--size] = null;缩åsize大å°ï¼å¹¶å°åæåä¸ä½ç½®ç©ºã第äºä¸ªremoveæ¹æ³ä¸éè¦å第ä¸ä¸ªæ¹æ³ä¸æ ·ï¼éè¦åè¯ä½¿ç¨è è¦å é¤çä¸æ 对åºçå ç´ ï¼åªéè¦å¤ææ¯å¦å é¤æåå³å¯ãå¦æè¦å é¤çå ç´ å¨å表ä¸ï¼åå é¤æåï¼å¦æä¸å¨å失败ãå æ¤è°ç¨containsæ¹æ³å°±å¯ä»¥å¤ææ¯å¦è¦å é¤çå ç´ å¨å表ä¸ãå¨åè°ç¨remove(int index),ä¸å¨åè¿å失败ã