134 |
|
* to ensure that it can hold at least the given number of elements. |
135 |
|
* |
136 |
|
* @param minCapacity the desired minimum capacity |
137 |
< |
* @since 9 |
137 |
> |
* @since TBD |
138 |
|
*/ |
139 |
< |
public void ensureCapacity(int minCapacity) { |
139 |
> |
/* public */ void ensureCapacity(int minCapacity) { |
140 |
|
if (minCapacity > elements.length) |
141 |
|
grow(minCapacity - elements.length); |
142 |
|
// checkInvariants(); |
145 |
|
/** |
146 |
|
* Minimizes the internal storage of this collection. |
147 |
|
* |
148 |
< |
* @since 9 |
148 |
> |
* @since TBD |
149 |
|
*/ |
150 |
< |
public void trimToSize() { |
150 |
> |
/* public */ void trimToSize() { |
151 |
|
if (size < elements.length) { |
152 |
|
elements = toArray(); |
153 |
|
head = 0; |
196 |
|
} |
197 |
|
|
198 |
|
/** |
199 |
– |
* Returns the array index of the last element. |
200 |
– |
* May return invalid index -1 if there are no elements. |
201 |
– |
*/ |
202 |
– |
final int tail() { |
203 |
– |
return add(head, size - 1, elements.length); |
204 |
– |
} |
205 |
– |
|
206 |
– |
/** |
207 |
– |
* Adds i and j, mod modulus. |
208 |
– |
* Precondition and postcondition: 0 <= i < modulus, 0 <= j <= modulus. |
209 |
– |
*/ |
210 |
– |
static final int add(int i, int j, int modulus) { |
211 |
– |
if ((i += j) - modulus >= 0) i -= modulus; |
212 |
– |
return i; |
213 |
– |
} |
214 |
– |
|
215 |
– |
/** |
199 |
|
* Increments i, mod modulus. |
200 |
|
* Precondition and postcondition: 0 <= i < modulus. |
201 |
|
*/ |
214 |
|
} |
215 |
|
|
216 |
|
/** |
217 |
+ |
* Adds i and j, mod modulus. |
218 |
+ |
* Precondition and postcondition: 0 <= i < modulus, 0 <= j <= modulus. |
219 |
+ |
*/ |
220 |
+ |
static final int add(int i, int j, int modulus) { |
221 |
+ |
if ((i += j) - modulus >= 0) i -= modulus; |
222 |
+ |
return i; |
223 |
+ |
} |
224 |
+ |
|
225 |
+ |
/** |
226 |
+ |
* Returns the array index of the last element. |
227 |
+ |
* May return invalid index -1 if there are no elements. |
228 |
+ |
*/ |
229 |
+ |
final int tail() { |
230 |
+ |
return add(head, size - 1, elements.length); |
231 |
+ |
} |
232 |
+ |
|
233 |
+ |
/** |
234 |
|
* Returns element at array index i. |
235 |
|
*/ |
236 |
|
@SuppressWarnings("unchecked") |
305 |
|
public boolean addAll(Collection<? extends E> c) { |
306 |
|
// checkInvariants(); |
307 |
|
Object[] a, elements; |
308 |
< |
int len, capacity, s = size; |
309 |
< |
if ((len = (a = c.toArray()).length) == 0) |
308 |
> |
int newcomers, capacity, s = size; |
309 |
> |
if ((newcomers = (a = c.toArray()).length) == 0) |
310 |
|
return false; |
311 |
< |
while ((capacity = (elements = this.elements).length) - s < len) |
312 |
< |
grow(len - (capacity - s)); |
311 |
> |
while ((capacity = (elements = this.elements).length) - s < newcomers) |
312 |
> |
grow(newcomers - (capacity - s)); |
313 |
|
int i = add(head, s, capacity); |
314 |
|
for (Object x : a) { |
315 |
|
Objects.requireNonNull(x); |
845 |
|
* operator to that element, as specified by {@link List#replaceAll}. |
846 |
|
* |
847 |
|
* @param operator the operator to apply to each element |
848 |
< |
* @since 9 |
848 |
> |
* @since TBD |
849 |
|
*/ |
850 |
< |
public void replaceAll(UnaryOperator<E> operator) { |
850 |
> |
/* public */ void replaceAll(UnaryOperator<E> operator) { |
851 |
|
Objects.requireNonNull(operator); |
852 |
|
final Object[] elements = this.elements; |
853 |
|
final int capacity = elements.length; |
902 |
|
} |
903 |
|
return deleted > 0; |
904 |
|
} catch (Throwable ex) { |
905 |
< |
for (; remaining > 0; |
906 |
< |
remaining--, i = inc(i, capacity), j = inc(j, capacity)) |
907 |
< |
elements[j] = elements[i]; |
905 |
> |
if (deleted > 0) |
906 |
> |
for (; remaining > 0; |
907 |
> |
remaining--, i = inc(i, capacity), j = inc(j, capacity)) |
908 |
> |
elements[j] = elements[i]; |
909 |
|
throw ex; |
910 |
|
} finally { |
911 |
|
size -= deleted; |