Benefits of the String implementation in JAVA 1. Compilation creates unique strings. When compiling, strings are resolved as far as they can. This includes applying the concatenation operator and changing other literals into strings. Hi7 and hi+7 both resolve to the same string at compile time and are equivalent objects within the class string pool. Compilers differ in their capacity to attain this resolution. You can test the compiler's capabilities by decompiling the statements that require concatenation, and then changing it, if needed. 2. Substring operations do not require copying all of the characters in String objects. In fact, substrings can make use of the same array of characters that was used in the original string, and use a different starting point and ending point in the array of characters. Substring operations are quick and efficient as they help save memory. The additional object is simply an extra wrapper to the Custom Software Development underlying array of chars with different pointers. 3. Strings are implemented in the JDK as an internal char array using index offsets (actually a start offset and a count of characters). This fundamental structure is unlikely to be changed with any other version of Java. 4. Strings have strong support for internationalization. It will take a huge effort to reproduce the internationalization capabilities of another class. 5. The close relationship with StringBuffers allows Strings to refer to the same char array as used by the StringBuffer. This is an extremely effective weapon with two edges. If, in normal practice, you make use of a StringBuffer modify and add characters, data types, and later convert the final result to an String and then convert it to a String, it will work well. StringBuffer offers efficient methods for manipulating Strings, such as changing, growing, insertion and appending. The resulting String will then be able to effectively reference the same array of characters with no additional copying of characters. It is extremely speedy and reduces the number of objects being used by eliminating intermediate objects. When the StringBuffer object is later altered The StringBuffer copy the StringBuffer's char array into a referenced array of characters. The String object retains its reference to the shared char array. This means that copying overhead can occur at unexpected points in the application. Instead of copying happening during the toString( ) method calling, as anticipated, any subsequent modification of the StringBuffer results in an entirely new array of characters to be created, and an array copy to be carried out. 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 can be reused more quickly and with reliable performance. The drawbacks of the String implementation are 1. Not being able to subclass String means that it is impossible to add additional behavior to String for your own needs. 2. This means that access can be done via the limited number of String methods that are currently available, which adds cost. 3. It is possible to enhance the efficiency and number of String character manipulation methods by copying characters onto your own array, and then manipulating them. String will then impose an additional procedure that is not necessary. 4. Char arrays are more efficient to process direct. 5. String Buffer's tightly coupled coupling could result in unexpectedly high memory usage. StringBuffer toString( () creates StringBuffer. The array is able to hold StringBuffer's strings regardless of the size (i.e. the StringBuffer's capacity). A StringBuffer that has the capacity to store 10,000 characters could be used to make a string of 10 characters. The 10-character String still utilizes a 10,000-char array to store its 10 characters. If the StringBuffer is used to create another 10-character string then the StringBuffer first creates a brand new internal array of 10,000-chars to create the string with; Then, the new String uses that 10,000-char array to store the 10 characters. The process could continue indefinitely and use large amounts of memory. The StringBuffer creates an internal array of 10,000 characters to construct the string with; then, the new String uses that same 10,000-char array to store the 10 characters. A variety of methods produce String objects which are more commonly used than the char arrays. Strings have a disadvantage as they're not flexible. String objects aren't flexible, so it takes additional effort to work with them. You may also make String objects more quickly by developing your custom char array manipulation technique.