History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/lang/StringBuffer.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/lang/StringBuffer.java+605−0
@@ -0,0 +1,605 @@
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;
27+
28+
29+/**
30+ * A thread-safe, mutable sequence of characters.
31+ * A string buffer is like a {@link String}, but can be modified. At any
32+ * point in time it contains some particular sequence of characters, but
33+ * the length and content of the sequence can be changed through certain
34+ * method calls.
35+ * <p>
36+ * String buffers are safe for use by multiple threads. The methods
37+ * are synchronized where necessary so that all the operations on any
38+ * particular instance behave as if they occur in some serial order
39+ * that is consistent with the order of the method calls made by each of
40+ * the individual threads involved.
41+ * <p>
42+ * The principal operations on a <code>StringBuffer</code> are the
43+ * <code>append</code> and <code>insert</code> methods, which are
44+ * overloaded so as to accept data of any type. Each effectively
45+ * converts a given datum to a string and then appends or inserts the
46+ * characters of that string to the string buffer. The
47+ * <code>append</code> method always adds these characters at the end
48+ * of the buffer; the <code>insert</code> method adds the characters at
49+ * a specified point.
50+ * <p>
51+ * For example, if <code>z</code> refers to a string buffer object
52+ * whose current contents are "<code>start</code>", then
53+ * the method call <code>z.append("le")</code> would cause the string
54+ * buffer to contain "<code>startle</code>", whereas
55+ * <code>z.insert(4, "le")</code> would alter the string buffer to
56+ * contain "<code>starlet</code>".
57+ * <p>
58+ * In general, if sb refers to an instance of a <code>StringBuffer</code>,
59+ * then <code>sb.append(x)</code> has the same effect as
60+ * <code>sb.insert(sb.length(),&nbsp;x)</code>.
61+ * <p>
62+ * Whenever an operation occurs involving a source sequence (such as
63+ * appending or inserting from a source sequence) this class synchronizes
64+ * only on the string buffer performing the operation, not on the source.
65+ * <p>
66+ * Every string buffer has a capacity. As long as the length of the
67+ * character sequence contained in the string buffer does not exceed
68+ * the capacity, it is not necessary to allocate a new internal
69+ * buffer array. If the internal buffer overflows, it is
70+ * automatically made larger.
71+ *
72+ * As of release JDK 5, this class has been supplemented with an equivalent
73+ * class designed for use by a single thread, {@link StringBuilder}. The
74+ * <tt>StringBuilder</tt> class should generally be used in preference to
75+ * this one, as it supports all of the same operations but it is faster, as
76+ * it performs no synchronization.
77+ *
78+ * @author Arthur van Hoff
79+ * @see java.lang.StringBuilder
80+ * @see java.lang.String
81+ * @since JDK1.0
82+ */
83+ public final class StringBuffer
84+ extends AbstractStringBuilder
85+ implements java.io.Serializable, CharSequence
86+{
87+
88+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
89+ static final long serialVersionUID = 3388685877147921107L;
90+
91+ /**
92+ * Constructs a string buffer with no characters in it and an
93+ * initial capacity of 16 characters.
94+ */
95+ public StringBuffer() {
96+ super(16);
97+ }
98+
99+ /**
100+ * Constructs a string buffer with no characters in it and
101+ * the specified initial capacity.
102+ *
103+ * @param capacity the initial capacity.
104+ * @exception NegativeArraySizeException if the <code>capacity</code>
105+ * argument is less than <code>0</code>.
106+ */
107+ public StringBuffer(int capacity) {
108+ super(capacity);
109+ }
110+
111+ /**
112+ * Constructs a string buffer initialized to the contents of the
113+ * specified string. The initial capacity of the string buffer is
114+ * <code>16</code> plus the length of the string argument.
115+ *
116+ * @param str the initial contents of the buffer.
117+ * @exception NullPointerException if <code>str</code> is <code>null</code>
118+ */
119+ public StringBuffer(String str) {
120+ super(str.length() + 16);
121+ append(str);
122+ }
123+
124+ /**
125+ * Constructs a string buffer that contains the same characters
126+ * as the specified <code>CharSequence</code>. The initial capacity of
127+ * the string buffer is <code>16</code> plus the length of the
128+ * <code>CharSequence</code> argument.
129+ * <p>
130+ * If the length of the specified <code>CharSequence</code> is
131+ * less than or equal to zero, then an empty buffer of capacity
132+ * <code>16</code> is returned.
133+ *
134+ * @param seq the sequence to copy.
135+ * @exception NullPointerException if <code>seq</code> is <code>null</code>
136+ * @since 1.5
137+ */
138+ public StringBuffer(CharSequence seq) {
139+ this(seq.length() + 16);
140+ append(seq);
141+ }
142+
143+ public synchronized int length() {
144+ return count;
145+ }
146+
147+ public synchronized int capacity() {
148+ return value.length;
149+ }
150+
151+
152+ public synchronized void ensureCapacity(int minimumCapacity) {
153+ if (minimumCapacity > value.length) {
154+ expandCapacity(minimumCapacity);
155+ }
156+ }
157+
158+ /**
159+ * @since 1.5
160+ */
161+ public synchronized void trimToSize() {
162+ super.trimToSize();
163+ }
164+
165+ /**
166+ * @throws IndexOutOfBoundsException {@inheritDoc}
167+ * @see #length()
168+ */
169+ public synchronized void setLength(int newLength) {
170+ super.setLength(newLength);
171+ }
172+
173+ /**
174+ * @throws IndexOutOfBoundsException {@inheritDoc}
175+ * @see #length()
176+ */
177+ public synchronized char charAt(int index) {
178+ if ((index < 0) || (index >= count))
179+ throw new StringIndexOutOfBoundsException(index);
180+ return value[index];
181+ }
182+
183+ /**
184+ * @since 1.5
185+ */
186+ public synchronized int codePointAt(int index) {
187+ return super.codePointAt(index);
188+ }
189+
190+ /**
191+ * @since 1.5
192+ */
193+ public synchronized int codePointBefore(int index) {
194+ return super.codePointBefore(index);
195+ }
196+
197+ /**
198+ * @since 1.5
199+ */
200+ public synchronized int codePointCount(int beginIndex, int endIndex) {
201+ return super.codePointCount(beginIndex, endIndex);
202+ }
203+
204+ /**
205+ * @since 1.5
206+ */
207+ public synchronized int offsetByCodePoints(int index, int codePointOffset) {
208+ return super.offsetByCodePoints(index, codePointOffset);
209+ }
210+
211+ /**
212+ * @throws NullPointerException {@inheritDoc}
213+ * @throws IndexOutOfBoundsException {@inheritDoc}
214+ */
215+ public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
216+ int dstBegin)
217+ {
218+ super.getChars(srcBegin, srcEnd, dst, dstBegin);
219+ }
220+
221+ /**
222+ * @throws IndexOutOfBoundsException {@inheritDoc}
223+ * @see #length()
224+ */
225+ public synchronized void setCharAt(int index, char ch) {
226+ if ((index < 0) || (index >= count))
227+ throw new StringIndexOutOfBoundsException(index);
228+ value[index] = ch;
229+ }
230+
231+ public synchronized StringBuffer append(Object obj) {
232+ super.append(String.valueOf(obj));
233+ return this;
234+ }
235+
236+ public synchronized StringBuffer append(String str) {
237+ super.append(str);
238+ return this;
239+ }
240+
241+ /**
242+ * Appends the specified <tt>StringBuffer</tt> to this sequence.
243+ * <p>
244+ * The characters of the <tt>StringBuffer</tt> argument are appended,
245+ * in order, to the contents of this <tt>StringBuffer</tt>, increasing the
246+ * length of this <tt>StringBuffer</tt> by the length of the argument.
247+ * If <tt>sb</tt> is <tt>null</tt>, then the four characters
248+ * <tt>"null"</tt> are appended to this <tt>StringBuffer</tt>.
249+ * <p>
250+ * Let <i>n</i> be the length of the old character sequence, the one
251+ * contained in the <tt>StringBuffer</tt> just prior to execution of the
252+ * <tt>append</tt> method. Then the character at index <i>k</i> in
253+ * the new character sequence is equal to the character at index <i>k</i>
254+ * in the old character sequence, if <i>k</i> is less than <i>n</i>;
255+ * otherwise, it is equal to the character at index <i>k-n</i> in the
256+ * argument <code>sb</code>.
257+ * <p>
258+ * This method synchronizes on <code>this</code> (the destination)
259+ * object but does not synchronize on the source (<code>sb</code>).
260+ *
261+ * @param sb the <tt>StringBuffer</tt> to append.
262+ * @return a reference to this object.
263+ * @since 1.4
264+ */
265+ public synchronized StringBuffer append(StringBuffer sb) {
266+ super.append(sb);
267+ return this;
268+ }
269+
270+
271+ /**
272+ * Appends the specified <code>CharSequence</code> to this
273+ * sequence.
274+ * <p>
275+ * The characters of the <code>CharSequence</code> argument are appended,
276+ * in order, increasing the length of this sequence by the length of the
277+ * argument.
278+ *
279+ * <p>The result of this method is exactly the same as if it were an
280+ * invocation of this.append(s, 0, s.length());
281+ *
282+ * <p>This method synchronizes on this (the destination)
283+ * object but does not synchronize on the source (<code>s</code>).
284+ *
285+ * <p>If <code>s</code> is <code>null</code>, then the four characters
286+ * <code>"null"</code> are appended.
287+ *
288+ * @param s the <code>CharSequence</code> to append.
289+ * @return a reference to this object.
290+ * @since 1.5
291+ */
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+ }
302+
303+ /**
304+ * @throws IndexOutOfBoundsException {@inheritDoc}
305+ * @since 1.5
306+ */
307+ public synchronized StringBuffer append(CharSequence s, int start, int end)
308+ {
309+ super.append(s, start, end);
310+ return this;
311+ }
312+
313+ public synchronized StringBuffer append(char[] str) {
314+ super.append(str);
315+ return this;
316+ }
317+
318+ /**
319+ * @throws IndexOutOfBoundsException {@inheritDoc}
320+ */
321+ public synchronized StringBuffer append(char[] str, int offset, int len) {
322+ super.append(str, offset, len);
323+ return this;
324+ }
325+
326+ public synchronized StringBuffer append(boolean b) {
327+ super.append(b);
328+ return this;
329+ }
330+
331+ public synchronized StringBuffer append(char c) {
332+ super.append(c);
333+ return this;
334+ }
335+
336+ public synchronized StringBuffer append(int i) {
337+ super.append(i);
338+ return this;
339+ }
340+
341+ /**
342+ * @since 1.5
343+ */
344+ public synchronized StringBuffer appendCodePoint(int codePoint) {
345+ super.appendCodePoint(codePoint);
346+ return this;
347+ }
348+
349+ public synchronized StringBuffer append(long lng) {
350+ super.append(lng);
351+ return this;
352+ }
353+
354+ public synchronized StringBuffer append(float f) {
355+ super.append(f);
356+ return this;
357+ }
358+
359+ public synchronized StringBuffer append(double d) {
360+ super.append(d);
361+ return this;
362+ }
363+
364+ /**
365+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
366+ * @since 1.2
367+ */
368+ public synchronized StringBuffer delete(int start, int end) {
369+ super.delete(start, end);
370+ return this;
371+ }
372+
373+ /**
374+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
375+ * @since 1.2
376+ */
377+ public synchronized StringBuffer deleteCharAt(int index) {
378+ super.deleteCharAt(index);
379+ return this;
380+ }
381+
382+ /**
383+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
384+ * @since 1.2
385+ */
386+ public synchronized StringBuffer replace(int start, int end, String str) {
387+ super.replace(start, end, str);
388+ return this;
389+ }
390+
391+ /**
392+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
393+ * @since 1.2
394+ */
395+ public synchronized String substring(int start) {
396+ return substring(start, count);
397+ }
398+
399+ /**
400+ * @throws IndexOutOfBoundsException {@inheritDoc}
401+ * @since 1.4
402+ */
403+ public synchronized CharSequence subSequence(int start, int end) {
404+ return super.substring(start, end);
405+ }
406+
407+ /**
408+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
409+ * @since 1.2
410+ */
411+ public synchronized String substring(int start, int end) {
412+ return super.substring(start, end);
413+ }
414+
415+ /**
416+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
417+ * @since 1.2
418+ */
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+ }
425+
426+ /**
427+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
428+ */
429+ public synchronized StringBuffer insert(int offset, Object obj) {
430+ super.insert(offset, String.valueOf(obj));
431+ return this;
432+ }
433+
434+ /**
435+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
436+ */
437+ public synchronized StringBuffer insert(int offset, String str) {
438+ super.insert(offset, str);
439+ return this;
440+ }
441+
442+ /**
443+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
444+ */
445+ public synchronized StringBuffer insert(int offset, char[] str) {
446+ super.insert(offset, str);
447+ return this;
448+ }
449+
450+ /**
451+ * @throws IndexOutOfBoundsException {@inheritDoc}
452+ * @since 1.5
453+ */
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+ }
462+
463+ /**
464+ * @throws IndexOutOfBoundsException {@inheritDoc}
465+ * @since 1.5
466+ */
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+ }
473+
474+ /**
475+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
476+ */
477+ public StringBuffer insert(int offset, boolean b) {
478+ return insert(offset, String.valueOf(b));
479+ }
480+
481+ /**
482+ * @throws IndexOutOfBoundsException {@inheritDoc}
483+ */
484+ public synchronized StringBuffer insert(int offset, char c) {
485+ super.insert(offset, c);
486+ return this;
487+ }
488+
489+ /**
490+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
491+ */
492+ public StringBuffer insert(int offset, int i) {
493+ return insert(offset, String.valueOf(i));
494+ }
495+
496+ /**
497+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
498+ */
499+ public StringBuffer insert(int offset, long l) {
500+ return insert(offset, String.valueOf(l));
501+ }
502+
503+ /**
504+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
505+ */
506+ public StringBuffer insert(int offset, float f) {
507+ return insert(offset, String.valueOf(f));
508+ }
509+
510+ /**
511+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
512+ */
513+ public StringBuffer insert(int offset, double d) {
514+ return insert(offset, String.valueOf(d));
515+ }
516+
517+ /**
518+ * @throws NullPointerException {@inheritDoc}
519+ * @since 1.4
520+ */
521+ public int indexOf(String str) {
522+ return indexOf(str, 0);
523+ }
524+
525+ /**
526+ * @throws NullPointerException {@inheritDoc}
527+ * @since 1.4
528+ */
529+ public synchronized int indexOf(String str, int fromIndex) {
530+ return String.indexOf(value, 0, count,
531+ str.toCharArray(), 0, str.length(), fromIndex);
532+ }
533+
534+ /**
535+ * @throws NullPointerException {@inheritDoc}
536+ * @since 1.4
537+ */
538+ public int lastIndexOf(String str) {
539+ // Note, synchronization achieved via other invocations
540+ return lastIndexOf(str, count);
541+ }
542+
543+ /**
544+ * @throws NullPointerException {@inheritDoc}
545+ * @since 1.4
546+ */
547+ public synchronized int lastIndexOf(String str, int fromIndex) {
548+ return String.lastIndexOf(value, 0, count,
549+ str.toCharArray(), 0, str.length(), fromIndex);
550+ }
551+
552+ /**
553+ * @since JDK1.0.2
554+ */
555+ public synchronized StringBuffer reverse() {
556+ super.reverse();
557+ return this;
558+ }
559+
560+ public synchronized String toString() {
561+ return new String(value, 0, count);
562+ }
563+
564+ /**
565+ * Serializable fields for StringBuffer.
566+ *
567+ * @serialField value char[]
568+ * The backing character array of this StringBuffer.
569+ * @serialField count int
570+ * The number of characters in this StringBuffer.
571+ * @serialField shared boolean
572+ * A flag indicating whether the backing array is shared.
573+ * The value is ignored upon deserialization.
574+ */
575+ private static final java.io.ObjectStreamField[] serialPersistentFields =
576+ {
577+ new java.io.ObjectStreamField("value", char[].class),
578+ new java.io.ObjectStreamField("count", Integer.TYPE),
579+ new java.io.ObjectStreamField("shared", Boolean.TYPE),
580+ };
581+
582+ /**
583+ * readObject is called to restore the state of the StringBuffer from
584+ * a stream.
585+ */
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", value);
590+ fields.put("count", count);
591+ fields.put("shared", false);
592+ s.writeFields();
593+ }
594+
595+ /**
596+ * readObject is called to restore the state of the StringBuffer from
597+ * a stream.
598+ */
599+ private void readObject(java.io.ObjectInputStream s)
600+ throws java.io.IOException, ClassNotFoundException {
601+ java.io.ObjectInputStream.GetField fields = s.readFields();
602+ value = (char[])fields.get("value", null);
603+ count = fields.get("count", 0);
604+ }
605+}