{"id":11877,"date":"2014-07-22T11:00:35","date_gmt":"2014-07-22T08:00:35","guid":{"rendered":"http:\/\/examples.javacodegeeks.com\/?p=11877"},"modified":"2020-09-30T10:52:44","modified_gmt":"2020-09-30T07:52:44","slug":"java-stringbuffer-example","status":"publish","type":"post","link":"https:\/\/examples.javacodegeeks.com\/stringbuffer-java-example\/","title":{"rendered":"StringBuffer Java Example"},"content":{"rendered":"

In this example, we are going to present the StringBuffer class<\/a> in Java, and StringBuffer vs StringBuilder which is\u00a0contained in the java.lang<\/code> package. We are going to show some of its most important uses and methods, and explain why and when it should be used, as well as the difference between StringBuffer<\/code> and String<\/code>.<\/p>\n

1. String vs StringBuffer<\/h2>\n

Strings in Java are immutable<\/strong>. This means that when you instantiate a new String<\/code> Object, you can not ever alter it. However, some of the most commonly seen code in Java happens to look like this:<\/p>\n

String str = \"hello\";\nstr = str + \" world\";\n\/\/this prints \"hello world\"\n<\/pre>\n
So, what is going on here? Although it seems that we are appending to the String object, that in fact does not happen. What actually happens, is that the JVM creates a new StringBuffer<\/code> object, which afterwards appends the different strings and in the end creates a new string, with a reference to the original. So essentially, we do not append a string to another, but we destroy the original String<\/code> and use its variable to point to a whole new String<\/strong> (the concat of the first and the second one), which is also immutable.<\/p>\n
Although it may seem that it is not a huge difference, it is in fact very important for optimization<\/strong>. While it is easier (and sometimes even advisable) to use the + operator for simplicity, when you have to do with a huge number of string concats you should try to use something like StringBuffer<\/code> to make it faster. We will show the huge speed difference in the example later.<\/p>\n
2. StringBuffer vs StringBuilder<\/h2>\n
Till Java 1.5 developers had a choice between String<\/code> and StringBuffer<\/code>. With Java 1.5 developers got a new option StringBuilder. In this section let us see the differences between StringBuffer and StingBuilder<\/code>.<\/p>\n
\n\n\n\n\n\n\n\n
StringBuffer<\/th>\nStringBuilder<\/th>\n<\/tr>\n<\/thead>\n
Thead safe as all methods are synchronised<\/td>\nNot thead safe, othewise it offers same features as StringBuffer<\/code><\/td>\n<\/tr>\n
Offered as pat of Java early releases<\/td>\nIntroduced only in Java 1.5<\/td>\n<\/tr>\n
Less performant as all methods are marked synchronised<\/td>\nOffers better performance than StringBuffer<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>
StringBuffer Vs StringBuilder Table<\/figcaption><\/figure>\n<\/p>\n
If you operate in a single-threaded environment or don’t care about thead-safety then use StringBuilder<\/code>.<\/p>\n
3. StringBuffer constructors<\/h2>\n
StringBuffer<\/code> offers below different constructors:<\/p>\n
\n\n\n\n\n\n\n\n\n
Constructor<\/th>\nExplanation<\/th>\n<\/tr>\n<\/thead>\n
StringBuffer()<\/code><\/td>\nDefault constructor which allocates uninitialized StringBuffer<\/code> of 16 characters capacity<\/td>\n<\/tr>\n
StringBuffer(CharSequence seq)<\/code><\/td>\nConstructs a StringBuffer<\/code> with same contents as in input chracter sequence<\/td>\n<\/tr>\n
StringBuffer(int capacity)<\/code><\/td>\nConstructs an empty StringBuffer<\/code> with specified capacity number of characters as capacity<\/td>\n<\/tr>\n
StringBuffer(Sting s)<\/code><\/td>\nConstructs a StringBuffer<\/code> initialized with the specifie input String<\/code> s<\/td>\n<\/tr>\n<\/tbody>\n<\/table>
StringBuffer constructors Table<\/figcaption><\/figure>\n
4. StringBuffer Java Example<\/h2>\n
Below Example depicts the usage of StringBuffer<\/code>,
 
<\/div> <\/div><\/p>\n
\n
public class StringBufferMain {\n\n    public static void main(String[] args) {\n        StringBuffer buffer = new StringBuffer();\n        \n        \/\/ Append the string representation of the argument to the end of the buffer.\n        \/\/ In this example we use a string, but the method also accepts int, float,\n        \/\/ double, boolean, char (or char[]), as well as objects.\n        buffer.append("Hello World!");\n        System.out.println(buffer.toString());\n        \n        \/\/ Delete the specified substring by providing the start and the end\n        \/\/ of the sequence.\n        buffer.delete(5, 11);\n        System.out.println(buffer.toString());\n        \n        \/\/ Delete just one char by providing its position.\n        buffer.deleteCharAt(5);\n        System.out.println(buffer.toString());\n        \n        \/\/ Insert a string in a specified place inside the buffer.\n        buffer.insert(0, "World ");\n        System.out.println(buffer.toString());\n        \n        \/\/ Get the index that the specified substring starts at.\n        System.out.println("Index of Hello: " + buffer.indexOf("Hello"));\n        System.out.println(); \/\/ Empty line\n        \n        \n        \n        \/\/ You can also instantiate a new StringBuffer and provide\n        \/\/ the initial String in the constructor.\n        StringBuffer newBuffer = new StringBuffer("This is a Hello World string. Hello!");\n        \n        \/\/ You can use lastIndexOf(String) to get the last time that a specified\n        \/\/ substring appears in the StringBuffer.\n        System.out.println("Index of Hello: " + newBuffer.indexOf("Hello"));\n        System.out.println("Last index of Hello: " + newBuffer.lastIndexOf("Hello"));\n        \n        \/\/ You can also replace a specific sub-sequence of the StringBuffer with another string.\n        \/\/ The size does not need to be the same, as shown here.\n        newBuffer.replace(0, 4, "That here");\n        System.out.println(newBuffer.toString());\n        \n        \/\/ You can replace a single char using this method here. We want to\n        \/\/ replace the last character of the string, so instead of counting the length,\n        \/\/ we will use the provided length() method, and replace the char in the last index.\n        newBuffer.setCharAt(newBuffer.length() - 1, '?');\n        System.out.println(newBuffer.toString());\n        \n        \/\/ You can reverse the StringBuffer as well!\n        newBuffer.reverse();\n        System.out.println(newBuffer.toString());\n        \n        \n        compareTime();\n    }\n\n    private static void compareTime() {\n        long startTime;\n        String str = "";\n        StringBuffer buffer = new StringBuffer();\n        \n        \/\/ Using String\n        startTime = System.currentTimeMillis();\n        for (int i = 0; i < 10000; i++) {\n            str += "extra";\n        }\n        System.out.println("Time using String: "\n                + (System.currentTimeMillis() - startTime) + " ms.");\n        \n        \/\/ Using StringBuffer\n        startTime = System.currentTimeMillis();\n        for (int i = 0; i < 10000; i++) {\n            buffer.append("extra");\n        }\n        System.out.println("Time using StringBuffer: "\n                + (System.currentTimeMillis() - startTime) + " ms.");\n    }\n}<\/pre>\n<\/div>\n
The first thing that you need to draw your attention to is the time output (the last 2 lines). You can see an enormous difference in time, which makes it pretty clear that Stringbuffer<\/code> is the recommended approach when you have to deal with a large number of strings<\/strong> (in our example it is 10000). 488 ms vs. 2 ms makes a whole lot of a difference, especially in heavy applications, where 10000 strings might be the minimum threshold.<\/p>\n
\n
\"StringBuffer
Output<\/figcaption><\/figure>\n<\/div>\n
Secondly, let’s take a look at some of the most interesting and important StringBuffer methods, which were used in the example:<\/p>\n