ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/ArrayList.java

Comparing jsr166/src/main/java/util/ArrayList.java (file contents):
Revision 1.59 by jsr166, Sun May 6 01:14:25 2018 UTC vs.
Revision 1.60 by jsr166, Wed May 16 16:18:00 2018 UTC

#	Line 314 | Line 314 | public class ArrayList<E> extends Abstra
314		* or -1 if there is no such index.
315		*/
316		public int indexOf(Object o) {
317	+	return indexOfRange(o, 0, size);
318	+	}
319	+
320	+	int indexOfRange(Object o, int start, int end) {
321	+	Object[] es = elementData;
322		if (o == null) {
323	<	for (int i = 0; i < size; i++)
324	<	if (elementData[i]==null)
323	>	for (int i = start; i < end; i++) {
324	>	if (es[i] == null) {
325		return i;
326	+	}
327	+	}
328		} else {
329	<	for (int i = 0; i < size; i++)
330	<	if (o.equals(elementData[i]))
329	>	for (int i = start; i < end; i++) {
330	>	if (o.equals(es[i])) {
331		return i;
332	+	}
333	+	}
334		}
335		return -1;
336		}
#	Line 334 | Line 343 | public class ArrayList<E> extends Abstra
343		* or -1 if there is no such index.
344		*/
345		public int lastIndexOf(Object o) {
346	+	return lastIndexOfRange(o, 0, size);
347	+	}
348	+
349	+	int lastIndexOfRange(Object o, int start, int end) {
350	+	Object[] es = elementData;
351		if (o == null) {
352	<	for (int i = size-1; i >= 0; i--)
353	<	if (elementData[i]==null)
352	>	for (int i = end - 1; i >= start; i--) {
353	>	if (es[i] == null) {
354		return i;
355	+	}
356	+	}
357		} else {
358	<	for (int i = size-1; i >= 0; i--)
359	<	if (o.equals(elementData[i]))
358	>	for (int i = end - 1; i >= start; i--) {
359	>	if (o.equals(es[i])) {
360		return i;
361	+	}
362	+	}
363		}
364		return -1;
365		}
#	Line 526 | Line 544 | public class ArrayList<E> extends Abstra
544		}
545
546		/**
547	+	* {@inheritDoc}
548	+	*/
549	+	public boolean equals(Object o) {
550	+	if (o == this) {
551	+	return true;
552	+	}
553	+
554	+	if (!(o instanceof List)) {
555	+	return false;
556	+	}
557	+
558	+	final int expectedModCount = modCount;
559	+	// ArrayList can be subclassed and given arbitrary behavior, but we can
560	+	// still deal with the common case where o is ArrayList precisely
561	+	boolean equal = (o.getClass() == ArrayList.class)
562	+	? equalsArrayList((ArrayList<?>) o)
563	+	: equalsRange((List<?>) o, 0, size);
564	+
565	+	checkForComodification(expectedModCount);
566	+	return equal;
567	+	}
568	+
569	+	boolean equalsRange(List<?> other, int from, int to) {
570	+	final Object[] es = elementData;
571	+	if (to > es.length) {
572	+	throw new ConcurrentModificationException();
573	+	}
574	+	var oit = other.iterator();
575	+	for (; from < to; from++) {
576	+	if (!oit.hasNext() || !Objects.equals(es[from], oit.next())) {
577	+	return false;
578	+	}
579	+	}
580	+	return !oit.hasNext();
581	+	}
582	+
583	+	private boolean equalsArrayList(ArrayList<?> other) {
584	+	final int otherModCount = other.modCount;
585	+	final int s = size;
586	+	boolean equal;
587	+	if (equal = (s == other.size)) {
588	+	final Object[] otherEs = other.elementData;
589	+	final Object[] es = elementData;
590	+	if (s > es.length || s > otherEs.length) {
591	+	throw new ConcurrentModificationException();
592	+	}
593	+	for (int i = 0; i < s; i++) {
594	+	if (!Objects.equals(es[i], otherEs[i])) {
595	+	equal = false;
596	+	break;
597	+	}
598	+	}
599	+	}
600	+	other.checkForComodification(otherModCount);
601	+	return equal;
602	+	}
603	+
604	+	private void checkForComodification(final int expectedModCount) {
605	+	if (modCount != expectedModCount) {
606	+	throw new ConcurrentModificationException();
607	+	}
608	+	}
609	+
610	+	/**
611	+	* {@inheritDoc}
612	+	*/
613	+	public int hashCode() {
614	+	int expectedModCount = modCount;
615	+	int hash = hashCodeRange(0, size);
616	+	checkForComodification(expectedModCount);
617	+	return hash;
618	+	}
619	+
620	+	int hashCodeRange(int from, int to) {
621	+	final Object[] es = elementData;
622	+	if (to > es.length) {
623	+	throw new ConcurrentModificationException();
624	+	}
625	+	int hashCode = 1;
626	+	for (int i = from; i < to; i++) {
627	+	Object e = es[i];
628	+	hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
629	+	}
630	+	return hashCode;
631	+	}
632	+
633	+	/**
634		* Removes the first occurrence of the specified element from this list,
635		* if it is present.  If the list does not contain the element, it is
636		* unchanged.  More formally, removes the element with the lowest index
#	Line 1170 | Line 1275 | public class ArrayList<E> extends Abstra
1275		return a;
1276		}
1277
1278	+	public boolean equals(Object o) {
1279	+	if (o == this) {
1280	+	return true;
1281	+	}
1282	+
1283	+	if (!(o instanceof List)) {
1284	+	return false;
1285	+	}
1286	+
1287	+	boolean equal = root.equalsRange((List<?>)o, offset, offset + size);
1288	+	checkForComodification();
1289	+	return equal;
1290	+	}
1291	+
1292	+	public int hashCode() {
1293	+	int hash = root.hashCodeRange(offset, offset + size);
1294	+	checkForComodification();
1295	+	return hash;
1296	+	}
1297	+
1298	+	public int indexOf(Object o) {
1299	+	int index = root.indexOfRange(o, offset, offset + size);
1300	+	checkForComodification();
1301	+	return index >= 0 ? index - offset : -1;
1302	+	}
1303	+
1304	+	public int lastIndexOf(Object o) {
1305	+	int index = root.lastIndexOfRange(o, offset, offset + size);
1306	+	checkForComodification();
1307	+	return index >= 0 ? index - offset : -1;
1308	+	}
1309	+
1310	+	public boolean contains(Object o) {
1311	+	return indexOf(o) >= 0;
1312	+	}
1313	+
1314		public Iterator<E> iterator() {
1315		return listIterator();
1316		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines