- Q: Why is the
String class declared final?
A: The short answer is that any class may be declared final if it is not considered suitable for extension, particularly if it is a highly specialised class. When an Application Programming Interface (API) class is very specialised, its internal behaviour may be quite complex and pose un-seen problems for anyone who would create a subclass.
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 anyclass 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 withString argument is rarely used except to create an independent copy of an existing string variable.
String s = "This is a test string";
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 theoffset index of the array onwards by count characters.
- 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 instancea1.
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 the equals(Object) method to compare the contents of two strings, as below.
The == operator doesn't match strings correctly!
- 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 aString 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.
A: This example code gets a char array from the input string and loops through it to populate a secondchar 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.
- 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 String concatenation 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 String instances 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, orStringBuilder 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. TheStringBuffer class does not override the superclass Object equals(Object) method, which tests whether the argument refers to the same object reference.
A: The key difference between a String and a StringBuffer in terms of memory allocation is that Stringobjects 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 orStringBuffer 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 aStringTokenizer 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. TheString method charAt(int) can then be used to get the first character of each word, as below.
No comments:
Post a Comment