author | rriggs |
Sat, 01 Mar 2014 11:57:57 -0500 | |
changeset 23040 | 0cb50d5761df |
parent 23024 | 7d5ecb31115f |
permissions | -rw-r--r-- |
2 | 1 |
/* |
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16742
diff
changeset
|
2 |
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. |
2 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
package java.lang; |
|
27 |
||
28 |
import sun.misc.FloatingDecimal; |
|
29 |
import java.util.Arrays; |
|
30 |
||
31 |
/** |
|
32 |
* A mutable sequence of characters. |
|
33 |
* <p> |
|
34 |
* Implements a modifiable string. At any point in time it contains some |
|
35 |
* particular sequence of characters, but the length and content of the |
|
36 |
* sequence can be changed through certain method calls. |
|
37 |
* |
|
15312
4b57f9da8192
4247235: (spec str) StringBuffer.insert(int, char[]) specification is inconsistent
jgish
parents:
14997
diff
changeset
|
38 |
* <p>Unless otherwise noted, passing a {@code null} argument to a constructor |
4b57f9da8192
4247235: (spec str) StringBuffer.insert(int, char[]) specification is inconsistent
jgish
parents:
14997
diff
changeset
|
39 |
* or method in this class will cause a {@link NullPointerException} to be |
4b57f9da8192
4247235: (spec str) StringBuffer.insert(int, char[]) specification is inconsistent
jgish
parents:
14997
diff
changeset
|
40 |
* thrown. |
4b57f9da8192
4247235: (spec str) StringBuffer.insert(int, char[]) specification is inconsistent
jgish
parents:
14997
diff
changeset
|
41 |
* |
2 | 42 |
* @author Michael McCloskey |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
43 |
* @author Martin Buchholz |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
44 |
* @author Ulf Zibis |
2 | 45 |
* @since 1.5 |
46 |
*/ |
|
47 |
abstract class AbstractStringBuilder implements Appendable, CharSequence { |
|
48 |
/** |
|
49 |
* The value is used for character storage. |
|
50 |
*/ |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
51 |
char[] value; |
2 | 52 |
|
53 |
/** |
|
54 |
* The count is the number of characters used. |
|
55 |
*/ |
|
56 |
int count; |
|
57 |
||
58 |
/** |
|
59 |
* This no-arg constructor is necessary for serialization of subclasses. |
|
60 |
*/ |
|
61 |
AbstractStringBuilder() { |
|
62 |
} |
|
63 |
||
64 |
/** |
|
65 |
* Creates an AbstractStringBuilder of the specified capacity. |
|
66 |
*/ |
|
67 |
AbstractStringBuilder(int capacity) { |
|
68 |
value = new char[capacity]; |
|
69 |
} |
|
70 |
||
71 |
/** |
|
72 |
* Returns the length (character count). |
|
73 |
* |
|
74 |
* @return the length of the sequence of characters currently |
|
75 |
* represented by this object |
|
76 |
*/ |
|
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
77 |
@Override |
2 | 78 |
public int length() { |
79 |
return count; |
|
80 |
} |
|
81 |
||
82 |
/** |
|
83 |
* Returns the current capacity. The capacity is the amount of storage |
|
84 |
* available for newly inserted characters, beyond which an allocation |
|
85 |
* will occur. |
|
86 |
* |
|
87 |
* @return the current capacity |
|
88 |
*/ |
|
89 |
public int capacity() { |
|
90 |
return value.length; |
|
91 |
} |
|
92 |
||
93 |
/** |
|
94 |
* Ensures that the capacity is at least equal to the specified minimum. |
|
95 |
* If the current capacity is less than the argument, then a new internal |
|
96 |
* array is allocated with greater capacity. The new capacity is the |
|
97 |
* larger of: |
|
98 |
* <ul> |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
99 |
* <li>The {@code minimumCapacity} argument. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
100 |
* <li>Twice the old capacity, plus {@code 2}. |
2 | 101 |
* </ul> |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
102 |
* If the {@code minimumCapacity} argument is nonpositive, this |
2 | 103 |
* method takes no action and simply returns. |
13821
02266c2bf3a8
4722265: (spec str) StringBuffer.ensureCapacity() should mention that capacity is mutable
jgish
parents:
11676
diff
changeset
|
104 |
* Note that subsequent operations on this object can reduce the |
02266c2bf3a8
4722265: (spec str) StringBuffer.ensureCapacity() should mention that capacity is mutable
jgish
parents:
11676
diff
changeset
|
105 |
* actual capacity below that requested here. |
2 | 106 |
* |
107 |
* @param minimumCapacity the minimum desired capacity. |
|
108 |
*/ |
|
109 |
public void ensureCapacity(int minimumCapacity) { |
|
7020
25638687fe82
6992121: StringBuilder.ensureCapacity(int minCap) throws OutOfMemoryError with minCap=Integer.MIN_VALUE
mchung
parents:
6295
diff
changeset
|
110 |
if (minimumCapacity > 0) |
25638687fe82
6992121: StringBuilder.ensureCapacity(int minCap) throws OutOfMemoryError with minCap=Integer.MIN_VALUE
mchung
parents:
6295
diff
changeset
|
111 |
ensureCapacityInternal(minimumCapacity); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
112 |
} |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
113 |
|
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
114 |
/** |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
115 |
* This method has the same contract as ensureCapacity, but is |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
116 |
* never synchronized. |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
117 |
*/ |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
118 |
private void ensureCapacityInternal(int minimumCapacity) { |
7020
25638687fe82
6992121: StringBuilder.ensureCapacity(int minCap) throws OutOfMemoryError with minCap=Integer.MIN_VALUE
mchung
parents:
6295
diff
changeset
|
119 |
// overflow-conscious code |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
120 |
if (minimumCapacity - value.length > 0) |
2 | 121 |
expandCapacity(minimumCapacity); |
122 |
} |
|
123 |
||
124 |
/** |
|
125 |
* This implements the expansion semantics of ensureCapacity with no |
|
126 |
* size check or synchronization. |
|
127 |
*/ |
|
128 |
void expandCapacity(int minimumCapacity) { |
|
5603
682e3deac7ce
6952330: Fix for 6933217 broke contract of StringBuffer.ensureCapacity
martin
parents:
5466
diff
changeset
|
129 |
int newCapacity = value.length * 2 + 2; |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
130 |
if (newCapacity - minimumCapacity < 0) |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
131 |
newCapacity = minimumCapacity; |
2 | 132 |
if (newCapacity < 0) { |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
133 |
if (minimumCapacity < 0) // overflow |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
134 |
throw new OutOfMemoryError(); |
2 | 135 |
newCapacity = Integer.MAX_VALUE; |
136 |
} |
|
137 |
value = Arrays.copyOf(value, newCapacity); |
|
138 |
} |
|
139 |
||
140 |
/** |
|
141 |
* Attempts to reduce storage used for the character sequence. |
|
142 |
* If the buffer is larger than necessary to hold its current sequence of |
|
143 |
* characters, then it may be resized to become more space efficient. |
|
144 |
* Calling this method may, but is not required to, affect the value |
|
145 |
* returned by a subsequent call to the {@link #capacity()} method. |
|
146 |
*/ |
|
147 |
public void trimToSize() { |
|
148 |
if (count < value.length) { |
|
149 |
value = Arrays.copyOf(value, count); |
|
150 |
} |
|
151 |
} |
|
152 |
||
153 |
/** |
|
154 |
* Sets the length of the character sequence. |
|
155 |
* The sequence is changed to a new character sequence |
|
156 |
* whose length is specified by the argument. For every nonnegative |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
157 |
* index <i>k</i> less than {@code newLength}, the character at |
2 | 158 |
* index <i>k</i> in the new character sequence is the same as the |
159 |
* character at index <i>k</i> in the old sequence if <i>k</i> is less |
|
160 |
* than the length of the old character sequence; otherwise, it is the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
161 |
* null character {@code '\u005Cu0000'}. |
2 | 162 |
* |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
163 |
* In other words, if the {@code newLength} argument is less than |
2 | 164 |
* the current length, the length is changed to the specified length. |
165 |
* <p> |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
166 |
* If the {@code newLength} argument is greater than or equal |
2 | 167 |
* to the current length, sufficient null characters |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
168 |
* ({@code '\u005Cu0000'}) are appended so that |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
169 |
* length becomes the {@code newLength} argument. |
2 | 170 |
* <p> |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
171 |
* The {@code newLength} argument must be greater than or equal |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
172 |
* to {@code 0}. |
2 | 173 |
* |
174 |
* @param newLength the new length |
|
175 |
* @throws IndexOutOfBoundsException if the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
176 |
* {@code newLength} argument is negative. |
2 | 177 |
*/ |
178 |
public void setLength(int newLength) { |
|
179 |
if (newLength < 0) |
|
180 |
throw new StringIndexOutOfBoundsException(newLength); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
181 |
ensureCapacityInternal(newLength); |
2 | 182 |
|
183 |
if (count < newLength) { |
|
14686
fb59583d33b2
6553074: String{Buffer,Builder}.indexOf(Str, int) contains unnecessary allocation
mduigou
parents:
14332
diff
changeset
|
184 |
Arrays.fill(value, count, newLength, '\0'); |
2 | 185 |
} |
14686
fb59583d33b2
6553074: String{Buffer,Builder}.indexOf(Str, int) contains unnecessary allocation
mduigou
parents:
14332
diff
changeset
|
186 |
|
fb59583d33b2
6553074: String{Buffer,Builder}.indexOf(Str, int) contains unnecessary allocation
mduigou
parents:
14332
diff
changeset
|
187 |
count = newLength; |
2 | 188 |
} |
189 |
||
190 |
/** |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
191 |
* Returns the {@code char} value in this sequence at the specified index. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
192 |
* The first {@code char} value is at index {@code 0}, the next at index |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
193 |
* {@code 1}, and so on, as in array indexing. |
2 | 194 |
* <p> |
195 |
* The index argument must be greater than or equal to |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
196 |
* {@code 0}, and less than the length of this sequence. |
2 | 197 |
* |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
198 |
* <p>If the {@code char} value specified by the index is a |
2 | 199 |
* <a href="Character.html#unicode">surrogate</a>, the surrogate |
200 |
* value is returned. |
|
201 |
* |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
202 |
* @param index the index of the desired {@code char} value. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
203 |
* @return the {@code char} value at the specified index. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
204 |
* @throws IndexOutOfBoundsException if {@code index} is |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
205 |
* negative or greater than or equal to {@code length()}. |
2 | 206 |
*/ |
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
207 |
@Override |
2 | 208 |
public char charAt(int index) { |
209 |
if ((index < 0) || (index >= count)) |
|
210 |
throw new StringIndexOutOfBoundsException(index); |
|
211 |
return value[index]; |
|
212 |
} |
|
213 |
||
214 |
/** |
|
215 |
* Returns the character (Unicode code point) at the specified |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
216 |
* index. The index refers to {@code char} values |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
217 |
* (Unicode code units) and ranges from {@code 0} to |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
218 |
* {@link #length()}{@code - 1}. |
2 | 219 |
* |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
220 |
* <p> If the {@code char} value specified at the given index |
2 | 221 |
* is in the high-surrogate range, the following index is less |
222 |
* than the length of this sequence, and the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
223 |
* {@code char} value at the following index is in the |
2 | 224 |
* low-surrogate range, then the supplementary code point |
225 |
* corresponding to this surrogate pair is returned. Otherwise, |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
226 |
* the {@code char} value at the given index is returned. |
2 | 227 |
* |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
228 |
* @param index the index to the {@code char} values |
2 | 229 |
* @return the code point value of the character at the |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
230 |
* {@code index} |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
231 |
* @exception IndexOutOfBoundsException if the {@code index} |
2 | 232 |
* argument is negative or not less than the length of this |
233 |
* sequence. |
|
234 |
*/ |
|
235 |
public int codePointAt(int index) { |
|
236 |
if ((index < 0) || (index >= count)) { |
|
237 |
throw new StringIndexOutOfBoundsException(index); |
|
238 |
} |
|
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
239 |
return Character.codePointAtImpl(value, index, count); |
2 | 240 |
} |
241 |
||
242 |
/** |
|
243 |
* Returns the character (Unicode code point) before the specified |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
244 |
* index. The index refers to {@code char} values |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
245 |
* (Unicode code units) and ranges from {@code 1} to {@link |
2 | 246 |
* #length()}. |
247 |
* |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
248 |
* <p> If the {@code char} value at {@code (index - 1)} |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
249 |
* is in the low-surrogate range, {@code (index - 2)} is not |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
250 |
* negative, and the {@code char} value at {@code (index - |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
251 |
* 2)} is in the high-surrogate range, then the |
2 | 252 |
* supplementary code point value of the surrogate pair is |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
253 |
* returned. If the {@code char} value at {@code index - |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
254 |
* 1} is an unpaired low-surrogate or a high-surrogate, the |
2 | 255 |
* surrogate value is returned. |
256 |
* |
|
257 |
* @param index the index following the code point that should be returned |
|
258 |
* @return the Unicode code point value before the given index. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
259 |
* @exception IndexOutOfBoundsException if the {@code index} |
2 | 260 |
* argument is less than 1 or greater than the length |
261 |
* of this sequence. |
|
262 |
*/ |
|
263 |
public int codePointBefore(int index) { |
|
264 |
int i = index - 1; |
|
265 |
if ((i < 0) || (i >= count)) { |
|
266 |
throw new StringIndexOutOfBoundsException(index); |
|
267 |
} |
|
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
268 |
return Character.codePointBeforeImpl(value, index, 0); |
2 | 269 |
} |
270 |
||
271 |
/** |
|
272 |
* Returns the number of Unicode code points in the specified text |
|
273 |
* range of this sequence. The text range begins at the specified |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
274 |
* {@code beginIndex} and extends to the {@code char} at |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
275 |
* index {@code endIndex - 1}. Thus the length (in |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
276 |
* {@code char}s) of the text range is |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
277 |
* {@code endIndex-beginIndex}. Unpaired surrogates within |
2 | 278 |
* this sequence count as one code point each. |
279 |
* |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
280 |
* @param beginIndex the index to the first {@code char} of |
2 | 281 |
* the text range. |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
282 |
* @param endIndex the index after the last {@code char} of |
2 | 283 |
* the text range. |
284 |
* @return the number of Unicode code points in the specified text |
|
285 |
* range |
|
286 |
* @exception IndexOutOfBoundsException if the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
287 |
* {@code beginIndex} is negative, or {@code endIndex} |
2 | 288 |
* is larger than the length of this sequence, or |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
289 |
* {@code beginIndex} is larger than {@code endIndex}. |
2 | 290 |
*/ |
291 |
public int codePointCount(int beginIndex, int endIndex) { |
|
292 |
if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) { |
|
293 |
throw new IndexOutOfBoundsException(); |
|
294 |
} |
|
295 |
return Character.codePointCountImpl(value, beginIndex, endIndex-beginIndex); |
|
296 |
} |
|
297 |
||
298 |
/** |
|
299 |
* Returns the index within this sequence that is offset from the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
300 |
* given {@code index} by {@code codePointOffset} code |
2 | 301 |
* points. Unpaired surrogates within the text range given by |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
302 |
* {@code index} and {@code codePointOffset} count as |
2 | 303 |
* one code point each. |
304 |
* |
|
305 |
* @param index the index to be offset |
|
306 |
* @param codePointOffset the offset in code points |
|
307 |
* @return the index within this sequence |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
308 |
* @exception IndexOutOfBoundsException if {@code index} |
2 | 309 |
* is negative or larger then the length of this sequence, |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
310 |
* or if {@code codePointOffset} is positive and the subsequence |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
311 |
* starting with {@code index} has fewer than |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
312 |
* {@code codePointOffset} code points, |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
313 |
* or if {@code codePointOffset} is negative and the subsequence |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
314 |
* before {@code index} has fewer than the absolute value of |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
315 |
* {@code codePointOffset} code points. |
2 | 316 |
*/ |
317 |
public int offsetByCodePoints(int index, int codePointOffset) { |
|
318 |
if (index < 0 || index > count) { |
|
319 |
throw new IndexOutOfBoundsException(); |
|
320 |
} |
|
321 |
return Character.offsetByCodePointsImpl(value, 0, count, |
|
322 |
index, codePointOffset); |
|
323 |
} |
|
324 |
||
325 |
/** |
|
326 |
* Characters are copied from this sequence into the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
327 |
* destination character array {@code dst}. The first character to |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
328 |
* be copied is at index {@code srcBegin}; the last character to |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
329 |
* be copied is at index {@code srcEnd-1}. The total number of |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
330 |
* characters to be copied is {@code srcEnd-srcBegin}. The |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
331 |
* characters are copied into the subarray of {@code dst} starting |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
332 |
* at index {@code dstBegin} and ending at index: |
21334 | 333 |
* <pre>{@code |
2 | 334 |
* dstbegin + (srcEnd-srcBegin) - 1 |
21334 | 335 |
* }</pre> |
2 | 336 |
* |
337 |
* @param srcBegin start copying at this offset. |
|
338 |
* @param srcEnd stop copying at this offset. |
|
339 |
* @param dst the array to copy the data into. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
340 |
* @param dstBegin offset into {@code dst}. |
2 | 341 |
* @throws IndexOutOfBoundsException if any of the following is true: |
342 |
* <ul> |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
343 |
* <li>{@code srcBegin} is negative |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
344 |
* <li>{@code dstBegin} is negative |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
345 |
* <li>the {@code srcBegin} argument is greater than |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
346 |
* the {@code srcEnd} argument. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
347 |
* <li>{@code srcEnd} is greater than |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
348 |
* {@code this.length()}. |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
349 |
* <li>{@code dstBegin+srcEnd-srcBegin} is greater than |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
350 |
* {@code dst.length} |
2 | 351 |
* </ul> |
352 |
*/ |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
353 |
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) |
2 | 354 |
{ |
355 |
if (srcBegin < 0) |
|
356 |
throw new StringIndexOutOfBoundsException(srcBegin); |
|
357 |
if ((srcEnd < 0) || (srcEnd > count)) |
|
358 |
throw new StringIndexOutOfBoundsException(srcEnd); |
|
359 |
if (srcBegin > srcEnd) |
|
360 |
throw new StringIndexOutOfBoundsException("srcBegin > srcEnd"); |
|
361 |
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); |
|
362 |
} |
|
363 |
||
364 |
/** |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
365 |
* The character at the specified index is set to {@code ch}. This |
2 | 366 |
* sequence is altered to represent a new character sequence that is |
367 |
* identical to the old character sequence, except that it contains the |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
368 |
* character {@code ch} at position {@code index}. |
2 | 369 |
* <p> |
370 |
* The index argument must be greater than or equal to |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
371 |
* {@code 0}, and less than the length of this sequence. |
2 | 372 |
* |
373 |
* @param index the index of the character to modify. |
|
374 |
* @param ch the new character. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
375 |
* @throws IndexOutOfBoundsException if {@code index} is |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
376 |
* negative or greater than or equal to {@code length()}. |
2 | 377 |
*/ |
378 |
public void setCharAt(int index, char ch) { |
|
379 |
if ((index < 0) || (index >= count)) |
|
380 |
throw new StringIndexOutOfBoundsException(index); |
|
381 |
value[index] = ch; |
|
382 |
} |
|
383 |
||
384 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
385 |
* Appends the string representation of the {@code Object} argument. |
2 | 386 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
387 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
388 |
* to a string by the method {@link String#valueOf(Object)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
389 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
390 |
* {@link #append(String) appended} to this character sequence. |
2 | 391 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
392 |
* @param obj an {@code Object}. |
2 | 393 |
* @return a reference to this object. |
394 |
*/ |
|
395 |
public AbstractStringBuilder append(Object obj) { |
|
396 |
return append(String.valueOf(obj)); |
|
397 |
} |
|
398 |
||
399 |
/** |
|
400 |
* Appends the specified string to this character sequence. |
|
401 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
402 |
* The characters of the {@code String} argument are appended, in |
2 | 403 |
* order, increasing the length of this sequence by the length of the |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
404 |
* argument. If {@code str} is {@code null}, then the four |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
405 |
* characters {@code "null"} are appended. |
2 | 406 |
* <p> |
407 |
* Let <i>n</i> be the length of this character sequence just prior to |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
408 |
* execution of the {@code append} method. Then the character at |
2 | 409 |
* index <i>k</i> in the new character sequence is equal to the character |
410 |
* at index <i>k</i> in the old character sequence, if <i>k</i> is less |
|
411 |
* than <i>n</i>; otherwise, it is equal to the character at index |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
412 |
* <i>k-n</i> in the argument {@code str}. |
2 | 413 |
* |
414 |
* @param str a string. |
|
415 |
* @return a reference to this object. |
|
416 |
*/ |
|
417 |
public AbstractStringBuilder append(String str) { |
|
16742
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
418 |
if (str == null) |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
419 |
return appendNull(); |
2 | 420 |
int len = str.length(); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
421 |
ensureCapacityInternal(count + len); |
2 | 422 |
str.getChars(0, len, value, count); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
423 |
count += len; |
2 | 424 |
return this; |
425 |
} |
|
426 |
||
427 |
// Documentation in subclasses because of synchro difference |
|
428 |
public AbstractStringBuilder append(StringBuffer sb) { |
|
429 |
if (sb == null) |
|
16742
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
430 |
return appendNull(); |
2 | 431 |
int len = sb.length(); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
432 |
ensureCapacityInternal(count + len); |
2 | 433 |
sb.getChars(0, len, value, count); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
434 |
count += len; |
2 | 435 |
return this; |
436 |
} |
|
437 |
||
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
438 |
/** |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
439 |
* @since 1.8 |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
440 |
*/ |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
441 |
AbstractStringBuilder append(AbstractStringBuilder asb) { |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
442 |
if (asb == null) |
16742
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
443 |
return appendNull(); |
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
444 |
int len = asb.length(); |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
445 |
ensureCapacityInternal(count + len); |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
446 |
asb.getChars(0, len, value, count); |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
447 |
count += len; |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
448 |
return this; |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
449 |
} |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
450 |
|
2 | 451 |
// Documentation in subclasses because of synchro difference |
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
452 |
@Override |
2 | 453 |
public AbstractStringBuilder append(CharSequence s) { |
454 |
if (s == null) |
|
16742
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
455 |
return appendNull(); |
2 | 456 |
if (s instanceof String) |
457 |
return this.append((String)s); |
|
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
458 |
if (s instanceof AbstractStringBuilder) |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
459 |
return this.append((AbstractStringBuilder)s); |
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
460 |
|
2 | 461 |
return this.append(s, 0, s.length()); |
462 |
} |
|
463 |
||
16742
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
464 |
private AbstractStringBuilder appendNull() { |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
465 |
int c = count; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
466 |
ensureCapacityInternal(c + 4); |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
467 |
final char[] value = this.value; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
468 |
value[c++] = 'n'; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
469 |
value[c++] = 'u'; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
470 |
value[c++] = 'l'; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
471 |
value[c++] = 'l'; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
472 |
count = c; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
473 |
return this; |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
474 |
} |
e6b0ac6581f1
8010849: (str) Optimize StringBuilder.append(null)
martin
parents:
16714
diff
changeset
|
475 |
|
2 | 476 |
/** |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
477 |
* Appends a subsequence of the specified {@code CharSequence} to this |
2 | 478 |
* sequence. |
479 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
480 |
* Characters of the argument {@code s}, starting at |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
481 |
* index {@code start}, are appended, in order, to the contents of |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
482 |
* this sequence up to the (exclusive) index {@code end}. The length |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
483 |
* of this sequence is increased by the value of {@code end - start}. |
2 | 484 |
* <p> |
485 |
* Let <i>n</i> be the length of this character sequence just prior to |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
486 |
* execution of the {@code append} method. Then the character at |
2 | 487 |
* index <i>k</i> in this character sequence becomes equal to the |
488 |
* character at index <i>k</i> in this sequence, if <i>k</i> is less than |
|
489 |
* <i>n</i>; otherwise, it is equal to the character at index |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
490 |
* <i>k+start-n</i> in the argument {@code s}. |
2 | 491 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
492 |
* If {@code s} is {@code null}, then this method appends |
2 | 493 |
* characters as if the s parameter was a sequence containing the four |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
494 |
* characters {@code "null"}. |
2 | 495 |
* |
496 |
* @param s the sequence to append. |
|
497 |
* @param start the starting index of the subsequence to be appended. |
|
498 |
* @param end the end index of the subsequence to be appended. |
|
499 |
* @return a reference to this object. |
|
500 |
* @throws IndexOutOfBoundsException if |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
501 |
* {@code start} is negative, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
502 |
* {@code start} is greater than {@code end} or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
503 |
* {@code end} is greater than {@code s.length()} |
2 | 504 |
*/ |
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
505 |
@Override |
2 | 506 |
public AbstractStringBuilder append(CharSequence s, int start, int end) { |
507 |
if (s == null) |
|
508 |
s = "null"; |
|
6295
91f1c55cf47e
6955504: (str) String[Builder/Buffer].append(char[],int,int) throws OutOfMemoryError in b94
martin
parents:
5986
diff
changeset
|
509 |
if ((start < 0) || (start > end) || (end > s.length())) |
2 | 510 |
throw new IndexOutOfBoundsException( |
511 |
"start " + start + ", end " + end + ", s.length() " |
|
512 |
+ s.length()); |
|
513 |
int len = end - start; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
514 |
ensureCapacityInternal(count + len); |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
515 |
for (int i = start, j = count; i < end; i++, j++) |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
516 |
value[j] = s.charAt(i); |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
517 |
count += len; |
2 | 518 |
return this; |
519 |
} |
|
520 |
||
521 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
522 |
* Appends the string representation of the {@code char} array |
2 | 523 |
* argument to this sequence. |
524 |
* <p> |
|
525 |
* The characters of the array argument are appended, in order, to |
|
526 |
* the contents of this sequence. The length of this sequence |
|
527 |
* increases by the length of the argument. |
|
528 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
529 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
530 |
* to a string by the method {@link String#valueOf(char[])}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
531 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
532 |
* {@link #append(String) appended} to this character sequence. |
2 | 533 |
* |
534 |
* @param str the characters to be appended. |
|
535 |
* @return a reference to this object. |
|
536 |
*/ |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
537 |
public AbstractStringBuilder append(char[] str) { |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
538 |
int len = str.length; |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
539 |
ensureCapacityInternal(count + len); |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
540 |
System.arraycopy(str, 0, value, count, len); |
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
541 |
count += len; |
2 | 542 |
return this; |
543 |
} |
|
544 |
||
545 |
/** |
|
546 |
* Appends the string representation of a subarray of the |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
547 |
* {@code char} array argument to this sequence. |
2 | 548 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
549 |
* Characters of the {@code char} array {@code str}, starting at |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
550 |
* index {@code offset}, are appended, in order, to the contents |
2 | 551 |
* of this sequence. The length of this sequence increases |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
552 |
* by the value of {@code len}. |
2 | 553 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
554 |
* The overall effect is exactly as if the arguments were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
555 |
* to a string by the method {@link String#valueOf(char[],int,int)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
556 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
557 |
* {@link #append(String) appended} to this character sequence. |
2 | 558 |
* |
559 |
* @param str the characters to be appended. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
560 |
* @param offset the index of the first {@code char} to append. |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
561 |
* @param len the number of {@code char}s to append. |
2 | 562 |
* @return a reference to this object. |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
563 |
* @throws IndexOutOfBoundsException |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
564 |
* if {@code offset < 0} or {@code len < 0} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
565 |
* or {@code offset+len > str.length} |
2 | 566 |
*/ |
567 |
public AbstractStringBuilder append(char str[], int offset, int len) { |
|
6295
91f1c55cf47e
6955504: (str) String[Builder/Buffer].append(char[],int,int) throws OutOfMemoryError in b94
martin
parents:
5986
diff
changeset
|
568 |
if (len > 0) // let arraycopy report AIOOBE for len < 0 |
91f1c55cf47e
6955504: (str) String[Builder/Buffer].append(char[],int,int) throws OutOfMemoryError in b94
martin
parents:
5986
diff
changeset
|
569 |
ensureCapacityInternal(count + len); |
2 | 570 |
System.arraycopy(str, offset, value, count, len); |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
571 |
count += len; |
2 | 572 |
return this; |
573 |
} |
|
574 |
||
575 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
576 |
* Appends the string representation of the {@code boolean} |
2 | 577 |
* argument to the sequence. |
578 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
579 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
580 |
* to a string by the method {@link String#valueOf(boolean)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
581 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
582 |
* {@link #append(String) appended} to this character sequence. |
2 | 583 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
584 |
* @param b a {@code boolean}. |
2 | 585 |
* @return a reference to this object. |
586 |
*/ |
|
587 |
public AbstractStringBuilder append(boolean b) { |
|
588 |
if (b) { |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
589 |
ensureCapacityInternal(count + 4); |
2 | 590 |
value[count++] = 't'; |
591 |
value[count++] = 'r'; |
|
592 |
value[count++] = 'u'; |
|
593 |
value[count++] = 'e'; |
|
594 |
} else { |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
595 |
ensureCapacityInternal(count + 5); |
2 | 596 |
value[count++] = 'f'; |
597 |
value[count++] = 'a'; |
|
598 |
value[count++] = 'l'; |
|
599 |
value[count++] = 's'; |
|
600 |
value[count++] = 'e'; |
|
601 |
} |
|
602 |
return this; |
|
603 |
} |
|
604 |
||
605 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
606 |
* Appends the string representation of the {@code char} |
2 | 607 |
* argument to this sequence. |
608 |
* <p> |
|
609 |
* The argument is appended to the contents of this sequence. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
610 |
* The length of this sequence increases by {@code 1}. |
2 | 611 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
612 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
613 |
* to a string by the method {@link String#valueOf(char)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
614 |
* and the character in that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
615 |
* {@link #append(String) appended} to this character sequence. |
2 | 616 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
617 |
* @param c a {@code char}. |
2 | 618 |
* @return a reference to this object. |
619 |
*/ |
|
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
620 |
@Override |
2 | 621 |
public AbstractStringBuilder append(char c) { |
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
622 |
ensureCapacityInternal(count + 1); |
2 | 623 |
value[count++] = c; |
624 |
return this; |
|
625 |
} |
|
626 |
||
627 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
628 |
* Appends the string representation of the {@code int} |
2 | 629 |
* argument to this sequence. |
630 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
631 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
632 |
* to a string by the method {@link String#valueOf(int)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
633 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
634 |
* {@link #append(String) appended} to this character sequence. |
2 | 635 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
636 |
* @param i an {@code int}. |
2 | 637 |
* @return a reference to this object. |
638 |
*/ |
|
639 |
public AbstractStringBuilder append(int i) { |
|
640 |
if (i == Integer.MIN_VALUE) { |
|
641 |
append("-2147483648"); |
|
642 |
return this; |
|
643 |
} |
|
644 |
int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1 |
|
645 |
: Integer.stringSize(i); |
|
646 |
int spaceNeeded = count + appendedLength; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
647 |
ensureCapacityInternal(spaceNeeded); |
2 | 648 |
Integer.getChars(i, spaceNeeded, value); |
649 |
count = spaceNeeded; |
|
650 |
return this; |
|
651 |
} |
|
652 |
||
653 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
654 |
* Appends the string representation of the {@code long} |
2 | 655 |
* argument to this sequence. |
656 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
657 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
658 |
* to a string by the method {@link String#valueOf(long)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
659 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
660 |
* {@link #append(String) appended} to this character sequence. |
2 | 661 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
662 |
* @param l a {@code long}. |
2 | 663 |
* @return a reference to this object. |
664 |
*/ |
|
665 |
public AbstractStringBuilder append(long l) { |
|
666 |
if (l == Long.MIN_VALUE) { |
|
667 |
append("-9223372036854775808"); |
|
668 |
return this; |
|
669 |
} |
|
670 |
int appendedLength = (l < 0) ? Long.stringSize(-l) + 1 |
|
671 |
: Long.stringSize(l); |
|
672 |
int spaceNeeded = count + appendedLength; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
673 |
ensureCapacityInternal(spaceNeeded); |
2 | 674 |
Long.getChars(l, spaceNeeded, value); |
675 |
count = spaceNeeded; |
|
676 |
return this; |
|
677 |
} |
|
678 |
||
679 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
680 |
* Appends the string representation of the {@code float} |
2 | 681 |
* argument to this sequence. |
682 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
683 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
684 |
* to a string by the method {@link String#valueOf(float)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
685 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
686 |
* {@link #append(String) appended} to this character sequence. |
2 | 687 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
688 |
* @param f a {@code float}. |
2 | 689 |
* @return a reference to this object. |
690 |
*/ |
|
691 |
public AbstractStringBuilder append(float f) { |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16742
diff
changeset
|
692 |
FloatingDecimal.appendTo(f,this); |
2 | 693 |
return this; |
694 |
} |
|
695 |
||
696 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
697 |
* Appends the string representation of the {@code double} |
2 | 698 |
* argument to this sequence. |
699 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
700 |
* The overall effect is exactly as if the argument were converted |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
701 |
* to a string by the method {@link String#valueOf(double)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
702 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
703 |
* {@link #append(String) appended} to this character sequence. |
2 | 704 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
705 |
* @param d a {@code double}. |
2 | 706 |
* @return a reference to this object. |
707 |
*/ |
|
708 |
public AbstractStringBuilder append(double d) { |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16742
diff
changeset
|
709 |
FloatingDecimal.appendTo(d,this); |
2 | 710 |
return this; |
711 |
} |
|
712 |
||
713 |
/** |
|
714 |
* Removes the characters in a substring of this sequence. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
715 |
* The substring begins at the specified {@code start} and extends to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
716 |
* the character at index {@code end - 1} or to the end of the |
2 | 717 |
* sequence if no such character exists. If |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
718 |
* {@code start} is equal to {@code end}, no changes are made. |
2 | 719 |
* |
720 |
* @param start The beginning index, inclusive. |
|
721 |
* @param end The ending index, exclusive. |
|
722 |
* @return This object. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
723 |
* @throws StringIndexOutOfBoundsException if {@code start} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
724 |
* is negative, greater than {@code length()}, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
725 |
* greater than {@code end}. |
2 | 726 |
*/ |
727 |
public AbstractStringBuilder delete(int start, int end) { |
|
728 |
if (start < 0) |
|
729 |
throw new StringIndexOutOfBoundsException(start); |
|
730 |
if (end > count) |
|
731 |
end = count; |
|
732 |
if (start > end) |
|
733 |
throw new StringIndexOutOfBoundsException(); |
|
734 |
int len = end - start; |
|
735 |
if (len > 0) { |
|
736 |
System.arraycopy(value, start+len, value, start, count-end); |
|
737 |
count -= len; |
|
738 |
} |
|
739 |
return this; |
|
740 |
} |
|
741 |
||
742 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
743 |
* Appends the string representation of the {@code codePoint} |
2 | 744 |
* argument to this sequence. |
745 |
* |
|
746 |
* <p> The argument is appended to the contents of this sequence. |
|
747 |
* The length of this sequence increases by |
|
748 |
* {@link Character#charCount(int) Character.charCount(codePoint)}. |
|
749 |
* |
|
750 |
* <p> The overall effect is exactly as if the argument were |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
751 |
* converted to a {@code char} array by the method |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
752 |
* {@link Character#toChars(int)} and the character in that array |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
753 |
* were then {@link #append(char[]) appended} to this character |
2 | 754 |
* sequence. |
755 |
* |
|
756 |
* @param codePoint a Unicode code point |
|
757 |
* @return a reference to this object. |
|
758 |
* @exception IllegalArgumentException if the specified |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
759 |
* {@code codePoint} isn't a valid Unicode code point |
2 | 760 |
*/ |
761 |
public AbstractStringBuilder appendCodePoint(int codePoint) { |
|
5986
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
762 |
final int count = this.count; |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
763 |
|
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
764 |
if (Character.isBmpCodePoint(codePoint)) { |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
765 |
ensureCapacityInternal(count + 1); |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
766 |
value[count] = (char) codePoint; |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
767 |
this.count = count + 1; |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
768 |
} else if (Character.isValidCodePoint(codePoint)) { |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
769 |
ensureCapacityInternal(count + 2); |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
770 |
Character.toSurrogates(codePoint, value, count); |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
771 |
this.count = count + 2; |
04eb44085c00
6934265: Add public method Character.isBmpCodePoint
martin
parents:
5627
diff
changeset
|
772 |
} else { |
2 | 773 |
throw new IllegalArgumentException(); |
774 |
} |
|
775 |
return this; |
|
776 |
} |
|
777 |
||
778 |
/** |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
779 |
* Removes the {@code char} at the specified position in this |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
780 |
* sequence. This sequence is shortened by one {@code char}. |
2 | 781 |
* |
782 |
* <p>Note: If the character at the given index is a supplementary |
|
783 |
* character, this method does not remove the entire character. If |
|
784 |
* correct handling of supplementary characters is required, |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
785 |
* determine the number of {@code char}s to remove by calling |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
786 |
* {@code Character.charCount(thisSequence.codePointAt(index))}, |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
787 |
* where {@code thisSequence} is this sequence. |
2 | 788 |
* |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
789 |
* @param index Index of {@code char} to remove |
2 | 790 |
* @return This object. |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
791 |
* @throws StringIndexOutOfBoundsException if the {@code index} |
2 | 792 |
* is negative or greater than or equal to |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
793 |
* {@code length()}. |
2 | 794 |
*/ |
795 |
public AbstractStringBuilder deleteCharAt(int index) { |
|
796 |
if ((index < 0) || (index >= count)) |
|
797 |
throw new StringIndexOutOfBoundsException(index); |
|
798 |
System.arraycopy(value, index+1, value, index, count-index-1); |
|
799 |
count--; |
|
800 |
return this; |
|
801 |
} |
|
802 |
||
803 |
/** |
|
804 |
* Replaces the characters in a substring of this sequence |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
805 |
* with characters in the specified {@code String}. The substring |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
806 |
* begins at the specified {@code start} and extends to the character |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
807 |
* at index {@code end - 1} or to the end of the |
2 | 808 |
* sequence if no such character exists. First the |
809 |
* characters in the substring are removed and then the specified |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
810 |
* {@code String} is inserted at {@code start}. (This |
2 | 811 |
* sequence will be lengthened to accommodate the |
812 |
* specified String if necessary.) |
|
813 |
* |
|
814 |
* @param start The beginning index, inclusive. |
|
815 |
* @param end The ending index, exclusive. |
|
816 |
* @param str String that will replace previous contents. |
|
817 |
* @return This object. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
818 |
* @throws StringIndexOutOfBoundsException if {@code start} |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
819 |
* is negative, greater than {@code length()}, or |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
820 |
* greater than {@code end}. |
2 | 821 |
*/ |
822 |
public AbstractStringBuilder replace(int start, int end, String str) { |
|
823 |
if (start < 0) |
|
824 |
throw new StringIndexOutOfBoundsException(start); |
|
825 |
if (start > count) |
|
826 |
throw new StringIndexOutOfBoundsException("start > length()"); |
|
827 |
if (start > end) |
|
828 |
throw new StringIndexOutOfBoundsException("start > end"); |
|
829 |
||
830 |
if (end > count) |
|
831 |
end = count; |
|
832 |
int len = str.length(); |
|
833 |
int newCount = count + len - (end - start); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
834 |
ensureCapacityInternal(newCount); |
2 | 835 |
|
836 |
System.arraycopy(value, end, value, start + len, count - end); |
|
837 |
str.getChars(value, start); |
|
838 |
count = newCount; |
|
839 |
return this; |
|
840 |
} |
|
841 |
||
842 |
/** |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
843 |
* Returns a new {@code String} that contains a subsequence of |
2 | 844 |
* characters currently contained in this character sequence. The |
845 |
* substring begins at the specified index and extends to the end of |
|
846 |
* this sequence. |
|
847 |
* |
|
848 |
* @param start The beginning index, inclusive. |
|
849 |
* @return The new string. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
850 |
* @throws StringIndexOutOfBoundsException if {@code start} is |
2 | 851 |
* less than zero, or greater than the length of this object. |
852 |
*/ |
|
853 |
public String substring(int start) { |
|
854 |
return substring(start, count); |
|
855 |
} |
|
856 |
||
857 |
/** |
|
858 |
* Returns a new character sequence that is a subsequence of this sequence. |
|
859 |
* |
|
860 |
* <p> An invocation of this method of the form |
|
861 |
* |
|
21334 | 862 |
* <pre>{@code |
863 |
* sb.subSequence(begin, end)}</pre> |
|
2 | 864 |
* |
865 |
* behaves in exactly the same way as the invocation |
|
866 |
* |
|
21334 | 867 |
* <pre>{@code |
868 |
* sb.substring(begin, end)}</pre> |
|
2 | 869 |
* |
870 |
* This method is provided so that this class can |
|
21334 | 871 |
* implement the {@link CharSequence} interface. |
2 | 872 |
* |
873 |
* @param start the start index, inclusive. |
|
874 |
* @param end the end index, exclusive. |
|
875 |
* @return the specified subsequence. |
|
876 |
* |
|
877 |
* @throws IndexOutOfBoundsException |
|
14997 | 878 |
* if {@code start} or {@code end} are negative, |
879 |
* if {@code end} is greater than {@code length()}, |
|
880 |
* or if {@code start} is greater than {@code end} |
|
2 | 881 |
* @spec JSR-51 |
882 |
*/ |
|
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
883 |
@Override |
2 | 884 |
public CharSequence subSequence(int start, int end) { |
885 |
return substring(start, end); |
|
886 |
} |
|
887 |
||
888 |
/** |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
889 |
* Returns a new {@code String} that contains a subsequence of |
2 | 890 |
* characters currently contained in this sequence. The |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
891 |
* substring begins at the specified {@code start} and |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
892 |
* extends to the character at index {@code end - 1}. |
2 | 893 |
* |
894 |
* @param start The beginning index, inclusive. |
|
895 |
* @param end The ending index, exclusive. |
|
896 |
* @return The new string. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
897 |
* @throws StringIndexOutOfBoundsException if {@code start} |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
898 |
* or {@code end} are negative or greater than |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
899 |
* {@code length()}, or {@code start} is |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
900 |
* greater than {@code end}. |
2 | 901 |
*/ |
902 |
public String substring(int start, int end) { |
|
903 |
if (start < 0) |
|
904 |
throw new StringIndexOutOfBoundsException(start); |
|
905 |
if (end > count) |
|
906 |
throw new StringIndexOutOfBoundsException(end); |
|
907 |
if (start > end) |
|
908 |
throw new StringIndexOutOfBoundsException(end - start); |
|
909 |
return new String(value, start, end - start); |
|
910 |
} |
|
911 |
||
912 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
913 |
* Inserts the string representation of a subarray of the {@code str} |
2 | 914 |
* array argument into this sequence. The subarray begins at the |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
915 |
* specified {@code offset} and extends {@code len} {@code char}s. |
2 | 916 |
* The characters of the subarray are inserted into this sequence at |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
917 |
* the position indicated by {@code index}. The length of this |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
918 |
* sequence increases by {@code len} {@code char}s. |
2 | 919 |
* |
920 |
* @param index position at which to insert subarray. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
921 |
* @param str A {@code char} array. |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
922 |
* @param offset the index of the first {@code char} in subarray to |
2 | 923 |
* be inserted. |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
924 |
* @param len the number of {@code char}s in the subarray to |
2 | 925 |
* be inserted. |
926 |
* @return This object |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
927 |
* @throws StringIndexOutOfBoundsException if {@code index} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
928 |
* is negative or greater than {@code length()}, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
929 |
* {@code offset} or {@code len} are negative, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
930 |
* {@code (offset+len)} is greater than |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
931 |
* {@code str.length}. |
2 | 932 |
*/ |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
933 |
public AbstractStringBuilder insert(int index, char[] str, int offset, |
2 | 934 |
int len) |
935 |
{ |
|
936 |
if ((index < 0) || (index > length())) |
|
937 |
throw new StringIndexOutOfBoundsException(index); |
|
938 |
if ((offset < 0) || (len < 0) || (offset > str.length - len)) |
|
939 |
throw new StringIndexOutOfBoundsException( |
|
940 |
"offset " + offset + ", len " + len + ", str.length " |
|
941 |
+ str.length); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
942 |
ensureCapacityInternal(count + len); |
2 | 943 |
System.arraycopy(value, index, value, index + len, count - index); |
944 |
System.arraycopy(str, offset, value, index, len); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
945 |
count += len; |
2 | 946 |
return this; |
947 |
} |
|
948 |
||
949 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
950 |
* Inserts the string representation of the {@code Object} |
2 | 951 |
* argument into this character sequence. |
952 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
953 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
954 |
* converted to a string by the method {@link String#valueOf(Object)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
955 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
956 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
957 |
* sequence at the indicated offset. |
2 | 958 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
959 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
960 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
961 |
* of this sequence. |
2 | 962 |
* |
963 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
964 |
* @param obj an {@code Object}. |
2 | 965 |
* @return a reference to this object. |
966 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
967 |
*/ |
|
968 |
public AbstractStringBuilder insert(int offset, Object obj) { |
|
969 |
return insert(offset, String.valueOf(obj)); |
|
970 |
} |
|
971 |
||
972 |
/** |
|
973 |
* Inserts the string into this character sequence. |
|
974 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
975 |
* The characters of the {@code String} argument are inserted, in |
2 | 976 |
* order, into this sequence at the indicated offset, moving up any |
977 |
* characters originally above that position and increasing the length |
|
978 |
* of this sequence by the length of the argument. If |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
979 |
* {@code str} is {@code null}, then the four characters |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
980 |
* {@code "null"} are inserted into this sequence. |
2 | 981 |
* <p> |
982 |
* The character at index <i>k</i> in the new character sequence is |
|
983 |
* equal to: |
|
984 |
* <ul> |
|
985 |
* <li>the character at index <i>k</i> in the old character sequence, if |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
986 |
* <i>k</i> is less than {@code offset} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
987 |
* <li>the character at index <i>k</i>{@code -offset} in the |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
988 |
* argument {@code str}, if <i>k</i> is not less than |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
989 |
* {@code offset} but is less than {@code offset+str.length()} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
990 |
* <li>the character at index <i>k</i>{@code -str.length()} in the |
2 | 991 |
* old character sequence, if <i>k</i> is not less than |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
992 |
* {@code offset+str.length()} |
2 | 993 |
* </ul><p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
994 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
995 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
996 |
* of this sequence. |
2 | 997 |
* |
998 |
* @param offset the offset. |
|
999 |
* @param str a string. |
|
1000 |
* @return a reference to this object. |
|
1001 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1002 |
*/ |
|
1003 |
public AbstractStringBuilder insert(int offset, String str) { |
|
1004 |
if ((offset < 0) || (offset > length())) |
|
1005 |
throw new StringIndexOutOfBoundsException(offset); |
|
1006 |
if (str == null) |
|
1007 |
str = "null"; |
|
1008 |
int len = str.length(); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1009 |
ensureCapacityInternal(count + len); |
2 | 1010 |
System.arraycopy(value, offset, value, offset + len, count - offset); |
1011 |
str.getChars(value, offset); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1012 |
count += len; |
2 | 1013 |
return this; |
1014 |
} |
|
1015 |
||
1016 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1017 |
* Inserts the string representation of the {@code char} array |
2 | 1018 |
* argument into this sequence. |
1019 |
* <p> |
|
1020 |
* The characters of the array argument are inserted into the |
|
1021 |
* contents of this sequence at the position indicated by |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1022 |
* {@code offset}. The length of this sequence increases by |
2 | 1023 |
* the length of the argument. |
1024 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1025 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1026 |
* converted to a string by the method {@link String#valueOf(char[])}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1027 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1028 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1029 |
* sequence at the indicated offset. |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1030 |
* <p> |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1031 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1032 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1033 |
* of this sequence. |
2 | 1034 |
* |
1035 |
* @param offset the offset. |
|
1036 |
* @param str a character array. |
|
1037 |
* @return a reference to this object. |
|
1038 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1039 |
*/ |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1040 |
public AbstractStringBuilder insert(int offset, char[] str) { |
2 | 1041 |
if ((offset < 0) || (offset > length())) |
1042 |
throw new StringIndexOutOfBoundsException(offset); |
|
1043 |
int len = str.length; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1044 |
ensureCapacityInternal(count + len); |
2 | 1045 |
System.arraycopy(value, offset, value, offset + len, count - offset); |
1046 |
System.arraycopy(str, 0, value, offset, len); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1047 |
count += len; |
2 | 1048 |
return this; |
1049 |
} |
|
1050 |
||
1051 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1052 |
* Inserts the specified {@code CharSequence} into this sequence. |
2 | 1053 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1054 |
* The characters of the {@code CharSequence} argument are inserted, |
2 | 1055 |
* in order, into this sequence at the indicated offset, moving up |
1056 |
* any characters originally above that position and increasing the length |
|
1057 |
* of this sequence by the length of the argument s. |
|
1058 |
* <p> |
|
1059 |
* The result of this method is exactly the same as if it were an |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1060 |
* invocation of this object's |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1061 |
* {@link #insert(int,CharSequence,int,int) insert}(dstOffset, s, 0, s.length()) |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1062 |
* method. |
2 | 1063 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1064 |
* <p>If {@code s} is {@code null}, then the four characters |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1065 |
* {@code "null"} are inserted into this sequence. |
2 | 1066 |
* |
1067 |
* @param dstOffset the offset. |
|
1068 |
* @param s the sequence to be inserted |
|
1069 |
* @return a reference to this object. |
|
1070 |
* @throws IndexOutOfBoundsException if the offset is invalid. |
|
1071 |
*/ |
|
1072 |
public AbstractStringBuilder insert(int dstOffset, CharSequence s) { |
|
1073 |
if (s == null) |
|
1074 |
s = "null"; |
|
1075 |
if (s instanceof String) |
|
1076 |
return this.insert(dstOffset, (String)s); |
|
1077 |
return this.insert(dstOffset, s, 0, s.length()); |
|
1078 |
} |
|
1079 |
||
1080 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1081 |
* Inserts a subsequence of the specified {@code CharSequence} into |
2 | 1082 |
* this sequence. |
1083 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1084 |
* The subsequence of the argument {@code s} specified by |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1085 |
* {@code start} and {@code end} are inserted, |
2 | 1086 |
* in order, into this sequence at the specified destination offset, moving |
1087 |
* up any characters originally above that position. The length of this |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1088 |
* sequence is increased by {@code end - start}. |
2 | 1089 |
* <p> |
1090 |
* The character at index <i>k</i> in this sequence becomes equal to: |
|
1091 |
* <ul> |
|
1092 |
* <li>the character at index <i>k</i> in this sequence, if |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1093 |
* <i>k</i> is less than {@code dstOffset} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1094 |
* <li>the character at index <i>k</i>{@code +start-dstOffset} in |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1095 |
* the argument {@code s}, if <i>k</i> is greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1096 |
* {@code dstOffset} but is less than {@code dstOffset+end-start} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1097 |
* <li>the character at index <i>k</i>{@code -(end-start)} in this |
2 | 1098 |
* sequence, if <i>k</i> is greater than or equal to |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1099 |
* {@code dstOffset+end-start} |
2 | 1100 |
* </ul><p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1101 |
* The {@code dstOffset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1102 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1103 |
* of this sequence. |
2 | 1104 |
* <p>The start argument must be nonnegative, and not greater than |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1105 |
* {@code end}. |
2 | 1106 |
* <p>The end argument must be greater than or equal to |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1107 |
* {@code start}, and less than or equal to the length of s. |
2 | 1108 |
* |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1109 |
* <p>If {@code s} is {@code null}, then this method inserts |
2 | 1110 |
* characters as if the s parameter was a sequence containing the four |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1111 |
* characters {@code "null"}. |
2 | 1112 |
* |
1113 |
* @param dstOffset the offset in this sequence. |
|
1114 |
* @param s the sequence to be inserted. |
|
1115 |
* @param start the starting index of the subsequence to be inserted. |
|
1116 |
* @param end the end index of the subsequence to be inserted. |
|
1117 |
* @return a reference to this object. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1118 |
* @throws IndexOutOfBoundsException if {@code dstOffset} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1119 |
* is negative or greater than {@code this.length()}, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1120 |
* {@code start} or {@code end} are negative, or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1121 |
* {@code start} is greater than {@code end} or |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1122 |
* {@code end} is greater than {@code s.length()} |
2 | 1123 |
*/ |
1124 |
public AbstractStringBuilder insert(int dstOffset, CharSequence s, |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1125 |
int start, int end) { |
2 | 1126 |
if (s == null) |
1127 |
s = "null"; |
|
1128 |
if ((dstOffset < 0) || (dstOffset > this.length())) |
|
1129 |
throw new IndexOutOfBoundsException("dstOffset "+dstOffset); |
|
1130 |
if ((start < 0) || (end < 0) || (start > end) || (end > s.length())) |
|
1131 |
throw new IndexOutOfBoundsException( |
|
1132 |
"start " + start + ", end " + end + ", s.length() " |
|
1133 |
+ s.length()); |
|
1134 |
int len = end - start; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1135 |
ensureCapacityInternal(count + len); |
2 | 1136 |
System.arraycopy(value, dstOffset, value, dstOffset + len, |
1137 |
count - dstOffset); |
|
1138 |
for (int i=start; i<end; i++) |
|
1139 |
value[dstOffset++] = s.charAt(i); |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1140 |
count += len; |
2 | 1141 |
return this; |
1142 |
} |
|
1143 |
||
1144 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1145 |
* Inserts the string representation of the {@code boolean} |
2 | 1146 |
* argument into this sequence. |
1147 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1148 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1149 |
* converted to a string by the method {@link String#valueOf(boolean)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1150 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1151 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1152 |
* sequence at the indicated offset. |
2 | 1153 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1154 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1155 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1156 |
* of this sequence. |
2 | 1157 |
* |
1158 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1159 |
* @param b a {@code boolean}. |
2 | 1160 |
* @return a reference to this object. |
1161 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1162 |
*/ |
|
1163 |
public AbstractStringBuilder insert(int offset, boolean b) { |
|
1164 |
return insert(offset, String.valueOf(b)); |
|
1165 |
} |
|
1166 |
||
1167 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1168 |
* Inserts the string representation of the {@code char} |
2 | 1169 |
* argument into this sequence. |
1170 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1171 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1172 |
* converted to a string by the method {@link String#valueOf(char)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1173 |
* and the character in that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1174 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1175 |
* sequence at the indicated offset. |
2 | 1176 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1177 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1178 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1179 |
* of this sequence. |
2 | 1180 |
* |
1181 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1182 |
* @param c a {@code char}. |
2 | 1183 |
* @return a reference to this object. |
1184 |
* @throws IndexOutOfBoundsException if the offset is invalid. |
|
1185 |
*/ |
|
1186 |
public AbstractStringBuilder insert(int offset, char c) { |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1187 |
ensureCapacityInternal(count + 1); |
2 | 1188 |
System.arraycopy(value, offset, value, offset + 1, count - offset); |
1189 |
value[offset] = c; |
|
5466
f130bb07764b
6933217: Huge arrays handled poorly in core libraries
martin
parents:
1247
diff
changeset
|
1190 |
count += 1; |
2 | 1191 |
return this; |
1192 |
} |
|
1193 |
||
1194 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1195 |
* Inserts the string representation of the second {@code int} |
2 | 1196 |
* argument into this sequence. |
1197 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1198 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1199 |
* converted to a string by the method {@link String#valueOf(int)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1200 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1201 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1202 |
* sequence at the indicated offset. |
2 | 1203 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1204 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1205 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1206 |
* of this sequence. |
2 | 1207 |
* |
1208 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1209 |
* @param i an {@code int}. |
2 | 1210 |
* @return a reference to this object. |
1211 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1212 |
*/ |
|
1213 |
public AbstractStringBuilder insert(int offset, int i) { |
|
1214 |
return insert(offset, String.valueOf(i)); |
|
1215 |
} |
|
1216 |
||
1217 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1218 |
* Inserts the string representation of the {@code long} |
2 | 1219 |
* argument into this sequence. |
1220 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1221 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1222 |
* converted to a string by the method {@link String#valueOf(long)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1223 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1224 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1225 |
* sequence at the indicated offset. |
2 | 1226 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1227 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1228 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1229 |
* of this sequence. |
2 | 1230 |
* |
1231 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1232 |
* @param l a {@code long}. |
2 | 1233 |
* @return a reference to this object. |
1234 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1235 |
*/ |
|
1236 |
public AbstractStringBuilder insert(int offset, long l) { |
|
1237 |
return insert(offset, String.valueOf(l)); |
|
1238 |
} |
|
1239 |
||
1240 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1241 |
* Inserts the string representation of the {@code float} |
2 | 1242 |
* argument into this sequence. |
1243 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1244 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1245 |
* converted to a string by the method {@link String#valueOf(float)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1246 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1247 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1248 |
* sequence at the indicated offset. |
2 | 1249 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1250 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1251 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1252 |
* of this sequence. |
2 | 1253 |
* |
1254 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1255 |
* @param f a {@code float}. |
2 | 1256 |
* @return a reference to this object. |
1257 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1258 |
*/ |
|
1259 |
public AbstractStringBuilder insert(int offset, float f) { |
|
1260 |
return insert(offset, String.valueOf(f)); |
|
1261 |
} |
|
1262 |
||
1263 |
/** |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1264 |
* Inserts the string representation of the {@code double} |
2 | 1265 |
* argument into this sequence. |
1266 |
* <p> |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1267 |
* The overall effect is exactly as if the second argument were |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1268 |
* converted to a string by the method {@link String#valueOf(double)}, |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1269 |
* and the characters of that string were then |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1270 |
* {@link #insert(int,String) inserted} into this character |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1271 |
* sequence at the indicated offset. |
2 | 1272 |
* <p> |
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1273 |
* The {@code offset} argument must be greater than or equal to |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1274 |
* {@code 0}, and less than or equal to the {@linkplain #length() length} |
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1275 |
* of this sequence. |
2 | 1276 |
* |
1277 |
* @param offset the offset. |
|
1223
5c1037124466
6728229: (str) StringBuilder.append(CharSequence) does not throw IndexOutOfBoundsException
martin
parents:
2
diff
changeset
|
1278 |
* @param d a {@code double}. |
2 | 1279 |
* @return a reference to this object. |
1280 |
* @throws StringIndexOutOfBoundsException if the offset is invalid. |
|
1281 |
*/ |
|
1282 |
public AbstractStringBuilder insert(int offset, double d) { |
|
1283 |
return insert(offset, String.valueOf(d)); |
|
1284 |
} |
|
1285 |
||
1286 |
/** |
|
1287 |
* Returns the index within this string of the first occurrence of the |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1288 |
* specified substring. |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1289 |
* |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1290 |
* <p>The returned index is the smallest value {@code k} for which: |
21334 | 1291 |
* <pre>{@code |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1292 |
* this.toString().startsWith(str, k) |
21334 | 1293 |
* }</pre> |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1294 |
* If no such value of {@code k} exists, then {@code -1} is returned. |
2 | 1295 |
* |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1296 |
* @param str the substring to search for. |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1297 |
* @return the index of the first occurrence of the specified substring, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1298 |
* or {@code -1} if there is no such occurrence. |
2 | 1299 |
*/ |
1300 |
public int indexOf(String str) { |
|
1301 |
return indexOf(str, 0); |
|
1302 |
} |
|
1303 |
||
1304 |
/** |
|
1305 |
* Returns the index within this string of the first occurrence of the |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1306 |
* specified substring, starting at the specified index. |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1307 |
* |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1308 |
* <p>The returned index is the smallest value {@code k} for which: |
21334 | 1309 |
* <pre>{@code |
19591
80e86f94c0e9
8016018: Typo in AbstractStringBuilder#indexOf and #lastIndexOf descriptions
igerasim
parents:
18143
diff
changeset
|
1310 |
* k >= Math.min(fromIndex, this.length()) && |
2 | 1311 |
* this.toString().startsWith(str, k) |
21334 | 1312 |
* }</pre> |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1313 |
* If no such value of {@code k} exists, then {@code -1} is returned. |
2 | 1314 |
* |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1315 |
* @param str the substring to search for. |
2 | 1316 |
* @param fromIndex the index from which to start the search. |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1317 |
* @return the index of the first occurrence of the specified substring, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1318 |
* starting at the specified index, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1319 |
* or {@code -1} if there is no such occurrence. |
2 | 1320 |
*/ |
1321 |
public int indexOf(String str, int fromIndex) { |
|
14686
fb59583d33b2
6553074: String{Buffer,Builder}.indexOf(Str, int) contains unnecessary allocation
mduigou
parents:
14332
diff
changeset
|
1322 |
return String.indexOf(value, 0, count, str, fromIndex); |
2 | 1323 |
} |
1324 |
||
1325 |
/** |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1326 |
* Returns the index within this string of the last occurrence of the |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1327 |
* specified substring. The last occurrence of the empty string "" is |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1328 |
* considered to occur at the index value {@code this.length()}. |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1329 |
* |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1330 |
* <p>The returned index is the largest value {@code k} for which: |
21334 | 1331 |
* <pre>{@code |
2 | 1332 |
* this.toString().startsWith(str, k) |
21334 | 1333 |
* }</pre> |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1334 |
* If no such value of {@code k} exists, then {@code -1} is returned. |
2 | 1335 |
* |
1336 |
* @param str the substring to search for. |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1337 |
* @return the index of the last occurrence of the specified substring, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1338 |
* or {@code -1} if there is no such occurrence. |
2 | 1339 |
*/ |
1340 |
public int lastIndexOf(String str) { |
|
1341 |
return lastIndexOf(str, count); |
|
1342 |
} |
|
1343 |
||
1344 |
/** |
|
1345 |
* Returns the index within this string of the last occurrence of the |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1346 |
* specified substring, searching backward starting at the specified index. |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1347 |
* |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1348 |
* <p>The returned index is the largest value {@code k} for which: |
21334 | 1349 |
* <pre>{@code |
19591
80e86f94c0e9
8016018: Typo in AbstractStringBuilder#indexOf and #lastIndexOf descriptions
igerasim
parents:
18143
diff
changeset
|
1350 |
* k <= Math.min(fromIndex, this.length()) && |
2 | 1351 |
* this.toString().startsWith(str, k) |
21334 | 1352 |
* }</pre> |
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1353 |
* If no such value of {@code k} exists, then {@code -1} is returned. |
2 | 1354 |
* |
1355 |
* @param str the substring to search for. |
|
1356 |
* @param fromIndex the index to start the search from. |
|
23024
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1357 |
* @return the index of the last occurrence of the specified substring, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1358 |
* searching backward from the specified index, |
7d5ecb31115f
8027640: String.indexOf(String,int) for the empty string case not specified
bchristi
parents:
21334
diff
changeset
|
1359 |
* or {@code -1} if there is no such occurrence. |
2 | 1360 |
*/ |
1361 |
public int lastIndexOf(String str, int fromIndex) { |
|
14686
fb59583d33b2
6553074: String{Buffer,Builder}.indexOf(Str, int) contains unnecessary allocation
mduigou
parents:
14332
diff
changeset
|
1362 |
return String.lastIndexOf(value, 0, count, str, fromIndex); |
2 | 1363 |
} |
1364 |
||
1365 |
/** |
|
1366 |
* Causes this character sequence to be replaced by the reverse of |
|
1367 |
* the sequence. If there are any surrogate pairs included in the |
|
1368 |
* sequence, these are treated as single characters for the |
|
1369 |
* reverse operation. Thus, the order of the high-low surrogates |
|
1370 |
* is never reversed. |
|
1371 |
* |
|
1372 |
* Let <i>n</i> be the character length of this character sequence |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1373 |
* (not the length in {@code char} values) just prior to |
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1374 |
* execution of the {@code reverse} method. Then the |
2 | 1375 |
* character at index <i>k</i> in the new character sequence is |
1376 |
* equal to the character at index <i>n-k-1</i> in the old |
|
1377 |
* character sequence. |
|
1378 |
* |
|
1379 |
* <p>Note that the reverse operation may result in producing |
|
1380 |
* surrogate pairs that were unpaired low-surrogates and |
|
1381 |
* high-surrogates before the operation. For example, reversing |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1382 |
* "\u005CuDC00\u005CuD800" produces "\u005CuD800\u005CuDC00" which is |
2 | 1383 |
* a valid surrogate pair. |
1384 |
* |
|
1385 |
* @return a reference to this object. |
|
1386 |
*/ |
|
1387 |
public AbstractStringBuilder reverse() { |
|
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1388 |
boolean hasSurrogates = false; |
2 | 1389 |
int n = count - 1; |
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1390 |
for (int j = (n-1) >> 1; j >= 0; j--) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1391 |
int k = n - j; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1392 |
char cj = value[j]; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1393 |
char ck = value[k]; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1394 |
value[j] = ck; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1395 |
value[k] = cj; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1396 |
if (Character.isSurrogate(cj) || |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1397 |
Character.isSurrogate(ck)) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1398 |
hasSurrogates = true; |
2 | 1399 |
} |
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1400 |
} |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1401 |
if (hasSurrogates) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1402 |
reverseAllValidSurrogatePairs(); |
2 | 1403 |
} |
16714
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1404 |
return this; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1405 |
} |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1406 |
|
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1407 |
/** Outlined helper method for reverse() */ |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1408 |
private void reverseAllValidSurrogatePairs() { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1409 |
for (int i = 0; i < count - 1; i++) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1410 |
char c2 = value[i]; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1411 |
if (Character.isLowSurrogate(c2)) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1412 |
char c1 = value[i + 1]; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1413 |
if (Character.isHighSurrogate(c1)) { |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1414 |
value[i++] = c1; |
cb235d5f8bd4
8010316: Improve handling of char sequences containing surrogates
martin
parents:
15312
diff
changeset
|
1415 |
value[i] = c2; |
2 | 1416 |
} |
1417 |
} |
|
1418 |
} |
|
1419 |
} |
|
1420 |
||
1421 |
/** |
|
1422 |
* Returns a string representing the data in this sequence. |
|
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1423 |
* A new {@code String} object is allocated and initialized to |
2 | 1424 |
* contain the character sequence currently represented by this |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1425 |
* object. This {@code String} is then returned. Subsequent |
2 | 1426 |
* changes to this sequence do not affect the contents of the |
11676
7e75ec031b97
7132338: Use @code friendly idiom for '\' in javadoc
darcy
parents:
7668
diff
changeset
|
1427 |
* {@code String}. |
2 | 1428 |
* |
1429 |
* @return a string representation of this sequence of characters. |
|
1430 |
*/ |
|
14332
451c5dd717dc
6206780: (str) Forwarding append methods in String{Buffer,Builder} are inconsistent
jgish
parents:
13822
diff
changeset
|
1431 |
@Override |
2 | 1432 |
public abstract String toString(); |
1433 |
||
1434 |
/** |
|
14997 | 1435 |
* Needed by {@code String} for the contentEquals method. |
2 | 1436 |
*/ |
1437 |
final char[] getValue() { |
|
1438 |
return value; |
|
1439 |
} |
|
1440 |
||
1441 |
} |