Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright 2003-2006 Sun Microsystems, Inc.  All Rights Reserved.
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
7
    * published by the Free Software Foundation.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun in the LICENSE file that accompanied this code.
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
   *
21
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  package java.lang;
27
  
29
  import java.util.Arrays;

A mutable sequence of characters.

Implements a modifiable string. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.

Author(s):
Michael McCloskey
Since:
1.5
40
  
41
  abstract class AbstractStringBuilder implements Appendable, CharSequence {
    
The value is used for character storage. 
44
  
45
      char value[];

    
The count is the number of characters used. 
49
  
50
      int count;

    
This no-arg constructor is necessary for serialization of subclasses. 
54
  
55
      AbstractStringBuilder() {
56
      }

    
Creates an AbstractStringBuilder of the specified capacity. 
60
  
61
      AbstractStringBuilder(int capacity) {
62
           = new char[capacity];
63
      }

    
Returns the length (character count).

Returns:
the length of the sequence of characters currently represented by this object
70
  
71
      public int length() {
72
          return ;
73
      }

    
Returns the current capacity. The capacity is the amount of storage available for newly inserted characters, beyond which an allocation will occur.

Returns:
the current capacity
81
  
82
      public int capacity() {
83
          return .;
84
      }

    
Ensures that the capacity is at least equal to the specified minimum. If the current capacity is less than the argument, then a new internal array is allocated with greater capacity. The new capacity is the larger of:
  • The minimumCapacity argument.
  • Twice the old capacity, plus 2.
If the minimumCapacity argument is nonpositive, this method takes no action and simply returns.

Parameters:
minimumCapacity the minimum desired capacity.
99
  
100
     public void ensureCapacity(int minimumCapacity) {
101
         if (minimumCapacity > .) {
102
             expandCapacity(minimumCapacity);
103
         }
104
     }

    
This implements the expansion semantics of ensureCapacity with no size check or synchronization. 
109
 
110
     void expandCapacity(int minimumCapacity) {
111
         int newCapacity = (. + 1) * 2;
112
         if (newCapacity < 0) {
113
             newCapacity = .;
114
         } else if (minimumCapacity > newCapacity) {
115
             newCapacity = minimumCapacity;
116
         }
117
          = Arrays.copyOf(, newCapacity);
118
     }

    
Attempts to reduce storage used for the character sequence. If the buffer is larger than necessary to hold its current sequence of characters, then it may be resized to become more space efficient. Calling this method may, but is not required to, affect the value returned by a subsequent call to the capacity() method. 
126
 
127
     public void trimToSize() {
128
         if ( < .) {
129
              = Arrays.copyOf(, );
130
         }
131
     }

    
Sets the length of the character sequence. The sequence is changed to a new character sequence whose length is specified by the argument. For every nonnegative index k less than newLength, the character at index k in the new character sequence is the same as the character at index k in the old sequence if k is less than the length of the old character sequence; otherwise, it is the null character '\u0000'. In other words, if the newLength argument is less than the current length, the length is changed to the specified length.

If the newLength argument is greater than or equal to the current length, sufficient null characters ('\u0000') are appended so that length becomes the newLength argument.

The newLength argument must be greater than or equal to 0.

Parameters:
newLength the new length
Throws:
IndexOutOfBoundsException if the newLength argument is negative.
157
 
158
     public void setLength(int newLength) {
159
         if (newLength < 0)
160
             throw new StringIndexOutOfBoundsException(newLength);
161
         if (newLength > .)
162
             expandCapacity(newLength);
163
 
164
         if ( < newLength) {
165
             for (;  < newLength; ++)
166
                 [] = '\0';
167
         } else {
168
              = newLength;
169
         }
170
     }

    
Returns the char value in this sequence at the specified index. The first char value is at index 0, the next at index 1, and so on, as in array indexing.

The index argument must be greater than or equal to 0, and less than the length of this sequence.

If the char value specified by the index is a surrogate, the surrogate value is returned.

Parameters:
index the index of the desired char value.
Returns:
the char value at the specified index.
Throws:
IndexOutOfBoundsException if index is negative or greater than or equal to length().
188
 
189
     public char charAt(int index) {
190
         if ((index < 0) || (index >= ))
191
             throw new StringIndexOutOfBoundsException(index);
192
         return [index];
193
     }

    
Returns the character (Unicode code point) at the specified index. The index refers to char values (Unicode code units) and ranges from 0 to length() - 1.

If the char value specified at the given index is in the high-surrogate range, the following index is less than the length of this sequence, and the char value at the following index is in the low-surrogate range, then the supplementary code point corresponding to this surrogate pair is returned. Otherwise, the char value at the given index is returned.

Parameters:
index the index to the char values
Returns:
the code point value of the character at the index
Throws:
IndexOutOfBoundsException if the index argument is negative or not less than the length of this sequence.
215
 
216
     public int codePointAt(int index) {
217
         if ((index < 0) || (index >= )) {
218
             throw new StringIndexOutOfBoundsException(index);
219
         }
220
         return Character.codePointAt(, index);
221
     }

    
Returns the character (Unicode code point) before the specified index. The index refers to char values (Unicode code units) and ranges from 1 to length().

If the char value at (index - 1) is in the low-surrogate range, (index - 2) is not negative, and the char value at (index - 2) is in the high-surrogate range, then the supplementary code point value of the surrogate pair is returned. If the char value at index - 1 is an unpaired low-surrogate or a high-surrogate, the surrogate value is returned.

Parameters:
index the index following the code point that should be returned
Returns:
the Unicode code point value before the given index.
Throws:
IndexOutOfBoundsException if the index argument is less than 1 or greater than the length of this sequence.
243
 
244
     public int codePointBefore(int index) {
245
         int i = index - 1;
246
         if ((i < 0) || (i >= )) {
247
             throw new StringIndexOutOfBoundsException(index);
248
         }
249
         return Character.codePointBefore(, index);
250
     }

    
Returns the number of Unicode code points in the specified text range of this sequence. The text range begins at the specified beginIndex and extends to the char at index endIndex - 1. Thus the length (in chars) of the text range is endIndex-beginIndex. Unpaired surrogates within this sequence count as one code point each.

Parameters:
beginIndex the index to the first char of the text range.
endIndex the index after the last char of the text range.
Returns:
the number of Unicode code points in the specified text range
Throws:
IndexOutOfBoundsException if the beginIndex is negative, or endIndex is larger than the length of this sequence, or beginIndex is larger than endIndex.
271
 
272
     public int codePointCount(int beginIndex, int endIndex) {
273
         if (beginIndex < 0 || endIndex >  || beginIndex > endIndex) {
274
             throw new IndexOutOfBoundsException();
275
         }
276
         return Character.codePointCountImpl(, beginIndex, endIndex-beginIndex);
277
     }

    
Returns the index within this sequence that is offset from the given index by codePointOffset code points. Unpaired surrogates within the text range given by index and codePointOffset count as one code point each.

Parameters:
index the index to be offset
codePointOffset the offset in code points
Returns:
the index within this sequence
Throws:
IndexOutOfBoundsException if index is negative or larger then the length of this sequence, or if codePointOffset is positive and the subsequence starting with index has fewer than codePointOffset code points, or if codePointOffset is negative and the subsequence before index has fewer than the absolute value of codePointOffset code points.
297
 
298
     public int offsetByCodePoints(int index, int codePointOffset) {
299
         if (index < 0 || index > ) {
300
             throw new IndexOutOfBoundsException();
301
         }
302
         return Character.offsetByCodePointsImpl(, 0, ,
303
                                                 index, codePointOffset);
304
     }

    
Characters are copied from this sequence into the destination character array dst. The first character to be copied is at index srcBegin; the last character to be copied is at index srcEnd-1. The total number of characters to be copied is srcEnd-srcBegin. The characters are copied into the subarray of dst starting at index dstBegin and ending at index: 

 dstbegin + (srcEnd-srcBegin) - 1

Parameters:
srcBegin start copying at this offset.
srcEnd stop copying at this offset.
dst the array to copy the data into.
dstBegin offset into dst.
Throws:
NullPointerException if dst is null.
IndexOutOfBoundsException if any of the following is true:
  • srcBegin is negative
  • dstBegin is negative
  • the srcBegin argument is greater than the srcEnd argument.
  • srcEnd is greater than this.length().
  • dstBegin+srcEnd-srcBegin is greater than dst.length 
335
 
336
     public void getChars(int srcBegin, int srcEnd, char dst[],
337
                                       int dstBegin)
338
     {
339
         if (srcBegin < 0)
340
             throw new StringIndexOutOfBoundsException(srcBegin);
341
         if ((srcEnd < 0) || (srcEnd > ))
342
             throw new StringIndexOutOfBoundsException(srcEnd);
343
         if (srcBegin > srcEnd)
344
             throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
345
         System.arraycopy(, srcBegin, dst, dstBegin, srcEnd - srcBegin);
346
     }

    
The character at the specified index is set to ch. This sequence is altered to represent a new character sequence that is identical to the old character sequence, except that it contains the character ch at position index.

The index argument must be greater than or equal to 0, and less than the length of this sequence.

Parameters:
index the index of the character to modify.
ch the new character.
Throws:
IndexOutOfBoundsException if index is negative or greater than or equal to length().
361
 
362
     public void setCharAt(int index, char ch) {
363
         if ((index < 0) || (index >= ))
364
             throw new StringIndexOutOfBoundsException(index);
365
         [index] = ch;
366
     }

    
Appends the string representation of the Object argument.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this sequence.

Parameters:
obj an Object.
Returns:
a reference to this object.
378
 
379
     public AbstractStringBuilder append(Object obj) {
380
         return append(String.valueOf(obj));
381
     }

    
Appends the specified string to this character sequence.

The characters of the String argument are appended, in order, increasing the length of this sequence by the length of the argument. If str is null, then the four characters "null" are appended.

Let n be the length of this character sequence just prior to execution of the append method. Then the character at index k in the new character sequence is equal to the character at index k in the old character sequence, if k is less than n; otherwise, it is equal to the character at index k-n in the argument str.

Parameters:
str a string.
Returns:
a reference to this object.
400
 
401
     public AbstractStringBuilder append(String str) {
402
         if (str == null) str = "null";
403
         int len = str.length();
404
         if (len == 0) return this;
405
         int newCount =  + len;
406
         if (newCount > .)
407
             expandCapacity(newCount);
408
         str.getChars(0, len, , );
409
          = newCount;
410
         return this;
411
     }
412
 
413
     // Documentation in subclasses because of synchro difference
414
     public AbstractStringBuilder append(StringBuffer sb) {
415
         if (sb == null)
416
             return append("null");
417
         int len = sb.length();
418
         int newCount =  + len;
419
         if (newCount > .)
420
             expandCapacity(newCount);
421
         sb.getChars(0, len, , );
422
          = newCount;
423
         return this;
424
     }
425
 
426
     // Documentation in subclasses because of synchro difference
427
     public AbstractStringBuilder append(CharSequence s) {
428
         if (s == null)
429
             s = "null";
430
         if (s instanceof String)
431
             return this.append((String)s);
432
         if (s instanceof StringBuffer)
433
             return this.append((StringBuffer)s);
434
         return this.append(s, 0, s.length());
435
     }

    
Appends a subsequence of the specified CharSequence to this sequence.

Characters of the argument s, starting at index start, are appended, in order, to the contents of this sequence up to the (exclusive) index end. The length of this sequence is increased by the value of end - start.

Let n be the length of this character sequence just prior to execution of the append method. Then the character at index k in this character sequence becomes equal to the character at index k in this sequence, if k is less than n; otherwise, it is equal to the character at index k+start-n in the argument s.

If s is null, then this method appends characters as if the s parameter was a sequence containing the four characters "null".

Parameters:
s the sequence to append.
start the starting index of the subsequence to be appended.
end the end index of the subsequence to be appended.
Returns:
a reference to this object.
Throws:
IndexOutOfBoundsException if start or end are negative, or start is greater than end or end is greater than s.length()
465
 
466
     public AbstractStringBuilder append(CharSequence s, int start, int end) {
467
         if (s == null)
468
             s = "null";
469
         if ((start < 0) || (end < 0) || (start > end) || (end > s.length()))
470
             throw new IndexOutOfBoundsException(
471
                 "start " + start + ", end " + end + ", s.length() "
472
                 + s.length());
473
         int len = end - start;
474
         if (len == 0)
475
             return this;
476
         int newCount =  + len;
477
         if (newCount > .)
478
             expandCapacity(newCount);
479
         for (int i=start; i<end; i++)
480
             [++] = s.charAt(i);
481
          = newCount;
482
         return this;
483
     }

    
Appends the string representation of the char array argument to this sequence.

The characters of the array argument are appended, in order, to the contents of this sequence. The length of this sequence increases by the length of the argument.

The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(char[]) and the characters of that string were then appended to this character sequence.

Parameters:
str the characters to be appended.
Returns:
a reference to this object.
500
 
501
     public AbstractStringBuilder append(char str[]) {
502
         int newCount =  + str.length;
503
         if (newCount > .)
504
             expandCapacity(newCount);
505
         System.arraycopy(str, 0, , , str.length);
506
          = newCount;
507
         return this;
508
     }

    
Appends the string representation of a subarray of the char array argument to this sequence.

Characters of the char array str, starting at index offset, are appended, in order, to the contents of this sequence. The length of this sequence increases by the value of len.

The overall effect is exactly as if the arguments were converted to a string by the method String.valueOf(char[],int,int) and the characters of that string were then appended to this character sequence.

Parameters:
str the characters to be appended.
offset the index of the first char to append.
len the number of chars to append.
Returns:
a reference to this object.
528
 
529
     public AbstractStringBuilder append(char str[], int offset, int len) {
530
         int newCount =  + len;
531
         if (newCount > .)
532
             expandCapacity(newCount);
533
         System.arraycopy(str, offset, , , len);
534
          = newCount;
535
         return this;
536
     }

    
Appends the string representation of the boolean argument to the sequence.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this sequence.

Parameters:
b a boolean.
Returns:
a reference to this object.
548
 
549
     public AbstractStringBuilder append(boolean b) {
550
         if (b) {
551
             int newCount =  + 4;
552
             if (newCount > .)
553
                 expandCapacity(newCount);
554
             [++] = 't';
555
             [++] = 'r';
556
             [++] = 'u';
557
             [++] = 'e';
558
         } else {
559
             int newCount =  + 5;
560
             if (newCount > .)
561
                 expandCapacity(newCount);
562
             [++] = 'f';
563
             [++] = 'a';
564
             [++] = 'l';
565
             [++] = 's';
566
             [++] = 'e';
567
         }
568
         return this;
569
     }

    
Appends the string representation of the char argument to this sequence.

The argument is appended to the contents of this sequence. The length of this sequence increases by 1.

The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(char) and the character in that string were then appended to this character sequence.

Parameters:
c a char.
Returns:
a reference to this object.
585
 
586
     public AbstractStringBuilder append(char c) {
587
         int newCount =  + 1;
588
         if (newCount > .)
589
             expandCapacity(newCount);
590
         [++] = c;
591
         return this;
592
     }

    
Appends the string representation of the int argument to this sequence.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this sequence.

Parameters:
i an int.
Returns:
a reference to this object.
604
 
605
     public AbstractStringBuilder append(int i) {
606
         if (i == .) {
607
             append("-2147483648");
608
             return this;
609
         }
610
         int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
611
                                      : Integer.stringSize(i);
612
         int spaceNeeded =  + appendedLength;
613
         if (spaceNeeded > .)
614
             expandCapacity(spaceNeeded);
615
         Integer.getChars(i, spaceNeeded, );
616
          = spaceNeeded;
617
         return this;
618
     }

    
Appends the string representation of the long argument to this sequence.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this sequence.

Parameters:
l a long.
Returns:
a reference to this object.
630
 
631
     public AbstractStringBuilder append(long l) {
632
         if (l == .) {
633
             append("-9223372036854775808");
634
             return this;
635
         }
636
         int appendedLength = (l < 0) ? Long.stringSize(-l) + 1
637
                                      : Long.stringSize(l);
638
         int spaceNeeded =  + appendedLength;
639
         if (spaceNeeded > .)
640
             expandCapacity(spaceNeeded);
641
         Long.getChars(l, spaceNeeded, );
642
          = spaceNeeded;
643
         return this;
644
     }

    
Appends the string representation of the float argument to this sequence.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this string sequence.

Parameters:
f a float.
Returns:
a reference to this object.
656
 
657
     public AbstractStringBuilder append(float f) {
658
         new FloatingDecimal(f).appendTo(this);
659
         return this;
660
     }

    
Appends the string representation of the double argument to this sequence.

The argument is converted to a string as if by the method String.valueOf, and the characters of that string are then appended to this sequence.

Parameters:
d a double.
Returns:
a reference to this object.
672
 
673
     public AbstractStringBuilder append(double d) {
674
         new FloatingDecimal(d).appendTo(this);
675
         return this;
676
     }

    
Removes the characters in a substring of this sequence. The substring begins at the specified start and extends to the character at index end - 1 or to the end of the sequence if no such character exists. If start is equal to end, no changes are made.

Parameters:
start The beginning index, inclusive.
end The ending index, exclusive.
Returns:
This object.
Throws:
StringIndexOutOfBoundsException if start is negative, greater than length(), or greater than end.
691
 
692
     public AbstractStringBuilder delete(int start, int end) {
693
         if (start < 0)
694
             throw new StringIndexOutOfBoundsException(start);
695
         if (end > )
696
             end = ;
697
         if (start > end)
698
             throw new StringIndexOutOfBoundsException();
699
         int len = end - start;
700
         if (len > 0) {
701
             System.arraycopy(, start+len, , start, -end);
702
              -= len;
703
         }
704
         return this;
705
     }

    
Appends the string representation of the codePoint argument to this sequence.

The argument is appended to the contents of this sequence. The length of this sequence increases by Character.charCount(codePoint).

The overall effect is exactly as if the argument were converted to a char array by the method Character.toChars(int) and the character in that array were then appended to this character sequence.

Parameters:
codePoint a Unicode code point
Returns:
a reference to this object.
Throws:
IllegalArgumentException if the specified codePoint isn't a valid Unicode code point
725
 
726
     public AbstractStringBuilder appendCodePoint(int codePoint) {
727
         if (!Character.isValidCodePoint(codePoint)) {
728
             throw new IllegalArgumentException();
729
         }
730
         int n = 1;
731
         if (codePoint >= .) {
732
             n++;
733
         }
734
         int newCount =  + n;
735
         if (newCount > .) {
736
             expandCapacity(newCount);
737
         }
738
         if (n == 1) {
739
             [++] = (char) codePoint;
740
         } else {
741
             Character.toSurrogates(codePoint, , );
742
              += n;
743
         }
744
         return this;
745
     }

    
Removes the char at the specified position in this sequence. This sequence is shortened by one char.

Note: If the character at the given index is a supplementary character, this method does not remove the entire character. If correct handling of supplementary characters is required, determine the number of chars to remove by calling Character.charCount(thisSequence.codePointAt(index)), where thisSequence is this sequence.

Parameters:
index Index of char to remove
Returns:
This object.
Throws:
StringIndexOutOfBoundsException if the index is negative or greater than or equal to length().
763
 
764
     public AbstractStringBuilder deleteCharAt(int index) {
765
         if ((index < 0) || (index >= ))
766
             throw new StringIndexOutOfBoundsException(index);
767
         System.arraycopy(, index+1, , index, -index-1);
768
         --;
769
         return this;
770
     }

    
Replaces the characters in a substring of this sequence with characters in the specified String. The substring begins at the specified start and extends to the character at index end - 1 or to the end of the sequence if no such character exists. First the characters in the substring are removed and then the specified String is inserted at start. (This sequence will be lengthened to accommodate the specified String if necessary.)

Parameters:
start The beginning index, inclusive.
end The ending index, exclusive.
str String that will replace previous contents.
Returns:
This object.
Throws:
StringIndexOutOfBoundsException if start is negative, greater than length(), or greater than end.
790
 
791
     public AbstractStringBuilder replace(int start, int end, String str) {
792
         if (start < 0)
793
             throw new StringIndexOutOfBoundsException(start);
794
         if (start > )
795
             throw new StringIndexOutOfBoundsException("start > length()");
796
         if (start > end)
797
             throw new StringIndexOutOfBoundsException("start > end");
798
 
799
         if (end > )
800
             end = ;
801
         int len = str.length();
802
         int newCount =  + len - (end - start);
803
         if (newCount > .)
804
             expandCapacity(newCount);
805
 
806
         System.arraycopy(, end, , start + len,  - end);
807
         str.getChars(, start);
808
          = newCount;
809
         return this;
810
     }

    
Returns a new String that contains a subsequence of characters currently contained in this character sequence. The substring begins at the specified index and extends to the end of this sequence.

Parameters:
start The beginning index, inclusive.
Returns:
The new string.
Throws:
StringIndexOutOfBoundsException if start is less than zero, or greater than the length of this object.
822
 
823
     public String substring(int start) {
824
         return substring(start, );
825
     }

    
Returns a new character sequence that is a subsequence of this sequence.

An invocation of this method of the form 

 sb.subSequence(begin, end)
behaves in exactly the same way as the invocation 
 sb.substring(begin, end)
This method is provided so that this class can implement the CharSequence interface.

Parameters:
start the start index, inclusive.
end the end index, exclusive.
Returns:
the specified subsequence.
Throws:
IndexOutOfBoundsException if start or end are negative, if end is greater than length(), or if start is greater than end
Spec:
JSR-51
852
 
853
     public CharSequence subSequence(int start, int end) {
854
         return substring(start, end);
855
     }

    
Returns a new String that contains a subsequence of characters currently contained in this sequence. The substring begins at the specified start and extends to the character at index end - 1.

Parameters:
start The beginning index, inclusive.
end The ending index, exclusive.
Returns:
The new string.
Throws:
StringIndexOutOfBoundsException if start or end are negative or greater than length(), or start is greater than end.
870
 
871
     public String substring(int start, int end) {
872
         if (start < 0)
873
             throw new StringIndexOutOfBoundsException(start);
874
         if (end > )
875
             throw new StringIndexOutOfBoundsException(end);
876
         if (start > end)
877
             throw new StringIndexOutOfBoundsException(end - start);
878
         return new String(, start, end - start);
879
     }

    
Inserts the string representation of a subarray of the str array argument into this sequence. The subarray begins at the specified offset and extends len chars. The characters of the subarray are inserted into this sequence at the position indicated by index. The length of this sequence increases by len chars.

Parameters:
index position at which to insert subarray.
str A char array.
offset the index of the first char in subarray to be inserted.
len the number of chars in the subarray to be inserted.
Returns:
This object
Throws:
StringIndexOutOfBoundsException if index is negative or greater than length(), or offset or len are negative, or (offset+len) is greater than str.length.
901
 
902
     public AbstractStringBuilder insert(int index, char str[], int offset,
903
                                         int len)
904
     {
905
         if ((index < 0) || (index > length()))
906
             throw new StringIndexOutOfBoundsException(index);
907
         if ((offset < 0) || (len < 0) || (offset > str.length - len))
908
             throw new StringIndexOutOfBoundsException(
909
                 "offset " + offset + ", len " + len + ", str.length "
910
                 + str.length);
911
         int newCount =  + len;
912
         if (newCount > .)
913
             expandCapacity(newCount);
914
         System.arraycopy(, index, , index + len,  - index);
915
         System.arraycopy(str, offset, , index, len);
916
          = newCount;
917
         return this;
918
     }

    
Inserts the string representation of the Object argument into this character sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the indicated offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
obj an Object.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
937
 
938
     public AbstractStringBuilder insert(int offset, Object obj) {
939
         return insert(offset, String.valueOf(obj));
940
     }

    
Inserts the string into this character sequence.

The characters of the String argument are inserted, in order, into this sequence at the indicated offset, moving up any characters originally above that position and increasing the length of this sequence by the length of the argument. If str is null, then the four characters "null" are inserted into this sequence.

The character at index k in the new character sequence is equal to:

  • the character at index k in the old character sequence, if k is less than offset
  • the character at index k-offset in the argument str, if k is not less than offset but is less than offset+str.length()
  • the character at index k-str.length() in the old character sequence, if k is not less than offset+str.length()

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
str a string.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
972
 
973
     public AbstractStringBuilder insert(int offset, String str) {
974
         if ((offset < 0) || (offset > length()))
975
             throw new StringIndexOutOfBoundsException(offset);
976
         if (str == null)
977
             str = "null";
978
         int len = str.length();
979
         int newCount =  + len;
980
         if (newCount > .)
981
             expandCapacity(newCount);
982
         System.arraycopy(, offset, , offset + len,  - offset);
983
         str.getChars(, offset);
984
          = newCount;
985
         return this;
986
     }

    
Inserts the string representation of the char array argument into this sequence.

The characters of the array argument are inserted into the contents of this sequence at the position indicated by offset. The length of this sequence increases by the length of the argument.

The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(char[]) and the characters of that string were then inserted into this character sequence at the position indicated by offset.

Parameters:
offset the offset.
str a character array.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1009
    public AbstractStringBuilder insert(int offset, char str[]) {
1010
        if ((offset < 0) || (offset > length()))
1011
            throw new StringIndexOutOfBoundsException(offset);
1012
        int len = str.length;
1013
        int newCount =  + len;
1014
        if (newCount > .)
1015
            expandCapacity(newCount);
1016
        System.arraycopy(, offset, , offset + len,  - offset);
1017
        System.arraycopy(str, 0, , offset, len);
1018
         = newCount;
1019
        return this;
1020
    }

    
Inserts the specified CharSequence into this sequence.

The characters of the CharSequence argument are inserted, in order, into this sequence at the indicated offset, moving up any characters originally above that position and increasing the length of this sequence by the length of the argument s.

The result of this method is exactly the same as if it were an invocation of this object's insert(dstOffset, s, 0, s.length()) method.

If s is null, then the four characters "null" are inserted into this sequence.

Parameters:
dstOffset the offset.
s the sequence to be inserted
Returns:
a reference to this object.
Throws:
IndexOutOfBoundsException if the offset is invalid.
1041
    public AbstractStringBuilder insert(int dstOffset, CharSequence s) {
1042
        if (s == null)
1043
            s = "null";
1044
        if (s instanceof String)
1045
            return this.insert(dstOffset, (String)s);
1046
        return this.insert(dstOffset, s, 0, s.length());
1047
    }

    
Inserts a subsequence of the specified CharSequence into this sequence.

The subsequence of the argument s specified by start and end are inserted, in order, into this sequence at the specified destination offset, moving up any characters originally above that position. The length of this sequence is increased by end - start.

The character at index k in this sequence becomes equal to:

  • the character at index k in this sequence, if k is less than dstOffset
  • the character at index k+start-dstOffset in the argument s, if k is greater than or equal to dstOffset but is less than dstOffset+end-start
  • the character at index k-(end-start) in this sequence, if k is greater than or equal to dstOffset+end-start

The dstOffset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

The start argument must be nonnegative, and not greater than end.

The end argument must be greater than or equal to start, and less than or equal to the length of s.

If s is null, then this method inserts characters as if the s parameter was a sequence containing the four characters "null".

Parameters:
dstOffset the offset in this sequence.
s the sequence to be inserted.
start the starting index of the subsequence to be inserted.
end the end index of the subsequence to be inserted.
Returns:
a reference to this object.
Throws:
IndexOutOfBoundsException if dstOffset is negative or greater than this.length(), or start or end are negative, or start is greater than end or end is greater than s.length()
1093
     public AbstractStringBuilder insert(int dstOffset, CharSequence s,
1094
                                           int start, int end) {
1095
        if (s == null)
1096
            s = "null";
1097
        if ((dstOffset < 0) || (dstOffset > this.length()))
1098
            throw new IndexOutOfBoundsException("dstOffset "+dstOffset);
1099
        if ((start < 0) || (end < 0) || (start > end) || (end > s.length()))
1100
            throw new IndexOutOfBoundsException(
1101
                "start " + start + ", end " + end + ", s.length() "
1102
                + s.length());
1103
        int len = end - start;
1104
        if (len == 0)
1105
            return this;
1106
        int newCount =  + len;
1107
        if (newCount > .)
1108
            expandCapacity(newCount);
1109
        System.arraycopy(, dstOffset, , dstOffset + len,
1110
                          - dstOffset);
1111
        for (int i=start; i<end; i++)
1112
            [dstOffset++] = s.charAt(i);
1113
         = newCount;
1114
        return this;
1115
    }

    
Inserts the string representation of the boolean argument into this sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the indicated offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
b a boolean.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1135
    public AbstractStringBuilder insert(int offset, boolean b) {
1136
        return insert(offset, String.valueOf(b));
1137
    }

    
Inserts the string representation of the char argument into this sequence.

The second argument is inserted into the contents of this sequence at the position indicated by offset. The length of this sequence increases by one.

The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(char) and the character in that string were then inserted into this character sequence at the position indicated by offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
c a char.
Returns:
a reference to this object.
Throws:
IndexOutOfBoundsException if the offset is invalid.
1162
    public AbstractStringBuilder insert(int offset, char c) {
1163
        int newCount =  + 1;
1164
        if (newCount > .)
1165
            expandCapacity(newCount);
1166
        System.arraycopy(, offset, , offset + 1,  - offset);
1167
        [offset] = c;
1168
         = newCount;
1169
        return this;
1170
    }

    
Inserts the string representation of the second int argument into this sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the indicated offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
i an int.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1190
    public AbstractStringBuilder insert(int offset, int i) {
1191
        return insert(offset, String.valueOf(i));
1192
    }

    
Inserts the string representation of the long argument into this sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the position indicated by offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
l a long.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1212
    public AbstractStringBuilder insert(int offset, long l) {
1213
        return insert(offset, String.valueOf(l));
1214
    }

    
Inserts the string representation of the float argument into this sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the indicated offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
f a float.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1234
    public AbstractStringBuilder insert(int offset, float f) {
1235
        return insert(offset, String.valueOf(f));
1236
    }

    
Inserts the string representation of the double argument into this sequence.

The second argument is converted to a string as if by the method String.valueOf, and the characters of that string are then inserted into this sequence at the indicated offset.

The offset argument must be greater than or equal to 0, and less than or equal to the length of this sequence.

Parameters:
offset the offset.
d a double.
Returns:
a reference to this object.
Throws:
StringIndexOutOfBoundsException if the offset is invalid.
1256
    public AbstractStringBuilder insert(int offset, double d) {
1257
        return insert(offset, String.valueOf(d));
1258
    }

    
Returns the index within this string of the first occurrence of the specified substring. The integer returned is the smallest value k such that: 
 this.toString().startsWith(str, k)
is true.

Parameters:
str any string.
Returns:
if the string argument occurs as a substring within this object, then the index of the first character of the first such substring is returned; if it does not occur as a substring, -1 is returned.
Throws:
NullPointerException if str is null.
1277
    public int indexOf(String str) {
1278
        return indexOf(str, 0);
1279
    }

    
Returns the index within this string of the first occurrence of the specified substring, starting at the specified index. The integer returned is the smallest value k for which: 
     k >= Math.min(fromIndex, str.length()) &&
                   this.toString().startsWith(str, k)
If no such value of k exists, then -1 is returned.

Parameters:
str the substring for which to search.
fromIndex the index from which to start the search.
Returns:
the index within this string of the first occurrence of the specified substring, starting at the specified index.
Throws:
NullPointerException if str is null.
1298
    public int indexOf(String str, int fromIndex) {
1299
        return String.indexOf(, 0, ,
1300
                              str.toCharArray(), 0, str.length(), fromIndex);
1301
    }

    
Returns the index within this string of the rightmost occurrence of the specified substring. The rightmost empty string "" is considered to occur at the index value this.length(). The returned index is the largest value k such that 
 this.toString().startsWith(str, k)
is true.

Parameters:
str the substring to search for.
Returns:
if the string argument occurs one or more times as a substring within this object, then the index of the first character of the last such substring is returned. If it does not occur as a substring, -1 is returned.
Throws:
NullPointerException if str is null.
1321
    public int lastIndexOf(String str) {
1322
        return lastIndexOf(str, );
1323
    }

    
Returns the index within this string of the last occurrence of the specified substring. The integer returned is the largest value k such that: 
     k <= Math.min(fromIndex, str.length()) &&
                   this.toString().startsWith(str, k)
If no such value of k exists, then -1 is returned.

Parameters:
str the substring to search for.
fromIndex the index to start the search from.
Returns:
the index within this sequence of the last occurrence of the specified substring.
Throws:
NullPointerException if str is null.
1342
    public int lastIndexOf(String str, int fromIndex) {
1343
        return String.lastIndexOf(, 0, ,
1344
                              str.toCharArray(), 0, str.length(), fromIndex);
1345
    }

    
Causes this character sequence to be replaced by the reverse of the sequence. If there are any surrogate pairs included in the sequence, these are treated as single characters for the reverse operation. Thus, the order of the high-low surrogates is never reversed. Let n be the character length of this character sequence (not the length in char values) just prior to execution of the reverse method. Then the character at index k in the new character sequence is equal to the character at index n-k-1 in the old character sequence.

Note that the reverse operation may result in producing surrogate pairs that were unpaired low-surrogates and high-surrogates before the operation. For example, reversing "\uDC00\uD800" produces "\uD800\uDC00" which is a valid surrogate pair.

Returns:
a reference to this object.
1369
    public AbstractStringBuilder reverse() {
1370
        boolean hasSurrogate = false;
1371
        int n =  - 1;
1372
        for (int j = (n-1) >> 1; j >= 0; --j) {
1373
            char temp = [j];
1374
            char temp2 = [n - j];
1375
            if (!hasSurrogate) {
1376
                hasSurrogate = (temp >= . && temp <= .)
1377
                    || (temp2 >= . && temp2 <= .);
1378
            }
1379
            [j] = temp2;
1380
            [n - j] = temp;
1381
        }
1382
        if (hasSurrogate) {
1383
            // Reverse back all valid surrogate pairs
1384
            for (int i = 0; i <  - 1; i++) {
1385
                char c2 = [i];
1386
                if (Character.isLowSurrogate(c2)) {
1387
                    char c1 = [i + 1];
1388
                    if (Character.isHighSurrogate(c1)) {
1389
                        [i++] = c1;
1390
                        [i] = c2;
1391
                    }
1392
                }
1393
            }
1394
        }
1395
        return this;
1396
    }

    
Returns a string representing the data in this sequence. A new String object is allocated and initialized to contain the character sequence currently represented by this object. This String is then returned. Subsequent changes to this sequence do not affect the contents of the String.

Returns:
a string representation of this sequence of characters.
1408
    public abstract String toString();

    
Needed by String for the contentEquals method. 
1413
    final char[] getValue() {
1414
        return ;
1415
    }
New to GrepCode? Check out our FAQ X