1291 |
|
public Spliterator<E> spliterator() { |
1292 |
|
checkForComodification(); |
1293 |
|
|
1294 |
< |
// ArrayListSpliterator is not used because late-binding logic |
1295 |
< |
// is different here |
1296 |
< |
return new Spliterator<>() { |
1294 |
> |
// ArrayListSpliterator not used here due to late-binding |
1295 |
> |
return new Spliterator<E>() { |
1296 |
|
private int index = offset; // current index, modified on advance/split |
1297 |
|
private int fence = -1; // -1 until used; then one past last index |
1298 |
|
private int expectedModCount; // initialized when fence set |
1306 |
|
return hi; |
1307 |
|
} |
1308 |
|
|
1309 |
< |
public ArrayListSpliterator<E> trySplit() { |
1309 |
> |
public ArrayList<E>.ArrayListSpliterator trySplit() { |
1310 |
|
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; |
1311 |
< |
// ArrayListSpliterator could be used here as the source is already bound |
1311 |
> |
// ArrayListSpliterator can be used here as the source is already bound |
1312 |
|
return (lo >= mid) ? null : // divide range in half unless too small |
1313 |
< |
new ArrayListSpliterator<>(root, lo, index = mid, |
1315 |
< |
expectedModCount); |
1313 |
> |
root.new ArrayListSpliterator(lo, index = mid, expectedModCount); |
1314 |
|
} |
1315 |
|
|
1316 |
|
public boolean tryAdvance(Consumer<? super E> action) { |
1352 |
|
} |
1353 |
|
|
1354 |
|
public long estimateSize() { |
1355 |
< |
return (long) (getFence() - index); |
1355 |
> |
return getFence() - index; |
1356 |
|
} |
1357 |
|
|
1358 |
|
public int characteristics() { |
1389 |
|
*/ |
1390 |
|
@Override |
1391 |
|
public Spliterator<E> spliterator() { |
1392 |
< |
return new ArrayListSpliterator<>(this, 0, -1, 0); |
1392 |
> |
return new ArrayListSpliterator(0, -1, 0); |
1393 |
|
} |
1394 |
|
|
1395 |
|
/** Index-based split-by-two, lazily initialized Spliterator */ |
1396 |
< |
static final class ArrayListSpliterator<E> implements Spliterator<E> { |
1396 |
> |
final class ArrayListSpliterator implements Spliterator<E> { |
1397 |
|
|
1398 |
|
/* |
1399 |
|
* If ArrayLists were immutable, or structurally immutable (no |
1427 |
|
* these streamlinings. |
1428 |
|
*/ |
1429 |
|
|
1432 |
– |
private final ArrayList<E> list; |
1430 |
|
private int index; // current index, modified on advance/split |
1431 |
|
private int fence; // -1 until used; then one past last index |
1432 |
|
private int expectedModCount; // initialized when fence set |
1433 |
|
|
1434 |
|
/** Create new spliterator covering the given range */ |
1435 |
< |
ArrayListSpliterator(ArrayList<E> list, int origin, int fence, |
1439 |
< |
int expectedModCount) { |
1440 |
< |
this.list = list; // OK if null unless traversed |
1435 |
> |
ArrayListSpliterator(int origin, int fence, int expectedModCount) { |
1436 |
|
this.index = origin; |
1437 |
|
this.fence = fence; |
1438 |
|
this.expectedModCount = expectedModCount; |
1440 |
|
|
1441 |
|
private int getFence() { // initialize fence to size on first use |
1442 |
|
int hi; // (a specialized variant appears in method forEach) |
1448 |
– |
ArrayList<E> lst; |
1443 |
|
if ((hi = fence) < 0) { |
1444 |
< |
if ((lst = list) == null) |
1445 |
< |
hi = fence = 0; |
1452 |
< |
else { |
1453 |
< |
expectedModCount = lst.modCount; |
1454 |
< |
hi = fence = lst.size; |
1455 |
< |
} |
1444 |
> |
expectedModCount = modCount; |
1445 |
> |
hi = fence = size; |
1446 |
|
} |
1447 |
|
return hi; |
1448 |
|
} |
1449 |
|
|
1450 |
< |
public ArrayListSpliterator<E> trySplit() { |
1450 |
> |
public ArrayListSpliterator trySplit() { |
1451 |
|
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; |
1452 |
|
return (lo >= mid) ? null : // divide range in half unless too small |
1453 |
< |
new ArrayListSpliterator<>(list, lo, index = mid, |
1464 |
< |
expectedModCount); |
1453 |
> |
new ArrayListSpliterator(lo, index = mid, expectedModCount); |
1454 |
|
} |
1455 |
|
|
1456 |
|
public boolean tryAdvance(Consumer<? super E> action) { |
1459 |
|
int hi = getFence(), i = index; |
1460 |
|
if (i < hi) { |
1461 |
|
index = i + 1; |
1462 |
< |
@SuppressWarnings("unchecked") E e = (E)list.elementData[i]; |
1462 |
> |
@SuppressWarnings("unchecked") E e = (E)elementData[i]; |
1463 |
|
action.accept(e); |
1464 |
< |
if (list.modCount != expectedModCount) |
1464 |
> |
if (modCount != expectedModCount) |
1465 |
|
throw new ConcurrentModificationException(); |
1466 |
|
return true; |
1467 |
|
} |
1470 |
|
|
1471 |
|
public void forEachRemaining(Consumer<? super E> action) { |
1472 |
|
int i, hi, mc; // hoist accesses and checks from loop |
1473 |
< |
ArrayList<E> lst; Object[] a; |
1473 |
> |
Object[] a; |
1474 |
|
if (action == null) |
1475 |
|
throw new NullPointerException(); |
1476 |
< |
if ((lst = list) != null && (a = lst.elementData) != null) { |
1476 |
> |
if ((a = elementData) != null) { |
1477 |
|
if ((hi = fence) < 0) { |
1478 |
< |
mc = lst.modCount; |
1479 |
< |
hi = lst.size; |
1478 |
> |
mc = modCount; |
1479 |
> |
hi = size; |
1480 |
|
} |
1481 |
|
else |
1482 |
|
mc = expectedModCount; |
1485 |
|
@SuppressWarnings("unchecked") E e = (E) a[i]; |
1486 |
|
action.accept(e); |
1487 |
|
} |
1488 |
< |
if (lst.modCount == mc) |
1488 |
> |
if (modCount == mc) |
1489 |
|
return; |
1490 |
|
} |
1491 |
|
} |
1493 |
|
} |
1494 |
|
|
1495 |
|
public long estimateSize() { |
1496 |
< |
return (long) (getFence() - index); |
1496 |
> |
return getFence() - index; |
1497 |
|
} |
1498 |
|
|
1499 |
|
public int characteristics() { |