Wrappers: Javas Wrapper Classes for the Primitives Types

Steve Bossie

NJIT
1
3/24/200804/29/06

Primitives & Wrappers

Java has a wrapper class for each of the eight primitive data types:
Primitive Type boolean byte char double Wrapper Class Boolean Byte Character Double
3/24/2008

Primitive Type float int long short

Wrapper Class Float Integer Long Short

Use of the Wrapper Classes

Javas primitive data types (boolean, int, etc.) are not classes. Wrapper classes are used in situations where objects are required, such as for elements of a Collection:

List<Integer> a = new ArrayList<Integer>(); methodRequiringListOfIntegers(a);

3/24/2008

Value => Object: Wrapper Object Creation

Wrapper.valueOf() takes a value (or string) and returns an object of that class:

Integer i1 = Integer.valueOf(42); Integer i2 = Integer.valueOf(42);

Boolean b1 = Boolean .valueOf(true); Boolean b2 = Boolean .valueOf(true); Long n1 = Long.valueOf(42000000L); Long n1 = Long.valueOf(42000000L);

3/24/2008

Object => Value

Each wrapper class Type has a method typeValue to obtain the objects value:

Integer i1 = Integer.valueOf(42); Boolean b1 = Boolean.valueOf(false); System.out.println(i1.intValue()); System.out.println(b1.intValue()); => 42 false 5

3/24/2008

String => value

The Wrapper class for each primitive type has a method parseType() to parse a string representation & return the literal value.
=> 42 => true => 2.71

Integer.parseInt(42) Boolean.parseBoolean(true) Double.parseDouble(2.71) //

Common use: Parsing the arguments to a program:

3/24/2008

Parsing argument lists

// Parse int and float program args. public parseArgs(String[] args) { for (int i = 0; i < args.length; i++) { try { println(Integer.parseInt(args[i])); } catch (Exception e) { try { println(Float.parseFloat(args[i])); } finally { } }}}
7
3/24/2008

Parsing argument lists

=>

arg # 0 = 0 arg # 1 = 42 arg # 2 = 999

arg # 3 = 0.0
arg # 4 = 1.42 8
3/24/2008

Sample values:
boolObj new Boolean(Boolean.TRUE); charObj = new Character('a'); byteObj = new Byte("100"); shortObj = new Short("32000"); intObj = new Integer(2000000); longObj = new Long(500000000000000000L); floatObj = new Float(1.42); doubleObj = new Double(1.42);
printWrapperInfo(); //method to print objects above

3/24/2008

Sample values (output from previous slide):

=> For Boolean & Character Wrappers: Boolean:true Character:a

For Number wrappers: Byte:100 Short:32000 Integer:2000000 Long:500000000000000000 Float:1.42 Double:1.42

10

3/24/2008

Each Number Wrapper has a MAX_VALUE constant:

byteObj = new Byte(Byte.MAX_VALUE); shortObj = new Short(Short.MAX_VALUE); intObj = new Integer(Integer.MAX_VALUE); longObj = new Long(Long.MAX_VALUE); floatObj = new Float(Float.MAX_VALUE); doubleObj = new Double(Double.MAX_VALUE); printNumValues("MAXIMUM NUMBER VALUES:");

11

3/24/2008

MAX values (output from previous slide):

=> Byte:127 Short:32767 Integer:2147483647 Long:9223372036854775807 Float:3.4028235E38 Double:1.7976931348623157E308

12

3/24/2008

Many useful utility methods, e.g., for Integer:

static static static static static static static static static static
13 int int int int int int int String String String String hashCode() numberOfLeadingZeros(int i) numberOfTrailingZeros(int i) reverse(int i) reverseBytes(int i) rotateLeft(int i, int distance) rotateRight(int i, int distance) toBinaryString(int i) toHexString(int i) toOctalString(int i) toString(int i, int radix)
3/24/2008

Double & Float: Utilities for Arithmetic Operations:

Constants POSITIVE_INFINITY & NEGATIVE_INFINITY Constant NaN = Not-a-Number (NaN) value.

Methods isNaN(), isInfinite()

14

3/24/2008

Primitive - Wrapper Split Personality:

Although the Wrapper classes provide needed functionality (OO versions of primitives and supporting functionality), Java code is sometimes overly complicated due to the necessary conversions between the primitive and wrapper versions of data being manipulated. Joshua Bloch published a technical note, excerpts of which are used below. Blochs article can be found at http://java.sun.com/features/2003/05/bloch_qa.html
3/24/2008

15

Blochs counting program: Java 1.4 Version

public class Freq { private static final Integer ONE = new Integer(1); public static void main(String args[]) { // Maps word (String) to frequency (Integer) Map m = new TreeMap(); for (int i=0; i<args.length; i++) { Integer freq = (Integer) m.get(args[i]); m.put(args[i], (freq==null ? ONE : new Integer(freq.intValue() + 1))); } System.out.println(m); } }

16

3/24/2008

Notes on the 1.4 Version:

This program generates a frequency table of words on the command line. It uses a Map whose keys are the words and whose values are the number of times that each word occurs on the line. The inner-loop code is a bit convoluted. Bloch continues by writing the same program with autoboxing, generics, and an enhanced for loop:

17

3/24/2008

Blochs counting program: Java 1.5 Version:

Blochs implementation rewritten with autoboxing, generics, and an enhanced for loop:

public class Freq { public static void main(String args[]) { Map<String, Integer> m = new TreeMap<String, Integer>(); for (String word : args) { Integer freq = m.get(word); m.put(word, (freq == null ? 1 : freq + 1)); } System.out.println(m); } }

18

3/24/2008

Notes on the 1.5 Version:

This version is much clearer, and is a good example of the use of a Wrapper class without the pitfalls of convoluted primitive-wrapper conversions.

19

3/24/2008

Final Notes

Javas wrapper classes are useful and provide a great deal of functionality, well beyond that of the primitive types. Code using Wrapper classes and primitives can be convoluted. Use Java 1.5s generics, autoboxing and the enhanced for loop to avoid unclear code.

20

3/24/2008