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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright (c) 1994, 2008, Oracle and/or its affiliates. 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.  Oracle designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
  * or visit www.oracle.com if you need additional information or have any
23
  * questions.
24
  */
25
 
26
 package java.lang;


A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified. 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.

String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.

The principal operations on a StringBuffer are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string buffer. The append method always adds these characters at the end of the buffer; the insert method adds the characters at a specified point.

For example, if z refers to a string buffer object whose current contents are "start", then the method call z.append("le") would cause the string buffer to contain "startle", whereas z.insert(4, "le") would alter the string buffer to contain "starlet".

In general, if sb refers to an instance of a StringBuffer, then sb.append(x) has the same effect as sb.insert(sb.length(), x).

Whenever an operation occurs involving a source sequence (such as appending or inserting from a source sequence) this class synchronizes only on the string buffer performing the operation, not on the source.

Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger. As of release JDK 5, this class has been supplemented with an equivalent class designed for use by a single thread, StringBuilder. The StringBuilder class should generally be used in preference to this one, as it supports all of the same operations but it is faster, as it performs no synchronization.

Author(s):
Arthur van Hoff
Since:
JDK1.0
See also:
StringBuilder
String
82
 
83
  public final class StringBuffer
84
     extends AbstractStringBuilder
85
     implements java.io.Serializable, CharSequence
86
 {

    
use serialVersionUID from JDK 1.0.2 for interoperability
88
 
89
     static final long serialVersionUID = 3388685877147921107L;

    
Constructs a string buffer with no characters in it and an initial capacity of 16 characters. 
94
 
95
     public StringBuffer() {
96
         super(16);
97
     }

    
Constructs a string buffer with no characters in it and the specified initial capacity.

Parameters:
capacity the initial capacity.
Throws:
NegativeArraySizeException if the capacity argument is less than 0.
107
    public StringBuffer(int capacity) {
108
        super(capacity);
109
    }

    
Constructs a string buffer initialized to the contents of the specified 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:
NullPointerException if str is null
119
    public StringBuffer(String str) {
120
        super(str.length() + 16);
121
        append(str);
122
    }

    
Constructs a string buffer that contains the same characters as the specified CharSequence. The initial capacity of the string buffer is 16 plus the length of the CharSequence argument.

If the length of the specified CharSequence is less than or equal to zero, then an empty buffer of capacity 16 is returned.

Parameters:
seq the sequence to copy.
Throws:
NullPointerException if seq is null
Since:
1.5
138
    public StringBuffer(CharSequence seq) {
139
        this(seq.length() + 16);
140
        append(seq);
141
    }
143
    public synchronized int length() {
144
        return ;
145
    }
147
    public synchronized int capacity() {
148
        return .;
149
    }
152
    public synchronized void ensureCapacity(int minimumCapacity) {
153
        if (minimumCapacity > .) {
154
            expandCapacity(minimumCapacity);
155
        }
156
    }

    

Since:
1.5
161
    public synchronized void trimToSize() {
162
        super.trimToSize();
163
    }

    

Throws:
IndexOutOfBoundsException
See also:
length()
169
    public synchronized void setLength(int newLength) {
170
        super.setLength(newLength);
171
    }

    

Throws:
IndexOutOfBoundsException
See also:
length()
177
    public synchronized char charAt(int index) {
178
        if ((index < 0) || (index >= ))
179
            throw new StringIndexOutOfBoundsException(index);
180
        return [index];
181
    }

    

Since:
1.5
186
    public synchronized int codePointAt(int index) {
187
        return super.codePointAt(index);
188
    }

    

Since:
1.5
193
    public synchronized int codePointBefore(int index) {
194
        return super.codePointBefore(index);
195
    }

    

Since:
1.5
200
    public synchronized int codePointCount(int beginIndex, int endIndex) {
201
        return super.codePointCount(beginIndex, endIndex);
202
    }

    

Since:
1.5
207
    public synchronized int offsetByCodePoints(int index, int codePointOffset) {
208
        return super.offsetByCodePoints(index, codePointOffset);
209
    }

    

Throws:
NullPointerException
IndexOutOfBoundsException
215
    public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
216
                                      int dstBegin)
217
    {
218
        super.getChars(srcBegin, srcEnd, dst, dstBegin);
219
    }

    

Throws:
IndexOutOfBoundsException
See also:
length()
225
    public synchronized void setCharAt(int index, char ch) {
226
        if ((index < 0) || (index >= ))
227
            throw new StringIndexOutOfBoundsException(index);
228
        [index] = ch;
229
    }
231
    public synchronized StringBuffer append(Object obj) {
232
        super.append(String.valueOf(obj));
233
        return this;
234
    }
236
    public synchronized StringBuffer append(String str) {
237
        super.append(str);
238
        return this;
239
    }

    
Appends the specified StringBuffer to this sequence.

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

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

This method synchronizes on this (the destination) object but does not synchronize on the source (sb).

Parameters:
sb the StringBuffer to append.
Returns:
a reference to this object.
Since:
1.4
265
    public synchronized StringBuffer append(StringBuffer sb) {
266
        super.append(sb);
267
        return this;
268
    }


    
Appends the specified CharSequence to this sequence.

The characters of the CharSequence argument are appended, in order, increasing the length of this sequence by the length of the argument.

The result of this method is exactly the same as if it were an invocation of this.append(s, 0, s.length());

This method synchronizes on this (the destination) object but does not synchronize on the source (s).

If s is null, then the four characters "null" are appended.

Parameters:
s the CharSequence to append.
Returns:
a reference to this object.
Since:
1.5
292
    public StringBuffer append(CharSequence s) {
293
        // Note, synchronization achieved via other invocations
294
        if (s == null)
295
            s = "null";
296
        if (s instanceof String)
297
            return this.append((String)s);
298
        if (s instanceof StringBuffer)
299
            return this.append((StringBuffer)s);
300
        return this.append(s, 0, s.length());
301
    }

    

Throws:
IndexOutOfBoundsException
Since:
1.5
307
    public synchronized StringBuffer append(CharSequence s, int start, int end)
308
    {
309
        super.append(s, start, end);
310
        return this;
311
    }
313
    public synchronized StringBuffer append(char[] str) {
314
        super.append(str);
315
        return this;
316
    }

    

Throws:
IndexOutOfBoundsException
321
    public synchronized StringBuffer append(char[] str, int offset, int len) {
322
        super.append(str, offset, len);
323
        return this;
324
    }
326
    public synchronized StringBuffer append(boolean b) {
327
        super.append(b);
328
        return this;
329
    }
331
    public synchronized StringBuffer append(char c) {
332
        super.append(c);
333
        return this;
334
    }
336
    public synchronized StringBuffer append(int i) {
337
        super.append(i);
338
        return this;
339
    }

    

Since:
1.5
344
    public synchronized StringBuffer appendCodePoint(int codePoint) {
345
        super.appendCodePoint(codePoint);
346
        return this;
347
    }
349
    public synchronized StringBuffer append(long lng) {
350
        super.append(lng);
351
        return this;
352
    }
354
    public synchronized StringBuffer append(float f) {
355
        super.append(f);
356
        return this;
357
    }
359
    public synchronized StringBuffer append(double d) {
360
        super.append(d);
361
        return this;
362
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
368
    public synchronized StringBuffer delete(int start, int end) {
369
        super.delete(start, end);
370
        return this;
371
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
377
    public synchronized StringBuffer deleteCharAt(int index) {
378
        super.deleteCharAt(index);
379
        return this;
380
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
386
    public synchronized StringBuffer replace(int start, int end, String str) {
387
        super.replace(start, end, str);
388
        return this;
389
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
395
    public synchronized String substring(int start) {
396
        return substring(start, );
397
    }

    

Throws:
IndexOutOfBoundsException
Since:
1.4
403
    public synchronized CharSequence subSequence(int start, int end) {
404
        return super.substring(start, end);
405
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
411
    public synchronized String substring(int start, int end) {
412
        return super.substring(start, end);
413
    }

    

Throws:
StringIndexOutOfBoundsException
Since:
1.2
419
    public synchronized StringBuffer insert(int index, char[] str, int offset,
420
                                            int len)
421
    {
422
        super.insert(index, str, offset, len);
423
        return this;
424
    }

    

Throws:
StringIndexOutOfBoundsException
429
    public synchronized StringBuffer insert(int offset, Object obj) {
430
        super.insert(offset, String.valueOf(obj));
431
        return this;
432
    }

    

Throws:
StringIndexOutOfBoundsException
437
    public synchronized StringBuffer insert(int offset, String str) {
438
        super.insert(offset, str);
439
        return this;
440
    }

    

Throws:
StringIndexOutOfBoundsException
445
    public synchronized StringBuffer insert(int offset, char[] str) {
446
        super.insert(offset, str);
447
        return this;
448
    }

    

Throws:
IndexOutOfBoundsException
Since:
1.5
454
    public StringBuffer insert(int dstOffset, CharSequence s) {
455
        // Note, synchronization achieved via other invocations
456
        if (s == null)
457
            s = "null";
458
        if (s instanceof String)
459
            return this.insert(dstOffset, (String)s);
460
        return this.insert(dstOffset, s, 0, s.length());
461
    }

    

Throws:
IndexOutOfBoundsException
Since:
1.5
467
    public synchronized StringBuffer insert(int dstOffset, CharSequence s,
468
                                            int start, int end)
469
    {
470
        super.insert(dstOffset, s, start, end);
471
        return this;
472
    }

    

Throws:
StringIndexOutOfBoundsException
477
    public StringBuffer insert(int offset, boolean b) {
478
        return insert(offset, String.valueOf(b));
479
    }

    

Throws:
IndexOutOfBoundsException
484
    public synchronized StringBuffer insert(int offset, char c) {
485
        super.insert(offset, c);
486
        return this;
487
    }

    

Throws:
StringIndexOutOfBoundsException
492
    public StringBuffer insert(int offset, int i) {
493
        return insert(offset, String.valueOf(i));
494
    }

    

Throws:
StringIndexOutOfBoundsException
499
    public StringBuffer insert(int offset, long l) {
500
        return insert(offset, String.valueOf(l));
501
    }

    

Throws:
StringIndexOutOfBoundsException
506
    public StringBuffer insert(int offset, float f) {
507
        return insert(offset, String.valueOf(f));
508
    }

    

Throws:
StringIndexOutOfBoundsException
513
    public StringBuffer insert(int offset, double d) {
514
        return insert(offset, String.valueOf(d));
515
    }

    

Throws:
NullPointerException
Since:
1.4
521
    public int indexOf(String str) {
522
        return indexOf(str, 0);
523
    }

    

Throws:
NullPointerException
Since:
1.4
529
    public synchronized int indexOf(String str, int fromIndex) {
530
        return String.indexOf(, 0, ,
531
                              str.toCharArray(), 0, str.length(), fromIndex);
532
    }

    

Throws:
NullPointerException
Since:
1.4
538
    public int lastIndexOf(String str) {
539
        // Note, synchronization achieved via other invocations
540
        return lastIndexOf(str, );
541
    }

    

Throws:
NullPointerException
Since:
1.4
547
    public synchronized int lastIndexOf(String str, int fromIndex) {
548
        return String.lastIndexOf(, 0, ,
549
                              str.toCharArray(), 0, str.length(), fromIndex);
550
    }

    

Since:
JDK1.0.2
555
    public synchronized StringBuffer reverse() {
556
        super.reverse();
557
        return this;
558
    }
560
    public synchronized String toString() {
561
        return new String(, 0, );
562
    }

    
Serializable fields for StringBuffer.

SerialField:
value char[] The backing character array of this StringBuffer.
SerialField:
count int The number of characters in this StringBuffer.
SerialField:
shared boolean A flag indicating whether the backing array is shared. The value is ignored upon deserialization.
575
    private static final java.io.ObjectStreamField[] serialPersistentFields =
576
    {
577
        new java.io.ObjectStreamField("value", char[].class),
578
        new java.io.ObjectStreamField("count", .),
579
        new java.io.ObjectStreamField("shared", .),
580
    };

    
readObject is called to restore the state of the StringBuffer from a stream. 
586
    private synchronized void writeObject(java.io.ObjectOutputStream s)
587
        throws java.io.IOException {
588
        java.io.ObjectOutputStream.PutField fields = s.putFields();
589
        fields.put("value", );
590
        fields.put("count", );
591
        fields.put("shared", false);
592
        s.writeFields();
593
    }

    
readObject is called to restore the state of the StringBuffer from a stream. 
599
    private void readObject(java.io.ObjectInputStream s)
600
        throws java.io.IOException, ClassNotFoundException {
601
        java.io.ObjectInputStream.GetField fields = s.readFields();
602
         = (char[])fields.get("value", null);
603
         = fields.get("count", 0);
604
    }
New to GrepCode? Check out our FAQ X