The advantages of the String implementation in JAVA 1. Compilation creates unique strings. Strings are resolved during compile time. This involves applying the concatenation operators and changing other literals into strings. Hi7 and hi+7 are both resolved to the same string at compile time and are equivalent objects inside the class string pool. Compilers differ in their ability to reach this resolution. You can always check the compiler by decompiling any statements that involve concatenation and changing it if necessary. 2. Since String objects are unchangeable Substring operations don't have to copy the whole sequence of characters. In fact, substrings could use the same char array the original string and simply refer to a different start point and ending point in the array of characters. Substring Hire Software Development Team operations are effective, as they are both fast and conserving of memory. The extra object is just wrapping the base char array, with distinct pointers into the array. 3. Strings are implemented in the JDK inside an internal char array, with index offsets. It is an offset at the start and character count. This fundamental structure is unlikely to be changed in any version of Java. 4. Strings have strong support for internationalization. It will require a significant effort to replicate the internationalization benefits of an alternative class. 5. StringBuffers are in close proximity to StringBuffers and StringBuffers, which means that Strings can refer to the same char array that is used by StringBuffers. It's a double-edged sword. If, in normal practice, you use a StringBuffer to modify and add characters, data types, and later transform the result into an String, this works just fine. The StringBuffer provides efficient mechanisms for growing, inserting, appending or altering kinds of String manipulation. The resulting String then efficiently references the same char array , with no extra character copying. This is extremely fast and minimizes the number objects being employed by removing intermediate objects. If the StringBuffer object is later modified The StringBuffer copy the StringBuffer's char array into a new referenced array of characters. The String object retains the reference to the previously shared array of characters. The overhead of copying can occur at unanticipated points in an application. The overhead of copying does not occur at the toString(?) method call like you'd expect. Any subsequent alteration made to the StringBuffer triggers an array copy to take place and an array of characters is created. To make the copying overhead occur at predictable times, you could explicitly execute some method that makes the copying occur, such as StringBuffer.setLength( ). StringBuffers are reusable more easily with a reliable performance. The drawbacks of the implementation of String are 1. It's impossible to subclass String and, therefore, you are unable to change the behavior of String to suit your needs. 2. The last point indicates that all access has to be through the restricted list of available String methods, imposing extra overhead. 3. It is possible to enhance the efficiency and number of String character manipulation methods by copying the characters into your own array, and then manipulating them. String will then impose an additional step is not necessary. 4. Char arrays are able to be processed faster. 5. The tight coupling with String Buffer can lead to an unexpectedly high amount of memory usage. StringBuffer converts to String( () creates StringBuffer. The current array holds StringBuffer's string regardless of its size (i.e. the capacity of the StringBuffer). For example, a StringBuffer with a capacity of 10,000 characters can create a string of 10 characters. The 10-character String still utilizes a 10,000-char array to store its 10 characters. The StringBuffer can be used to create a new string of 10 characters. First, it creates an internal array of 10,000 characters for construction of the string. The String makes use of the same array of 10,000 characters to store the 10 characters. The process could continue indefinitely and use large amounts of memory. The StringBuffer then creates a new internal array of 10,000 characters to construct the string using; and then the new String is built using the same array of 10,000 characters to store the 10 characters. Many methods return String objects which are more commonly used than char arrays. The disadvantage of Strings boils down to inflexibility. If you do extra work, the majority of tasks you can perform using String objects can be done quicker and with less objects by making use of your own set of methods for manipulating char arrays.