Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Licensed to the Apache Software Foundation (ASF) under one or more
3
    * contributor license agreements.  See the NOTICE file distributed with
4
    * this work for additional information regarding copyright ownership.
5
    * The ASF licenses this file to You under the Apache License, Version 2.0
6
    * (the "License"); you may not use this file except in compliance with
7
    * the License.  You may obtain a copy of the License at
8
    *
9
    *      http://www.apache.org/licenses/LICENSE-2.0
10
   *
11
   * Unless required by applicable law or agreed to in writing, software
12
   * distributed under the License is distributed on an "AS IS" BASIS,
13
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
   * See the License for the specific language governing permissions and
15
   * limitations under the License.
16
   */
17
  package org.apache.wicket.util.string;
18
  
This is a copy or combination of java.lang.StringBuffer and java.lang.String It has a special method getValue() which returns the internal char array. Hashcode and equals methods are also implemented. This AppendingStringBuffer is not synchronized.

Author(s):
Johan Compagner
See also:
java.lang.StringBuffer
32
  
33
  
34
  public final class AppendingStringBuffer implements java.io.Serializable, CharSequence
35
  {
use serialVersionUID from JDK 1.0.2 for interoperability
36
  
37
  	static final long serialVersionUID = 1L;
38
  
39
  	private static final AppendingStringBuffer NULL = new AppendingStringBuffer("null");
40
  	private static final StringBuffer SB_NULL = new StringBuffer("null");
The value is used for character storage.

Serial:
46
  
47
  	private char value[];
The count is the number of characters in the buffer.

Serial:
53
  
54
  	private int count;
Constructs a string buffer with no characters in it and an initial capacity of 16 characters. 
58
  
60
  	{
61
  		this(16);
62
  	}
Constructs a string buffer with no characters in it and an initial capacity specified by the length argument.

Parameters:
length the initial capacity.
Throws:
java.lang.NegativeArraySizeException if the length argument is less than 0.
72
  
73
  	public AppendingStringBuffer(int length)
74
  	{
75
  		 = new char[length];
76
  	}
Constructs a string buffer so that it represents the same sequence of characters as the string argument; in other words, the initial contents of the string buffer is a copy of the argument string. The initial capacity of the string buffer is 16 plus the length of the string argument.

Parameters:
str the initial contents of the buffer.
Throws:
java.lang.NullPointerException if str is null
88
  
90
  	{
91
  		this(str.length() + 16);
92
  		append(str);
93
  	}
Returns the length (character count) of this string buffer.

Returns:
the length of the sequence of characters currently represented by this string buffer.
99
  
100
 	public int length()
101
 	{
102
 		return ;
103
 	}
Returns the current capacity of the String buffer. The capacity is the amount of storage available for newly inserted characters; beyond which an allocation will occur.

Returns:
the current capacity of this string buffer.
110
 
111
 	public int capacity()
112
 	{
113
 		return .;
114
 	}
Ensures that the capacity of the buffer is at least equal to the specified minimum. If the current capacity of this string buffer is less than the argument, then a new internal buffer 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.
129
 
130
 	public void ensureCapacity(int minimumCapacity)
131
 	{
132
 		if (minimumCapacity > .)
133
 		{
134
 			expandCapacity(minimumCapacity);
135
 		}
136
 	}
This implements the expansion semantics of ensureCapacity but is unsynchronized for use internally by methods which are already synchronized.

Parameters:
minimumCapacity
See also:
java.lang.StringBuffer.ensureCapacity(int)
145
 
146
 	private void expandCapacity(int minimumCapacity)
147
 	{
148
 		int newCapacity = (. + 1) * 2;
149
 		if (newCapacity < 0)
150
 		{
151
 			newCapacity = .;
152
 		}
153
 		else if (minimumCapacity > newCapacity)
154
 		{
155
 			newCapacity = minimumCapacity;
156
 		}
157
 
158
 		char newValue[] = new char[newCapacity];
159
 		System.arraycopy(, 0, newValue, 0, );
160
 		 = newValue;
161
 	}
Sets the length of this String buffer. This string buffer is altered to represent 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 of the string buffer, the string buffer is truncated to contain exactly the number of characters given by the newLength argument.

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

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

Parameters:
newLength the new length of the buffer.
Throws:
java.lang.IndexOutOfBoundsException if the newLength argument is negative.
See also:
java.lang.StringBuffer.length()
186
 
187
 	public void setLength(int newLength)
188
 	{
189
 		if (newLength < 0)
190
 		{
191
 			throw new StringIndexOutOfBoundsException(newLength);
192
 		}
193
 
194
 		if (newLength > .)
195
 		{
196
 			expandCapacity(newLength);
197
 		}
198
 
199
 		if ( < newLength)
200
 		{
201
 			for (;  < newLength; ++)
202
 			{
203
 				[] = '\0';
204
 			}
205
 		}
206
 		else
207
 		{
208
 			 = newLength;
209
 		}
210
 	}
The specified character of the sequence currently represented by the string buffer, as indicated by the index argument, is returned. The first character of a string buffer is at index 0, the next at index 1, and so on, for array indexing.

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

Parameters:
index the index of the desired character.
Returns:
the character at the specified index of this string buffer.
Throws:
java.lang.IndexOutOfBoundsException if index is negative or greater than or equal to length().
See also:
java.lang.StringBuffer.length()
228
 
229
 	public char charAt(int index)
230
 	{
231
 		if ((index < 0) || (index >= ))
232
 		{
233
 			throw new StringIndexOutOfBoundsException(index);
234
 		}
235
 		return [index];
236
 	}
Characters are copied from this string buffer 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 in the string buffer.
srcEnd stop copying at this offset in the string buffer.
dst the array to copy the data into.
dstBegin offset into dst.
Throws:
java.lang.NullPointerException if dst is null.
java.lang.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(), the current length of this string buffer.
  • dstBegin+srcEnd-srcBegin is greater than dst.length 
276
 
277
 	public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)
278
 	{
279
 		if (srcBegin < 0)
280
 		{
281
 			throw new StringIndexOutOfBoundsException(srcBegin);
282
 		}
283
 		if ((srcEnd < 0) || (srcEnd > ))
284
 		{
285
 			throw new StringIndexOutOfBoundsException(srcEnd);
286
 		}
287
 		if (srcBegin > srcEnd)
288
 		{
289
 			throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
290
 		}
291
 		System.arraycopy(, srcBegin, dst, dstBegin, srcEnd - srcBegin);
292
 	}
The character at the specified index of this string buffer is set to ch. The string buffer 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 string buffer.

Parameters:
index the index of the character to modify.
ch the new character.
Throws:
java.lang.IndexOutOfBoundsException if index is negative or greater than or equal to length().
See also:
java.lang.StringBuffer.length()
311
 
312
 	public void setCharAt(int index, char ch)
313
 	{
314
 		if ((index < 0) || (index >= ))
315
 		{
316
 			throw new StringIndexOutOfBoundsException(index);
317
 		}
318
 		[index] = ch;
319
 	}
Appends the string representation of the Object argument to this string buffer.

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 buffer.

Parameters:
obj an Object.
Returns:
a reference to this AppendingStringBuffer object.
See also:
java.lang.String.valueOf(java.lang.Object)
java.lang.StringBuffer.append(java.lang.String)
333
 
335
 	{
336
 		if (obj instanceof AppendingStringBuffer)
337
 		{
339
 		}
340
 		else if (obj instanceof StringBuffer)
341
 		{
342
 			return append((StringBuffer)obj);
343
 		}
344
 		return append(String.valueOf(obj));
345
 	}
Appends the string to this string buffer.

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

Let n be the length of the old character sequence, the one contained in the string buffer 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 AppendingStringBuffer.
364
 
366
 	{
367
 		if (str == null)
368
 		{
369
 			str = String.valueOf(str);
370
 		}
371
 
372
 		int len = str.length();
373
 		int newcount =  + len;
374
 		if (newcount > .)
375
 		{
376
 			expandCapacity(newcount);
377
 		}
378
 		str.getChars(0, len, , );
379
 		 = newcount;
380
 		return this;
381
 	}
Appends the specified AppendingStringBuffer to this AppendingStringBuffer.

The characters of the AppendingStringBuffer argument are appended, in order, to the contents of this AppendingStringBuffer, increasing the length of this AppendingStringBuffer by the length of the argument. If sb is null, then the four characters "null" are appended to this AppendingStringBuffer.

Let n be the length of the old character sequence, the one contained in the AppendingStringBuffer 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 sb.

The method ensureCapacity is first called on this AppendingStringBuffer with the new buffer length as its argument. (This ensures that the storage of this AppendingStringBuffer is adequate to contain the additional characters being appended.)

Parameters:
sb the AppendingStringBuffer to append.
Returns:
a reference to this AppendingStringBuffer.
Since:
1.4
407
 
409
 	{
410
 		if (sb == null)
411
 		{
412
 			sb = ;
413
 		}
414
 
415
 		int len = sb.length();
416
 		int newcount =  + len;
417
 		if (newcount > .)
418
 		{
419
 			expandCapacity(newcount);
420
 		}
421
 		sb.getChars(0, len, , );
422
 		 = newcount;
423
 		return this;
424
 	}
Appends the specified AppendingStringBuffer to this AppendingStringBuffer.

The characters of the AppendingStringBuffer argument are appended, in order, to the contents of this AppendingStringBuffer, increasing the length of this AppendingStringBuffer by the length of the argument. If sb is null, then the four characters "null" are appended to this AppendingStringBuffer.

Let n be the length of the old character sequence, the one contained in the AppendingStringBuffer 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 sb.

The method ensureCapacity is first called on this AppendingStringBuffer with the new buffer length as its argument. (This ensures that the storage of this AppendingStringBuffer is adequate to contain the additional characters being appended.)

Parameters:
sb the AppendingStringBuffer to append.
Returns:
a reference to this AppendingStringBuffer.
Since:
1.4
450
 
452
 	{
453
 		if (sb == null)
454
 		{
455
 			sb = ;
456
 		}
457
 
458
 		int len = sb.length();
459
 		int newcount =  + len;
460
 		if (newcount > .)
461
 		{
462
 			expandCapacity(newcount);
463
 		}
464
 		sb.getChars(0, len, , );
465
 		 = newcount;
466
 		return this;
467
 	}
Appends the specified AppendingStringBuffer to this AppendingStringBuffer.

The characters of the AppendingStringBuffer argument are appended, in order, to the contents of this AppendingStringBuffer, increasing the length of this AppendingStringBuffer by the length of the argument. If sb is null, then the four characters "null" are appended to this AppendingStringBuffer.

Let n be the length of the old character sequence, the one contained in the AppendingStringBuffer 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 sb.

The method ensureCapacity is first called on this AppendingStringBuffer with the new buffer length as its argument. (This ensures that the storage of this AppendingStringBuffer is adequate to contain the additional characters being appended.)

Parameters:
sb the AppendingStringBuffer to append.
from The index where it must start from
length The length that must be copied
Returns:
a reference to this AppendingStringBuffer.
497
 
498
 	public AppendingStringBuffer append(StringBuffer sb, int from, int length)
499
 	{
500
 		if (sb == null)
501
 		{
502
 			sb = ;
503
 		}
504
 
505
 		int newcount =  + length;
506
 		if (newcount > .)
507
 		{
508
 			expandCapacity(newcount);
509
 		}
510
 		sb.getChars(from, length, , );
511
 		 = newcount;
512
 		return this;
513
 	}
Appends the string representation of the char array argument to this string buffer.

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

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

Parameters:
str the characters to be appended.
Returns:
a reference to this AppendingStringBuffer object.
529
 
530
 	public AppendingStringBuffer append(char str[])
531
 	{
532
 		int len = str.length;
533
 		int newcount =  + len;
534
 		if (newcount > .)
535
 		{
536
 			expandCapacity(newcount);
537
 		}
538
 		System.arraycopy(str, 0, , , len);
539
 		 = newcount;
540
 		return this;
541
 	}
Appends the string representation of a subarray of the char array argument to this string buffer.

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

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

Parameters:
str the characters to be appended.
offset the index of the first character to append.
len the number of characters to append.
Returns:
a reference to this AppendingStringBuffer object.
562
 
563
 	public AppendingStringBuffer append(char str[], int offset, int len)
564
 	{
565
 		int newcount =  + len;
566
 		if (newcount > .)
567
 		{
568
 			expandCapacity(newcount);
569
 		}
570
 		System.arraycopy(str, offset, , , len);
571
 		 = newcount;
572
 		return this;
573
 	}
Appends the string representation of the boolean argument to the string buffer.

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 buffer.

Parameters:
b a boolean.
Returns:
a reference to this AppendingStringBuffer.
See also:
java.lang.String.valueOf(boolean)
java.lang.StringBuffer.append(java.lang.String)
587
 
588
 	public AppendingStringBuffer append(boolean b)
589
 	{
590
 		if (b)
591
 		{
592
 			int newcount =  + 4;
593
 			if (newcount > .)
594
 			{
595
 				expandCapacity(newcount);
596
 			}
597
 			[++] = 't';
598
 			[++] = 'r';
599
 			[++] = 'u';
600
 			[++] = 'e';
601
 		}
602
 		else
603
 		{
604
 			int newcount =  + 5;
605
 			if (newcount > .)
606
 			{
607
 				expandCapacity(newcount);
608
 			}
609
 			[++] = 'f';
610
 			[++] = 'a';
611
 			[++] = 'l';
612
 			[++] = 's';
613
 			[++] = 'e';
614
 		}
615
 		return this;
616
 	}
Appends the string representation of the char argument to this string buffer.

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

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

Parameters:
c a char.
Returns:
a reference to this AppendingStringBuffer object.
631
 
632
 	public AppendingStringBuffer append(char c)
633
 	{
634
 		int newcount =  + 1;
635
 		if (newcount > .)
636
 		{
637
 			expandCapacity(newcount);
638
 		}
639
 		[++] = c;
640
 		return this;
641
 	}
Appends the string representation of the int argument to this string buffer.

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 buffer.

Parameters:
i an int.
Returns:
a reference to this AppendingStringBuffer object.
See also:
java.lang.String.valueOf(int)
java.lang.StringBuffer.append(java.lang.String)
654
 
655
 	public AppendingStringBuffer append(int i)
656
 	{
657
 		return append(String.valueOf(i));
658
 	}
Appends the string representation of the long argument to this string buffer.

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 buffer.

Parameters:
l a long.
Returns:
a reference to this AppendingStringBuffer object.
See also:
java.lang.String.valueOf(long)
java.lang.StringBuffer.append(java.lang.String)
671
 
672
 	public AppendingStringBuffer append(long l)
673
 	{
674
 		return append(String.valueOf(l));
675
 	}
Appends the string representation of the float argument to this string buffer.

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 buffer.

Parameters:
f a float.
Returns:
a reference to this AppendingStringBuffer object.
See also:
java.lang.String.valueOf(float)
java.lang.StringBuffer.append(java.lang.String)
688
 
689
 	public AppendingStringBuffer append(float f)
690
 	{
691
 		return append(String.valueOf(f));
692
 	}
Appends the string representation of the double argument to this string buffer.

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 buffer.

Parameters:
d a double.
Returns:
a reference to this AppendingStringBuffer object.
See also:
java.lang.String.valueOf(double)
java.lang.StringBuffer.append(java.lang.String)
706
 
707
 	public AppendingStringBuffer append(double d)
708
 	{
709
 		return append(String.valueOf(d));
710
 	}
Removes the characters in a substring of this AppendingStringBuffer. The substring begins at the specified start and extends to the character at index end - 1 or to the end of the AppendingStringBuffer 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 string buffer.
Throws:
java.lang.StringIndexOutOfBoundsException if start is negative, greater than length(), or greater than end.
Since:
1.2
728
 
729
 	public AppendingStringBuffer delete(int start, int end)
730
 	{
731
 		if (start < 0)
732
 		{
733
 			throw new StringIndexOutOfBoundsException(start);
734
 		}
735
 		if (end > )
736
 		{
737
 			end = ;
738
 		}
739
 		if (start > end)
740
 		{
742
 		}
743
 
744
 		int len = end - start;
745
 		if (len > 0)
746
 		{
747
 			System.arraycopy(, start + len, , start,  - end);
748
 			 -= len;
749
 		}
750
 		return this;
751
 	}
Removes the character at the specified position in this AppendingStringBuffer (shortening the AppendingStringBuffer by one character).

Parameters:
index Index of character to remove
Returns:
This string buffer.
Throws:
java.lang.StringIndexOutOfBoundsException if the index is negative or greater than or equal to length().
Since:
1.2
764
 
765
 	public AppendingStringBuffer deleteCharAt(int index)
766
 	{
767
 		if ((index < 0) || (index >= ))
768
 		{
770
 		}
771
 		System.arraycopy(, index + 1, , index,  - index - 1);
772
 		--;
773
 		return this;
774
 	}
Replaces the characters in a substring of this AppendingStringBuffer 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 AppendingStringBuffer if no such character exists. First the characters in the substring are removed and then the specified String is inserted at start. (The AppendingStringBuffer 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 string buffer.
Throws:
java.lang.StringIndexOutOfBoundsException if start is negative, greater than length(), or greater than end.
Since:
1.2
796
 
797
 	public AppendingStringBuffer replace(int start, int end, String str)
798
 	{
799
 		if (start < 0)
800
 		{
801
 			throw new StringIndexOutOfBoundsException(start);
802
 		}
803
 		if (end > )
804
 		{
805
 			end = ;
806
 		}
807
 		if (start > end)
808
 		{
810
 		}
811
 
812
 		int len = str.length();
813
 		int newCount =  + len - (end - start);
814
 		if (newCount > .)
815
 		{
816
 			expandCapacity(newCount);
817
 		}
818
 
819
 		System.arraycopy(, end, , start + len,  - end);
820
 		str.getChars(0, len, , start);
821
 		 = newCount;
822
 		return this;
823
 	}
Returns a new String that contains a subsequence of characters currently contained in this AppendingStringBuffer.The substring begins at the specified index and extends to the end of the AppendingStringBuffer.

Parameters:
start The beginning index, inclusive.
Returns:
The new string.
Throws:
java.lang.StringIndexOutOfBoundsException if start is less than zero, or greater than the length of this AppendingStringBuffer.
Since:
1.2
837
 
838
 	public String substring(int start)
839
 	{
840
 		return substring(start, );
841
 	}
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 the AppendingStringBuffer class can implement the java.lang.CharSequence interface.

Parameters:
start the start index, inclusive.
end the end index, exclusive.
Returns:
the specified subsequence.
Throws:
java.lang.IndexOutOfBoundsException if start or end are negative, if end is greater than length(), or if start is greater than end
Since:
1.4
Spec:
JSR-51
883
 
884
 	public CharSequence subSequence(int start, int end)
885
 	{
886
 		return this.substring(start, end);
887
 	}
Returns a new String that contains a subsequence of characters currently contained in this AppendingStringBuffer. The substring begins at the specified start and extends to the character at index end - 1. An exception is thrown if

Parameters:
start The beginning index, inclusive.
end The ending index, exclusive.
Returns:
The new string.
Throws:
java.lang.StringIndexOutOfBoundsException if start or end are negative or greater than length(), or start is greater than end.
Since:
1.2
905
 
906
 	public String substring(int start, int end)
907
 	{
908
 		if (start < 0)
909
 		{
910
 			throw new StringIndexOutOfBoundsException(start);
911
 		}
912
 		if (end > )
913
 		{
915
 		}
916
 		if (start > end)
917
 		{
918
 			throw new StringIndexOutOfBoundsException(end - start);
919
 		}
920
 		return new String(, start, end - start);
921
 	}
Inserts the string representation of a subarray of the str array argument into this string buffer. The subarray begins at the specified offset and extends len characters. The characters of the subarray are inserted into this string buffer at the position indicated by index. The length of this AppendingStringBuffer increases by len characters.

Parameters:
index position at which to insert subarray.
str A character array.
offset the index of the first character in subarray to to be inserted.
len the number of characters in the subarray to to be inserted.
Returns:
This string buffer.
Throws:
java.lang.StringIndexOutOfBoundsException if index is negative or greater than length(), or offset or len are negative, or (offset+len) is greater than str.length.
Since:
1.2
944
 
945
 	public AppendingStringBuffer insert(int index, char str[], int offset, int len)
946
 	{
947
 		if ((index < 0) || (index > ))
948
 		{
950
 		}
951
 		if ((offset < 0) || (offset + len < 0) || (offset + len > str.length))
952
 		{
953
 			throw new StringIndexOutOfBoundsException(offset);
954
 		}
955
 		if (len < 0)
956
 		{
958
 		}
959
 		int newCount =  + len;
960
 		if (newCount > .)
961
 		{
962
 			expandCapacity(newCount);
963
 		}
964
 		System.arraycopy(, index, , index + len,  - index);
965
 		System.arraycopy(str, offset, , index, len);
966
 		 = newCount;
967
 		return this;
968
 	}
Inserts the string representation of the Object argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
obj an Object.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(java.lang.Object)
insert(int,java.lang.String)
length()
991
 
992
 	public AppendingStringBuffer insert(int offset, Object obj)
993
 	{
994
 		if (obj instanceof AppendingStringBuffer)
995
 		{
997
 			return insert(offset, asb.value, 0, asb.count);
998
 		}
999
 		else if (obj instanceof StringBuffer)
1001
			return insert(offset, (StringBuffer)obj);
1003
		return insert(offset, String.valueOf(obj));
1004
	}
Inserts the string into this string buffer.

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

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 string buffer.

Parameters:
offset the offset.
str a string.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.StringBuffer.length()
1038
	public AppendingStringBuffer insert(int offset, String str)
1040
		if ((offset < 0) || (offset > ))
1045
		if (str == null)
1047
			str = String.valueOf(str);
1049
		int len = str.length();
1050
		int newcount =  + len;
1051
		if (newcount > .)
1053
			expandCapacity(newcount);
1055
		System.arraycopy(, offset, , offset + len,  - offset);
1056
		str.getChars(0, len, , offset);
1057
		 = newcount;
1058
		return this;
1059
	}
Inserts the string into this string buffer.

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

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 string buffer.

Parameters:
offset the offset.
str a string.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.StringBuffer.length()
1093
	public AppendingStringBuffer insert(int offset, StringBuffer str)
1095
		if ((offset < 0) || (offset > ))
1100
		if (str == null)
1102
			str = ;
1104
		int len = str.length();
1105
		int newcount =  + len;
1106
		if (newcount > .)
1108
			expandCapacity(newcount);
1110
		System.arraycopy(, offset, , offset + len,  - offset);
1111
		str.getChars(0, len, , offset);
1112
		 = newcount;
1113
		return this;
1114
	}
Inserts the string representation of the char array argument into this string buffer.

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

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

Parameters:
offset the offset.
str a character array.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
1137
	public AppendingStringBuffer insert(int offset, char str[])
1139
		if ((offset < 0) || (offset > ))
1143
		int len = str.length;
1144
		int newcount =  + len;
1145
		if (newcount > .)
1147
			expandCapacity(newcount);
1149
		System.arraycopy(, offset, , offset + len,  - offset);
1150
		System.arraycopy(str, 0, , offset, len);
1151
		 = newcount;
1152
		return this;
1153
	}
Inserts the string representation of the boolean argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
b a boolean.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(boolean)
java.lang.StringBuffer.insert(int,java.lang.String)
java.lang.StringBuffer.length()
1177
	public AppendingStringBuffer insert(int offset, boolean b)
1179
		return insert(offset, String.valueOf(b));
1180
	}
Inserts the string representation of the char argument into this string buffer.

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

The overall effect is exactly as if the argument were converted to a string by the method java.lang.String.valueOf(char) and the character in that string were then inserted into this AppendingStringBuffer object 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 string buffer.

Parameters:
offset the offset.
c a char.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.IndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.StringBuffer.length()
1206
	public AppendingStringBuffer insert(int offset, char c)
1208
		int newcount =  + 1;
1209
		if (newcount > .)
1211
			expandCapacity(newcount);
1213
		System.arraycopy(, offset, , offset + 1,  - offset);
1214
		[offset] = c;
1215
		 = newcount;
1216
		return this;
1217
	}
Inserts the string representation of the second int argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
i an int.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(int)
java.lang.StringBuffer.insert(int,java.lang.String)
java.lang.StringBuffer.length()
1241
	public AppendingStringBuffer insert(int offset, int i)
1243
		return insert(offset, String.valueOf(i));
1244
	}
Inserts the string representation of the long argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
l a long.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(long)
java.lang.StringBuffer.insert(int,java.lang.String)
java.lang.StringBuffer.length()
1268
	public AppendingStringBuffer insert(int offset, long l)
1270
		return insert(offset, String.valueOf(l));
1271
	}
Inserts the string representation of the float argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
f a float.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(float)
java.lang.StringBuffer.insert(int,java.lang.String)
java.lang.StringBuffer.length()
1295
	public AppendingStringBuffer insert(int offset, float f)
1297
		return insert(offset, String.valueOf(f));
1298
	}
Inserts the string representation of the double argument into this string buffer.

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 string buffer 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 string buffer.

Parameters:
offset the offset.
d a double.
Returns:
a reference to this AppendingStringBuffer object.
Throws:
java.lang.StringIndexOutOfBoundsException if the offset is invalid.
See also:
java.lang.String.valueOf(double)
java.lang.StringBuffer.insert(int,java.lang.String)
java.lang.StringBuffer.length()
1322
	public AppendingStringBuffer insert(int offset, double d)
1324
		return insert(offset, String.valueOf(d));
1325
	}
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, <i>k</i>)
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:
java.lang.NullPointerException if str is null.
Since:
1.4
1346
	public int indexOf(String str)
1348
		return indexOf(str, 0);
1349
	}
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:
java.lang.NullPointerException if str is null.
Since:
1.4
1372
	public int indexOf(String str, int fromIndex)
1374
		return indexOf(, 0, , str.toCharArray(), 0, str.length(), fromIndex);
1377
	static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target,
1378
			int targetOffset, int targetCount, int fromIndex)
1380
		if (fromIndex >= sourceCount)
1382
			return (targetCount == 0 ? sourceCount : -1);
1384
		if (fromIndex < 0)
1386
			fromIndex = 0;
1388
		if (targetCount == 0)
1390
			return fromIndex;
1393
		char first = target[targetOffset];
1394
		int i = sourceOffset + fromIndex;
1395
		int max = sourceOffset + (sourceCount - targetCount);
1397
		startSearchForFirstChar : while (true)
1399
			/* Look for first character. */
1400
			while (i <= max && source[i] != first)
1402
				i++;
1404
			if (i > max)
1406
				return -1;
1409
			/* Found first character, now look at the rest of v2 */
1410
			int j = i + 1;
1411
			int end = j + targetCount - 1;
1412
			int k = targetOffset + 1;
1413
			while (j < end)
1415
				if (source[j++] != target[k++])
1417
					i++;
1418
					/* Look for str's first char again. */
1419
					continue startSearchForFirstChar;
1422
			return i - sourceOffset; /* Found whole string. */
1424
	}
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:
java.lang.NullPointerException if str is null.
Since:
1.4
1447
	public int lastIndexOf(String str)
1449
		return lastIndexOf(str, );
1450
	}
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 string of the last occurrence of the specified substring.
Throws:
java.lang.NullPointerException if str is null.
Since:
1.4
1471
	public int lastIndexOf(String str, int fromIndex)
1473
		return lastIndexOf(, 0, , str.toCharArray(), 0, str.length(), fromIndex);
1476
	static int lastIndexOf(char[] source, int sourceOffset, int sourceCount, char[] target,
1477
			int targetOffset, int targetCount, int fromIndex)
1479
		/*
1480
		 * Check arguments; return immediately where possible. For consistency, don't check for null
1481
		 * str.
1482
		 */
1483
		int rightIndex = sourceCount - targetCount;
1484
		if (fromIndex < 0)
1486
			return -1;
1488
		if (fromIndex > rightIndex)
1490
			fromIndex = rightIndex;
1492
		/* Empty string always matches. */
1493
		if (targetCount == 0)
1495
			return fromIndex;
1498
		int strLastIndex = targetOffset + targetCount - 1;
1499
		char strLastChar = target[strLastIndex];
1500
		int min = sourceOffset + targetCount - 1;
1501
		int i = min + fromIndex;
1503
		startSearchForLastChar : while (true)
1505
			while (i >= min && source[i] != strLastChar)
1507
				i--;
1509
			if (i < min)
1511
				return -1;
1513
			int j = i - 1;
1514
			int start = j - (targetCount - 1);
1515
			int k = strLastIndex - 1;
1517
			while (j > start)
1519
				if (source[j--] != target[k--])
1521
					i--;
1522
					continue startSearchForLastChar;
1525
			return start - sourceOffset + 1;
1527
	}
Tests if this AppendingStringBuffer starts with the specified prefix beginning a specified index.

Parameters:
prefix the prefix.
toffset where to begin looking in the string.
Returns:
true if the character sequence represented by the argument is a prefix of the substring of this object starting at index toffset; false otherwise. The result is false if toffset is negative or greater than the length of this String object; otherwise the result is the same as the result of the expression 
 this.subString(toffset).startsWith(prefix)
 
1548
	public boolean startsWith(CharSequence prefix, int toffset)
1550
		char ta[] = ;
1551
		int to = toffset;
1552
		int po = 0;
1553
		int pc = prefix.length();
1554
		// Note: toffset might be near -1>>>1.
1555
		if ((toffset < 0) || (toffset >  - pc))
1557
			return false;
1559
		while (--pc >= 0)
1561
			if (ta[to++] != prefix.charAt(po++))
1563
				return false;
1566
		return true;
1567
	}
Tests if this AppendingStringBuffer starts with the specified prefix.

Parameters:
prefix the prefix.
Returns:
true if the character sequence represented by the argument is a prefix of the character sequence represented by this AppendingStringBuffer; false otherwise. Note also that true will be returned if the argument is an empty string or is equal to this AppendingStringBuffer object as determined by the equals(java.lang.Object) method.
Since:
1. 0
1582
	public boolean startsWith(CharSequence prefix)
1584
		return startsWith(prefix, 0);
1585
	}
Tests if this AppendingStringBuffer ends with the specified suffix.

Parameters:
suffix the suffix.
Returns:
true if the character sequence represented by the argument is a suffix of the character sequence represented by this AppendingStringBuffer; false otherwise. Note that the result will be true if the argument is the empty string or is equal to this AppendingStringBuffer object as determined by the equals(java.lang.Object) method.
1599
	public boolean endsWith(CharSequence suffix)
1601
		return startsWith(suffix,  - suffix.length());
1602
	}
Converts to a string representing the data in this AppendingStringBuffer. A new String object is allocated and initialized to contain the character sequence currently represented by this string buffer. This String is then returned. Subsequent changes to the string buffer do not affect the contents of the String.

Implementation advice: This method can be coded so as to create a new String object without allocating new memory to hold a copy of the character sequence. Instead, the string can share the memory used by the string buffer. Any subsequent operation that alters the content or capacity of the string buffer must then make a copy of the internal buffer at that time. This strategy is effective for reducing the amount of memory allocated by a string concatenation operation when it is implemented using a string buffer.

Returns:
a string representation of the string buffer.
1619
	public String toString()
1621
		return new String(this., 0, );
1622
	}
This method returns the internal char array. So it is not

Returns:
The internal char array
1629
	public final char[] getValue()
1631
		return ;
1632
	}
readObject is called to restore the state of the AppendingStringBuffer from a stream.

Parameters:
s
Throws:
java.lang.ClassNotFoundException
java.io.IOException
1645
		 = (char[]).clone();
1646
	}
Compares this AppendingStringBuffer to the specified object. The result is true if and only if the argument is not null and is a AppendingStringBuffer object or another charsequence object! that represents the same sequence of characters as this object.

Parameters:
anObject the object to compare this AppendingStringBuffer against.
Returns:
true if the AppendingStringBufferare equal; false otherwise.
1659
	public boolean equals(Object anObject)
1661
		if (this == anObject)
1663
			return true;
1665
		if (anObject instanceof AppendingStringBuffer)
1667
			AppendingStringBuffer anotherString = (AppendingStringBuffer)anObject;
1668
			int n = ;
1669
			if (n == anotherString.count)
1671
				char v1[] = ;
1672
				char v2[] = anotherString.value;
1673
				int i = 0;
1674
				while (n-- != 0)
1676
					if (v1[i] != v2[i++])
1678
						return false;
1681
				return true;
1684
		else if (anObject instanceof CharSequence)
1686
			CharSequence sequence = (CharSequence)anObject;
1687
			int n = ;
1688
			if (sequence.length() == )
1690
				char v1[] = ;
1691
				int i = 0;
1692
				while (n-- != 0)
1694
					if (v1[i] != sequence.charAt(i++))
1696
						return false;
1699
				return true;
1702
		return false;
1703
	}
Returns a hash code for this AppendingStringBuffer. The hash code for a AppendingStringBuffer object is computed as 
    s[0]*31ˆ(n-1) + s[1]*31ˆ(n-2) + ... + s[n-1]
using int arithmetic, where s[i] is the ith character of the AppendingStringBuffer, n is the length of the AppendingStringBuffer, and ^ indicates exponentiation. (The hash value of the empty AppendingStringBuffer is zero.)

Returns:
a hash code value for this object.
1720
	public int hashCode()
1722
		int h = 0;
1723
		if (h == 0)
1725
			int off = 0;
1726
			char val[] = ;
1727
			int len = ;
1729
			for (int i = 0; i < len; i++)
1731
				h = 31 * h + val[off++];
1734
		return h;
1735
	}
Clears the buffer contents, but leaves the allocated size intact 
1740
	public void clear()
1742
		 = 0;
New to GrepCode? Check out our FAQ X