StringBuffer 源代码
StringBuffer.java
001 /**
002 * @(#)StringBuffer.java 1.101 05/11/17
003 *
004 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
005 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
006 */
007
008 package java.lang;
059 *
060 * @author Arthur van Hoff
061 * @version 1.101, 11/17/05
062 * @see java.lang.StringBuilder
063 * @see java.lang.String
064 * @since JDK1.0
065 */
066 public final class StringBuffer
067 extends AbstractStringBuilder
068 implements java.io.Serializable, CharSequence
069 {
070
071 /*** use serialVersionUID from JDK 1.0.2 for interoperability */
072 static final long serialVersionUID = 3388685877147921107L;
073
078 public StringBuffer() {
079 super(16);
080 }
081
090 public StringBuffer(int capacity) {
091 super(capacity);
092 }
093
102 public StringBuffer(String str) {
103 super(str.length() + 16);
104 append(str);
105 }
106
121 public StringBuffer(CharSequence seq) {
122 this(seq.length() + 16);
123 append(seq);
124 }
125
126 public synchronized int length() {
127 return count;
128 }
129
130 public synchronized int capacity() {
131 return value.length;
132 }
133
134
135 public synchronized void ensureCapacity(int minimumCapacity) {
136 if (minimumCapacity > value.length) {
137 expandCapacity(minimumCapacity);
138 }
139 }
140
144 public synchronized void trimToSize() {
145 super.trimToSize();
146 }
147
152 public synchronized void setLength(int newLength) {
153 super.setLength(newLength);
154 }
155
160 public synchronized char charAt(int index) {
161 if ((index < 0) || (index >= count))
162 throw new StringIndexOutOfBoundsException(index);
163 return value[index];
164 }
165
169 public synchronized int codePointAt(int index) {
170 return super.codePointAt(index);
171 }
172
176 public synchronized int codePointBefore(int index) {
177 return super.codePointBefore(index);
178 }
179
183 public synchronized int codePointCount(int beginIndex, int endIndex) {
184 return super.codePointCount(beginIndex, endIndex);
185 }
186
190 public synchronized int offsetByCodePoints(int index, int codePointOffset) {
191 return super.offsetByCodePoints(index, codePointOffset);
192 }
193
198 public synchronized void getChars(int srcBegin, int srcEnd, char dst[],
199 int dstBegin)
200 {
201 super.getChars(srcBegin, srcEnd, dst, dstBegin);
202 }
203
208 public synchronized void setCharAt(int index, char ch) {
209 if ((index < 0) || (index >= count))
210 throw new StringIndexOutOfBoundsException(index);
211 value[index] = ch;
212 }
213
218 public synchronized StringBuffer append(Object obj) {
219 super.append(String.valueOf(obj));
220 return this;
221 }
222
223 public synchronized StringBuffer append(String str) {
224 super.append(str);
225 return this;
226 }
227
252 public synchronized StringBuffer append(StringBuffer sb) {
253 super.append(sb);
254 return this;
255 }
279 public StringBuffer append(CharSequence s) {
280 // Note, synchronization achieved via other invocations
281 if (s == null)
282 s = "null";
283 if (s instanceof String)
284 return this.append((String)s);
285 if (s instanceof StringBuffer)
286 return this.append((StringBuffer)s);
287 return this.append(s, 0, s.length());
288 }
289
294 public synchronized StringBuffer append(CharSequence s, int start, int end)
295 {
296 super.append(s, start, end);
297 return this;
298 }
299
300 public synchronized StringBuffer append(char str[]) {
301 super.append(str);
302 return this;
303 }
304
305 public synchronized StringBuffer append(char str[], int offset, int len) {
306 super.append(str, offset, len);
307 return this;
308 }
309
314 public synchronized StringBuffer append(boolean b) {
315 super.append(b);
316 return this;
317 }
318
319 public synchronized StringBuffer append(char c) {
320 super.append(c);
321 return this;
322 }
328 public synchronized StringBuffer append(int i) {
329 super.append(i);
330 return this;
331 }
332
336 public synchronized StringBuffer appendCodePoint(int codePoint) {
337 super.appendCodePoint(codePoint);
338 return this;
339 }
340
345 public synchronized StringBuffer append(long lng) {
346 super.append(lng);
347 return this;
348 }
349
354 public synchronized StringBuffer append(float f) {
355 super.append(f);
356 return this;
357 }
358
363 public synchronized StringBuffer append(double d) {
364 super.append(d);
365 return this;
366 }
367
372 public synchronized StringBuffer delete(int start, int end) {
373 super.delete(start, end);
374 return this;
375 }
376
381 public synchronized StringBuffer deleteCharAt(int index) {
382 super.deleteCharAt(index);
383 return this;
384 }
385
390 public synchronized StringBuffer replace(int start, int end, String str) {
391 super.replace(start, end, str);
392 return this;
393 }
394
399 public synchronized String substring(int start) {
400 return substring(start, count);
401 }
402
407 public synchronized CharSequence subSequence(int start, int end) {
408 return super.substring(start, end);
409 }
410
415 public synchronized String substring(int start, int end) {
416 return super.substring(start, end);
417 }
418
423 public synchronized StringBuffer insert(int index, char str[], int offset,
424 int len)
425 {
426 super.insert(index, str, offset, len);
427 return this;
428 }
429
436 public synchronized StringBuffer insert(int offset, Object obj) {
437 super.insert(offset, String.valueOf(obj));
438 return this;
439 }
440
445 public synchronized StringBuffer insert(int offset, String str) {
446 super.insert(offset, str);
447 return this;
448 }
449
453 public synchronized StringBuffer insert(int offset, char str[]) {
454 super.insert(offset, str);
455 return this;
456 }
457
462 public StringBuffer insert(int dstOffset, CharSequence s) {
463 // Note, synchronization achieved via other invocations
464 if (s == null)
465 s = "null";
466 if (s instanceof String)
467 return this.insert(dstOffset, (String)s);
468 return this.insert(dstOffset, s, 0, s.length());
469 }
470
475 public synchronized StringBuffer insert(int dstOffset, CharSequence s,
476 int start, int end)
477 {
478 super.insert(dstOffset, s, start, end);
479 return this;
480 }
481
488 public StringBuffer insert(int offset, boolean b) {
489 return insert(offset, String.valueOf(b));
490 }
491
496 public synchronized StringBuffer insert(int offset, char c) {
497 super.insert(offset, c);
498 return this;
499 }
500
507 public StringBuffer insert(int offset, int i) {
508 return insert(offset, String.valueOf(i));
509 }
510
517 public StringBuffer insert(int offset, long l) {
518 return insert(offset, String.valueOf(l));
519 }
520
527 public StringBuffer insert(int offset, float f) {
528 return insert(offset, String.valueOf(f));
529 }
530
537 public StringBuffer insert(int offset, double d) {
538 return insert(offset, String.valueOf(d));
539 }
540
545 public int indexOf(String str) {
546 return indexOf(str, 0);
547 }
548
553 public synchronized int indexOf(String str, int fromIndex) {
554 return String.indexOf(value, 0, count,
555 str.toCharArray(), 0, str.length(), fromIndex);
556 }
557
562 public int lastIndexOf(String str) {
563 // Note, synchronization achieved via other invocations
564 return lastIndexOf(str, count);
565 }
566
571 public synchronized int lastIndexOf(String str, int fromIndex) {
572 return String.lastIndexOf(value, 0, count,
573 str.toCharArray(), 0, str.length(), fromIndex);
574 }
575
579 public synchronized StringBuffer reverse() {
580 super.reverse();
581 return this;
582 }
583
584 public synchronized String toString() {
585 return new String(value, 0, count);
586 }
587
599 private static final java.io.ObjectStreamField[] serialPersistentFields =
600 {
601 new java.io.ObjectStreamField("value", char[].class),
602 new java.io.ObjectStreamField("count", Integer.TYPE),
603 new java.io.ObjectStreamField("shared", Boolean.TYPE),
604 };
605
610 private synchronized void writeObject(java.io.ObjectOutputStream s)
611 throws java.io.IOException {
612 java.io.ObjectOutputStream.PutField fields = s.putFields();
613 fields.put("value", value);
614 fields.put("count", count);
615 fields.put("shared", false);
616 s.writeFields();
617 }
618
623 private void readObject(java.io.ObjectInputStream s)
624 throws java.io.IOException, ClassNotFoundException {
625 java.io.ObjectInputStream.GetField fields = s.readFields();
626 value = (char[])fields.get("value", null);
627 count = (int)fields.get("count", 0);
628 }
629 }