Wednesday, January 4, 2012


Q: So the String class is final because its methods are complex?
A: Yes, it is partly because the String class implementation is so complex that overriding the class would very likely cause problems. A subclass would have to take account of lots of internal code that maintains the integrity of the String data representation, such as the Unicode representation, locale-specific features, upper and lower case schemes and byte conversion.
A high level of complexity and compatibility constraints are the most typical reasons you would mark any class final, but the integrity of the String class is also critical to many Java security mechanisms. A custom class that could stand in place of a String could be mis-used.
Q: How many objects are created for identical strings?
A: Two identical string literal assignments would create two separate string references, but they would both refer to the same string object. This is a special optimisation case that is supported by the fact that string objects are immutable in Java. Once a Java String object is created it cannot be changed, so it is safe for any number of identical string literal references to point to a single String object.
The Java compiler marks string literals in a way that the Java Virtual Machine can identify and add to its String Literal Pool, a collection of references to Java string objects. If identical string literals are found at runtime the String Literal Pool provides a reference to the first instance of the string, and no duplicate String object is created. That means that two identical string literals refer to the same Java object.
This optimisation does not apply to strings declared with the new String() constructor, as the examples below demonstrate.
Q: What's the use of the String constructor?
A: The explicit String constructor has the same result as using double quotes to implicitly create a string reference, in both cases the given string is assigned to the reference variable. However, passing a double quoted string argument to the String constructor actually makes two strings; the argument string is implicitly created inline and then its contents are copied to the new String instance. For this reason this constructor is largely redundant and not recommended for general purposes. The String constructor with String argument is rarely used except to create an independent copy of an existing string variable.
// Creates one string implicitly String s = "This is a test string";  // Creates two string instances String s = new String("This is a test string");       
Q: How should I use the String constructor?
A: The String class does have a constructor but it should not be used unless you have a very clear and definite purpose for it. In most cases a new String should be declared by enclosing the relevant text in double quotes assigned to a String variable, or passed directly into a method.
String myString = "Efficient String creation.";  System.out.println("Anonymous string instance.");     
There are a number of specialist String constructors that can be used to create strings from character and byte arrays, StringBuffer and StringBuilder references, see the Java API documentation for full details.
public String(char[] value);  public String(char[] value, int offset, int count);  public String(byte[] value);  public String(byte[] value, int offset, int count);  public String(StringBuffer buffer);  public String(StringBuilder builder);     
The int arguments above operate like a substring method parameters, to select only the characters from the offset index of the array onwards by count characters.

String methods and operators

Q: One case prints a Java code, another a literal string!
A: Your sample code shows some confusion between reference values and literal strings. Whenever an object reference is passed to the System.out.println(Object) method, its toString()method is used to provide the output.
a a1 = new a();  out.println("a");       
In this case, the instantiation of the class a, referenced by the variable a1 is legitimate, but the second line completely disregards it and will print the string literal "a". Whenever you put characters in double quote marks like this, the Java interpreter will treat it as a String object, not a reference to the class a or instance a1.
try {   ... } catch(Exception e) {    out.println(e); }       
In the second case the reference to the exception e will be printed by calling its toString() method. The default implementation of toString() inherited from the Object class will output a coded reference to the object in the Java Virtual Machine. If the toString() method has been overridden by the exception class, it may provide human readable diagnostic information.
Q: The == operator doesn't match strings correctly!
A: Java strings are stored as an immutable sequence of Unicode characters and the class' equals() method is overridden to compare that character content, so standard logical comparison operators will not give the result one might expect. If you use the simple comparison operator on two string objects that represent the same string, it will return false. Always use theequals(Object) method to compare the contents of two strings, as below.
Q: Is the + operator overloaded?
A: Java does not have operator overloading, but string concatenation is a special case. When the + operator is applied to a String, the two values are appended as a new String. If you use the + operator with a String and a primitive value, such as an int or long, the Java interpreter implicitly converts the primitive value a string representation and concatenates them.
Q: How can you say the + operator is not overloaded in Java!
A: The plus operator for Java strings is a limited exceptional case that is practically the same as operator overloading. Its a fine distinction but using + to append object contents is not a general case in Java, it only applies to String objects. An equivalent append operation may be meaningful and useful for data storage types but does not have a general application and is not implemented in Java.
// Compiler error: "operator + cannot be applied to java.util.Vector" // Vector vector = new Vector() + new Vector();       
Q: How can I reverse the characters in a string?
A: This example code gets a char array from the input string and loops through it to populate a second char array. The for loop uses two variables, i is incremented and j is decremented at each pass. The output array could be used to create a new string or output directly, as in this case.

String buffers and tokenizers

Q: What is the difference between String and StringBuffer?
A: The main difference is that in Java Strings are immutable, which makes them quite inefficient for concatenating large amounts of text, especially in extensive loops. For each Stringconcatenation statement the Java runtime system must instantiate at least one additional String object and then dispose of it. StringBuffer is designed exactly to overcome this problem, to build string content in an editable internal buffer without generating lots of additional objects. StringBuffer has many convenience methods to append all Java primitive types, character arrays and objects, and to check and manipulate characters in the buffer.
Q: When should I use a StringBuffer instead of a String?
A: In most cases you should use a StringBuffer rather than string concatenation. The character content of Java String objects is immutable. Whenever you concatenate two Stringinstances you actually create a third String object for the result. This implicit String object creation can slow down your program, increase the number of objects in the runtime system and the garbage collection required to dispose of the temporary strings.
On a small scale, string concatenation is unlikely to have a significant performance impact, but if you are building strings in a for or while loop, or over many statement lines it is better to use a StringBuffer, or StringBuilder in single threaded applications.
Q: Why don't two StringBuffers match?
A: The String class overrides the default implementation of the equals(Object) method to compare the string contents of each object. In this case equivalent string contents are considered equal. The StringBuffer class does not override the superclass Object equals(Object) method, which tests whether the argument refers to the same object reference.
Q: What's the difference in the memory allocation for StringBuffers?
A: The key difference between a String and a StringBuffer in terms of memory allocation is that String objects are immutable; once the string contents are set they cannot be changed, so the virtual machine can optimise memory use on this basis. The content of StringBuffers can be expanded beyond their initial buffer size, so the memory allocation needs to be variable and must be managed by the Java runtime system. The StringBuffer class automatically adjusts its buffer size to fit the string content it is given, but you should instantiate the class with an explicit buffer size large enough to avoid the performance overhead associated with such resizes.
StringBuffer buffer = new StringBuffer(1024);       
Java programmers should not be concerned with detailed level memory management for String operations, which will be handled and optimised by the runtime system. The key things are to choose String or StringBuffer types appropriate to the task and set an adequate buffer size.
Q: How can I pad a StringBuffer?
A: The StringBuffer insert(int, String) method can be used to pad the buffer at specific locations. The method inserts the given string at the offset position indicated by the int value and shifts the original buffer contents right. The original string contents are preserved and the buffer length is increased by the length of the inserted string.
Q: What is a StringTokenizer for?
A: The standard java.util.StringTokenizer class is a special type of Enumeration that represents segments of a string, which may be separated by one or more "delimiters". When you construct a StringTokenizer with a comma delimiter, it will identify each word in a comma separated list for instance.
Q: How can I get a person's initials from their full name?
A: The simplest way to extract single words from a string like a full name is to use a StringTokenizer. The String method charAt(int) can then be used to get the first character of each word, as below.

Regular expressions

Q: How can I check a string has no numbers?
A: The simplest way to check that a String does not contain any numbers is to use the regular expression class Pattern in the java.util.regex package. The method below uses the regular expression [^0-9]+ to check that none of the characters in the input string is a number. The square brackets define a character class. The negation modifier ^ followed by the number range 0-9 means "not a number". The + quantifier asks the regular expression to match the character class one or more times.

Post a Comment

Receive All Free Updates Via Facebook.