1.å¦ä½èªå·±å®ç°ä¸ä¸ªç®åçArrayList
2.java 中ArrayList集合用indexof方法返回元素的索引 如果元素是重复的 应该返回哪个索引?
3.关于 List 的线程不安全
4.Java里面elementData 和elementDats有什么区别吗?
å¦ä½èªå·±å®ç°ä¸ä¸ªç®åç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),ä¸å¨åè¿å失败ã
java 中ArrayList集合用indexof方法返回元素的索引 如果元素是重复的 应该返回哪个索引?
以下是indexOf的源代码,可以看出, 是从0往后找,找到就返回
/
*** Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
关于 List 的线程不安全
讨论 List 数据结构在多线程环境下的安全性问题。首先,答案是否定的,因为 List 类在 Java 中并未提供线程安全的实现,以牺牲一致性保证了效率。filedisk源码分析以 ArrayList 为例,溯源码体系其核心方法 add(E e) 未加锁,如源码所示:
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
为提升性能和并发性,未对并发操作进行同步处理,从而可能导致并发修改异常(ConcurrentModificationException)。通过在模拟代码中执行并发添加操作即可复现该异常。
针对此问题,有以下几种解决策略:
1. **使用 Vector**:Vector 类提供了线程安全的尾数的源码 add 方法,通过 synchronized 关键字对方法进行同步,确保并发安全。但其性能表现低于无锁的实现,特别是后天源码在高并发场景下。
2. **利用 Collections.synchronizedList()**:此方法通过将非线程安全的 List 实例包装为同步的 List 实例,提供了一个简单的解决方式。通过以下代码即可实现:
java
List list = Collections.synchronizedList(new ArrayList());
3. **采用 CopyOnWriteArrayList**:此类在添加元素时不会修改原有数据结构,而是武器代源码在添加后创建新的数据结构副本。核心源码揭示了这一实现机制,具体为使用 ReentrantLock 上锁,复制现有数组,添加元素至新数组,并最终释放锁。
综上所述,解决 List 类线程不安全问题的常见策略包括使用 Vector、Collections.synchronizedList() 方法或 CopyOnWriteArrayList 类。每种方法都有其适用场景和性能考量,开发者应根据具体需求选择合适的解决方案。
Java里面elementData 和elementDats有什么区别吗?
直接看源码,可以看到的是,ArrayList有三个构造函数:
无参构造:
无参构造时,Obeject数组elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
当其为有参构造时:会有两种情况:
给定初始容量构造:
源码具体逻辑如下:
当 传入的初始容量initialCapacity > 0为真时,创建一个大小为initialCapacity的空数组,并将引用赋给elementData;
当 传入的初始容量initialCapacity = 0为真时,将空数组EMPTY_ELEMENTDATA赋给elementData;
当 传入的初始容量initialCapacity < 0为真时,直接抛出IllegalArgumentException异常。
2024-12-23 06:552501人浏览
2024-12-23 06:461998人浏览
2024-12-23 06:351986人浏览
2024-12-23 06:30479人浏览
2024-12-23 05:372167人浏览
2024-12-23 05:052173人浏览
一項利用美國「毅力」號火星車探測數據開展的新研究發現,火星赤道以北的耶澤羅隕石坑在遠古時期曾存在一個巨大的湖泊和河流三角洲。隨着時間推移,隕石坑內沉積物的沉積和侵蝕形成今天的地質構造。來源:央視新聞)
1.网上订餐系统什么的最好,php的怎么样?2.DV4-5314不能进U盘模式,设置成在UFEI模式下的启动顺序为U盘系统,但是相容模式下是硬盘为第一启动,而且3.2021年软件工程专业本科论文选题硕