Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. StringBuilder and StringBuffer in Java
What is the main difference between StringBuffer and StringBuilder? Is there any performance issues when deciding on any one of these?
3. String, StringBuffer, and StringBuilder
Please tell me a real time situation to compare String, StringBuffer, and StringBuilder?
4. What's the best way to build a string of delimited items in Java?
While working in a Java app, I recently was needing to assemble a comma-delimited list of values to pass to another web service without knowing how many elements there would be in advance. The best I could come up with off the top of my head was something like this: public String appendWithDelimiter( String original, String addition, String delimiter ) { if ( original.equals( "" ) ) { retur...
5. How to clear/empty Java Stringbuilder
I'm using a StringBuilder in a loop and every x iterations I want to empty it and start with an empty StringBuilder, but I can't see any method similar to the .Net StringBuilder.Clear in the docs, just the delete method which seems overly complicated. So what is the best way to clean out a StringBuilder in Java?
6. Is it always a bad idea to use + to concatenate strings
I have code as follows : String s = ""; for (My my : myList) { s += my.getX(); } Findbugs always reports error when I do this.
7. C# or Java: Prepend strings with StringBuilder?
I know we can append strings using StringBuilder. Is there a way we can prepend strings (ie: Add strings infront of a string) using StringBuilder so we can keep the performance benefits that StringBuilder offers?
8. Abstract Factory, Factory Method, Builder
It may seem as if this is question is a dupe, but please bear with me - I promise I've read the related posts (and the GOF book). After everything I've read, I still don't have it clear when to use an Abstract Factory, a Factory Method, or a Builder. I believe it will finally sink in after I see a simple example of a problem which is best approached by, say, a builder and it would be clearly ...
9. Java performance tips
I have a program I ported from C to Java. Both apps use quicksort to order some partitioned data (genomic coordinates). The Java version runs fast, but I'd like to get it closer to the C version. I am using the Sun JDK v6u14. Obviously I can't get parity with the C application, but I'd like to learn what I can do to eke out as much performance as reasonably possible (within the limits of the...
10. How do I parse JSON from a Java HTTPResponse?
I have an HttpResponse object for a web request I just made. The response is in the JSON format, so I need to parse it. I can do it in an absurdly complex way, but it seems like there must be a better way. Is this really the best I can do? HttpResponse response; // some response object Reader in = new BufferedReader( new InputStreamReader(response.getEntity().getContent(), "U...
11. Can I multiply strings in java to repeat sequences?
I have something like the following: int i = 3; String someNum = "123"; I'd like to append i "0"'s to the "someNum" string. Does it have some way I can multiply a string to repeat it like Python does? So I could just go: someNum = sumNum + ("0" * 3); or something similar? Where, in this case, my final result would be: "123000".
12. Java - declaring from Interface type instead of Class
In my quest to correctly grasp Interface best practices, I have noticed declarations such as: List<String> myList = new ArrayList<String>(); instead of ArrayList<String> myList = new ArrayList<String>(); -To my understanding the reason is because it allows flexibility in case one day you do not want to implement an ArrayList but maybe another type of list. With t...
13. Is there a direct equivalent in Java for Python's str.join?
Possible Duplicates: What’s the best way to build a string of delimited items in Java? Java: convert List<String> to a join()d string In Java, given a collection, getting the iterator and doing a separate case for the first (or last) element and the rest to get a comma separated string seems quite dull, is there something like str.join in Python? Extra clarification fo...
14. How to convert an alphanumeric phone number to digits
UPDATE: The final version of my utility looks like this: StringBuilder b = new StringBuilder(); for(char c : inLetters.toLowerCase().toCharArray()) { switch(c) { case '0': b.append("0"); break; case '1': b.append("1"); break; case '2': case 'a': case 'b': case 'c': b.append("2"); break; case '3...
15. Inserting a Java string in another string without concatenation?
Is there a more elegant way of doing this in Java? String value1 = "Testing"; String test = "text goes here " + value1 + " more text"; Is it possible to put the variable directly in the string and have its value evaluated?
16. How can we improve performance of this piece of code?
How to Improve performance of this chunk of code : public static String concatStrings(Vector strings) { String returnValue = ""; Iterator iter = strings.iterator(); while( iter.hasNext() ) { returnValue += (String)iter.next(); } return returnValue; }
17. How to Reassign value of StringBuffer?
How can we re assign the value of a StringBuffer or StringBuilder Variable? StringBuffer sb=new StringBuffer("teststr"); Now i have to change the value of sb to "testString" without emptying the contents. I am looking at a method which can do this assignment directly without using separate memory allocation.I think we can do it only after emptying the contents.
18. String assembly by StringBuilder vs StringWriter and PrintWriter
I recently encountered an idiom I haven't seen before: string assembly by StringWriter and PrintWriter. I mean, I know how to use them, but I've always used StringBuilder. Is there a concrete reason for preferring one over the other? The StringBuilder method seems much more natural to me, but is it just style? I've looked at several questions here (including this one which comes closest: ht...
19. Using "this" with methods (in Java)
Exact duplicate by same poster: http://stackoverflow.com/questions/516291/the-use-of-this-in-java Hello, what about using "this" with methods in Java? Is it optional or there are situations when one needs to use it obligatory? The only situation I have encountered is when in the class you invoke a method within a method. But it is optional. Here is a silly example just to show what I mean: ...
20. Java: StringBuffer & Concatenation
I'm using StringBuffer in Java to concat strings together, like so: StringBuffer str = new StringBuffer(); str.append("string value"); I would like to know if there's a method (although I didn't find anything from a quick glance at the documentation) or some other way to add "padding". Let me explain; every time I append something to the string, I want to add a space in the end, like so: ...
21. What is the fastest way to scrape HTML webpage in Android?
I need to extract information from an unstructured web page in Android. The information I want is embedded in a table that doesn't have an id. <table> <tr><td>Description</td><td></td><td>I want this field next to the description cell</td></tr> </table> Should I use Pattern Matching? Use BufferedReader to extract the informati... 
1
  /*
2
   * Copyright 2003-2004 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang;


A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.

The principal operations on a StringBuilder 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 builder. The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.

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

In general, if sb refers to an instance of a StringBuilder, then sb.append(x) has the same effect as sb.insert(sb.length(), x). Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.

Instances of StringBuilder are not safe for use by multiple threads. If such synchronization is required then it is recommended that StringBuffer be used.

Author(s):
Michael McCloskey
Since:
1.5
See also:
StringBuffer
String
71
 
72
 public final class StringBuilder
73
     extends AbstractStringBuilder
74
     implements java.io.Serializable, CharSequence
75
 {

    
use serialVersionUID for interoperability
77
 
78
     static final long serialVersionUID = 4383685877147921099L;

    
Constructs a string builder with no characters in it and an initial capacity of 16 characters. 
83
 
84
     public StringBuilder() {
85
         super(16);
86
     }

    
Constructs a string builder with no characters in it and an initial capacity specified by the capacity argument.

Parameters:
capacity the initial capacity.
Throws:
NegativeArraySizeException if the capacity argument is less than 0.
95
 
96
     public StringBuilder(int capacity) {
97
         super(capacity);
98
     }

    
Constructs a string builder initialized to the contents of the specified string. The initial capacity of the string builder is 16 plus the length of the string argument.

Parameters:
str the initial contents of the buffer.
Throws:
NullPointerException if str is null
108
    public StringBuilder(String str) {
109
        super(str.length() + 16);
110
        append(str);
111
    }

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

Parameters:
seq the sequence to copy.
Throws:
NullPointerException if seq is null
122
    public StringBuilder(CharSequence seq) {
123
        this(seq.length() + 16);
124
        append(seq);
125
    }

    

See also:
String.valueOf(java.lang.Object)
append(java.lang.String)
131
    public StringBuilder append(Object obj) {
132
        return append(String.valueOf(obj));
133
    }
135
    public StringBuilder append(String str) {
136
        super.append(str);
137
        return this;
138
    }
140
    // Appends the specified string builder to this sequence.
141
    private StringBuilder append(StringBuilder sb) {
142
        if (sb == null)
143
            return append("null");
144
        int len = sb.length();
145
        int newcount =  + len;
146
        if (newcount > .)
147
            expandCapacity(newcount);
148
        sb.getChars(0, len, , );
149
         = newcount;
150
        return this;
151
    }

    
Appends the specified StringBuffer to this sequence.

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

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

Parameters:
sb the StringBuffer to append.
Returns:
a reference to this object.
172
    public StringBuilder append(StringBuffer sb) {
173
        super.append(sb);
174
        return this;
175
    }

    

Throws:
IndexOutOfBoundsException
180
    public StringBuilder append(CharSequence s) {
181
        if (s == null)
182
            s = "null";
183
        if (s instanceof String)
184
            return this.append((String)s);
185
        if (s instanceof StringBuffer)
186
            return this.append((StringBuffer)s);
187
        if (s instanceof StringBuilder)
188
            return this.append((StringBuilder)s);
189
        return this.append(s, 0, s.length());
190
    }

    

Throws:
IndexOutOfBoundsException
195
    public StringBuilder append(CharSequence s, int start, int end) {
196
        super.append(s, start, end);
197
        return this;
198
    }
200
    public StringBuilder append(char str[]) {
201
        super.append(str);
202
        return this;
203
    }
205
    public StringBuilder append(char str[], int offset, int len) {
206
        super.append(str, offset, len);
207
        return this;
208
    }

    

See also:
String.valueOf(boolean)
append(java.lang.String)
214
    public StringBuilder append(boolean b) {
215
        super.append(b);
216
        return this;
217
    }
219
    public StringBuilder append(char c) {
220
        super.append(c);
221
        return this;
222
    }

    

See also:
String.valueOf(int)
append(java.lang.String)
228
    public StringBuilder append(int i) {
229
        super.append(i);
230
        return this;
231
    }

    

See also:
String.valueOf(long)
append(java.lang.String)
237
    public StringBuilder append(long lng) {
238
        super.append(lng);
239
        return this;
240
    }

    

See also:
String.valueOf(float)
append(java.lang.String)
246
    public StringBuilder append(float f) {
247
        super.append(f);
248
        return this;
249
    }

    

See also:
String.valueOf(double)
append(java.lang.String)
255
    public StringBuilder append(double d) {
256
        super.append(d);
257
        return this;
258
    }

    

Since:
1.5
263
    public StringBuilder appendCodePoint(int codePoint) {
264
        super.appendCodePoint(codePoint);
265
        return this;
266
    }

    

Throws:
StringIndexOutOfBoundsException
271
    public StringBuilder delete(int start, int end) {
272
        super.delete(start, end);
273
        return this;
274
    }

    

Throws:
StringIndexOutOfBoundsException
279
    public StringBuilder deleteCharAt(int index) {
280
        super.deleteCharAt(index);
281
        return this;
282
    }

    

Throws:
StringIndexOutOfBoundsException
287
    public StringBuilder replace(int start, int end, String str) {
288
        super.replace(start, end, str);
289
        return this;
290
    }

    

Throws:
StringIndexOutOfBoundsException
295
    public StringBuilder insert(int index, char str[], int offset,
296
                                int len)
297
    {
298
        super.insert(index, str, offset, len);
299
        return this;
300
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(java.lang.Object)
insert(int,java.lang.String)
AbstractStringBuilder.length()
308
    public StringBuilder insert(int offset, Object obj) {
309
        return insert(offset, String.valueOf(obj));
310
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
AbstractStringBuilder.length()
316
    public StringBuilder insert(int offset, String str) {
317
        super.insert(offset, str);
318
        return this;
319
    }

    

Throws:
StringIndexOutOfBoundsException
324
    public StringBuilder insert(int offset, char str[]) {
325
        super.insert(offset, str);
326
        return this;
327
    }

    

Throws:
IndexOutOfBoundsException
332
    public StringBuilder insert(int dstOffset, CharSequence s) {
333
        if (s == null)
334
            s = "null";
335
        if (s instanceof String)
336
            return this.insert(dstOffset, (String)s);
337
        return this.insert(dstOffset, s, 0, s.length());
338
    }

    

Throws:
IndexOutOfBoundsException
343
    public StringBuilder insert(int dstOffset, CharSequence s,
344
                                int start, int end)
345
    {
346
        super.insert(dstOffset, s, start, end);
347
        return this;
348
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(boolean)
insert(int,java.lang.String)
AbstractStringBuilder.length()
356
    public StringBuilder insert(int offset, boolean b) {
357
        super.insert(offset, b);
358
        return this;
359
    }

    

Throws:
IndexOutOfBoundsException
See also:
AbstractStringBuilder.length()
365
    public StringBuilder insert(int offset, char c) {
366
        super.insert(offset, c);
367
        return this;
368
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(int)
insert(int,java.lang.String)
AbstractStringBuilder.length()
376
    public StringBuilder insert(int offset, int i) {
377
        return insert(offset, String.valueOf(i));
378
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(long)
insert(int,java.lang.String)
AbstractStringBuilder.length()
386
    public StringBuilder insert(int offset, long l) {
387
        return insert(offset, String.valueOf(l));
388
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(float)
insert(int,java.lang.String)
AbstractStringBuilder.length()
396
    public StringBuilder insert(int offset, float f) {
397
        return insert(offset, String.valueOf(f));
398
    }

    

Throws:
StringIndexOutOfBoundsException
See also:
String.valueOf(double)
insert(int,java.lang.String)
AbstractStringBuilder.length()
406
    public StringBuilder insert(int offset, double d) {
407
        return insert(offset, String.valueOf(d));
408
    }

    

Throws:
NullPointerException
413
    public int indexOf(String str) {
414
        return indexOf(str, 0);
415
    }

    

Throws:
NullPointerException
420
    public int indexOf(String str, int fromIndex) {
421
        return String.indexOf(, 0, ,
422
                              str.toCharArray(), 0, str.length(), fromIndex);
423
    }

    

Throws:
NullPointerException
428
    public int lastIndexOf(String str) {
429
        return lastIndexOf(str, );
430
    }

    

Throws:
NullPointerException
435
    public int lastIndexOf(String str, int fromIndex) {
436
        return String.lastIndexOf(, 0, ,
437
                              str.toCharArray(), 0, str.length(), fromIndex);
438
    }
440
    public StringBuilder reverse() {
441
        super.reverse();
442
        return this;
443
    }
445
    public String toString() {
446
        // Create a copy, don't share the array
447
        return new String(, 0, );
448
    }

    
Save the state of the StringBuilder instance to a stream (that is, serialize it).

SerialData:
the number of characters currently stored in the string builder (int), followed by the characters in the string builder (char[]). The length of the char array may be greater than the number of characters currently stored in the string builder, in which case extra characters are ignored.
461
    private void writeObject(java.io.ObjectOutputStream s)
462
        throws java.io.IOException {
463
        s.defaultWriteObject();
464
        s.writeInt();
465
        s.writeObject();
466
    }

    
readObject is called to restore the state of the StringBuffer from a stream. 
472
    private void readObject(java.io.ObjectInputStream s)
473
        throws java.io.IOException, ClassNotFoundException {
474
        s.defaultReadObject();
475
         = s.readInt();
476
         = (char[]) s.readObject();
477
    }
New to GrepCode? Check out our FAQ X