For every primitive type in Java, there is a built-in object type called a wrapper class. For example, the wrapper class for int is called Integer; for double it is called Double.
Wrapper classes are useful for several reasons:
The most straightforward way to create a wrapper object is to use its constructor:
Integer i = new Integer (17);Technically String is not a wrapper class, because there is no corresponding primitive type, but the syntax for creating a String object is the same:
String s = new String ("fred");On the other hand, no one ever uses the constructor for String objects, because you can get the same effect with a simple String value:
String s = "fred";In my development environment, the Boolean wrapper class has not been implemented correctly. There is supposed to be a constructor that takes a primitive boolean as an argument, but the following code
Boolean b = new Boolean (true);generates an error.
Some of the wrapper classes have a second constructor that takes a String as an argument and tries to convert to the appropriate type. For example:
Integer i = new Integer ("17");There is supposed to be a Boolean constructor that takes a String argument, but it has not been implemented in my development environment. There is no such constructor for Characters.
The type conversion process is not very robust. For example, if the Strings are not in the right format, they will cause a NumberFormatException. Any non-numeric character in the String, including a space, will cause the conversion to fail.
Integer i = new Integer ("17.1"); // WRONG!!It is usually a good idea to check the format of the String before you try to convert it.
Annoyingly, there is yet another way to create wrapper objects, using class methods in the wrapper classes.
Integer i = Integer.valueOf ("17");These methods use the same conversion methods as the constructors (parseInt and parseDouble), so they are no more robust.
When there are two ways to do the same thing, it is probably best to choose one and stick to it consistently. In this case, I think using the constructors is much better than using valueOf, because it makes it much clearer that you are creating new wrapper objects. The name valueOf is poorly chosen; given the name, it is not at all clear what it does.
Java knows how to print wrapper objects, so the easiest way to extract a value is just to print the object:
Integer i = new Integer (17);Alternatively, you can use the toString method to convert the contents of the wrapper object to a String
String istring = i.toString();Finally, if you just want to extract the primitive value from the object, there is an object method in each wrapper class that does the job:
int iprim = i.intValue ();There are also methods for converting wrapper classes into different primitive types.
As I mentioned, the wrapper classes contain useful methods that pertain to each type. For example, Integer contains methods for interpreting and printing integers in different bases. If you have a String that contains a number in base 6, you can convert to base 10 using parseInt.
String base6 = "12345";Since parseInt is a class method, you invoke it by naming the class and the method in dot notation.
Base 6 might not be all that useful, but hexadecimal (base 16) and octal (base 8) are common for computer science related things.
In the Character class, there are lots of methods for converting charaters to upper and lower case, and for checking whether a character is a number, letter, or symbol.