Upload
patel-prit
View
298
Download
5
Tags:
Embed Size (px)
DESCRIPTION
fvsdg
Citation preview
Java has a wrapper class for each of the eight primitive data types:
Primitive Type
Wrapper Class
Primitive Type
Wrapper Class
boolean Boolean float Float
byte Byte int Integer
char Character long Long
double Double short Short
Java’s 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 (will study later in Java):
List<Integer> a = new ArrayList<Integer>();methodRequiringListOfIntegers(a);
Wrapper.valueOf() takes a value (or string) and returns an object of that class:
Integer i2 = Integer.valueOf(“42”);
Boolean b2 = Boolean .valueOf(“true”);
Long n1 = Long.valueOf(“42000000L”);
public class WrapperDemo {
public static void main(String args[]) {
Boolean bool = Boolean.valueOf("true"); Character c = new Character('c'); Byte b = Byte.valueOf("12"); Short s = Short.valueOf("2"); Integer i = Integer.valueOf("13245"); Long l = Long.valueOf("12341234"); Float f = Float.valueOf("11234.1234"); Double d =
Double.valueOf("43213241234.123412341234");
System.out.println(bool); System.out.println(c); System.out.println(b); System.out.println(s); System.out.println(i); System.out.println(l); System.out.println(f); System.out.println(d); } }
Each wrapper class Type has a method typeValue to obtain the object’s value:
Integer i1 = Integer.valueOf(“42”;Boolean b1 = Boolean.valueOf(“false”);System.out.println(i1.intValue());System.out.println(b1.boolValue());
=>42false
The Wrapper class for each primitive type has a method parseType() to parse a string representation & return the literal value.
Integer.parseInt(“42”) => 42Boolean.parseBoolean(“true”) => trueDouble.parseDouble(“2.71”) => 2.71//…
Common use: Parsing the arguments to a program:
public static void main(String[] args) { // TODO Auto-generated method stub
for (int i = 0; i < args.length; i++) { try { System.out.println(Integer.parseInt(args[i])); } catch (Exception e) { try { System.out.println(Float.parseFloat(args[i])); } finally { } } } } }
Object boolObj = new Boolean(Boolean.TRUE); Object charObj = new Character('a'); Number byteObj = new Byte("100"); Number shortObj = new Short("32000"); Number intObj = new Integer(2000000); Number longObj = new Long(500000000000000000L); Number floatObj = new Float(1.42); Number doubleObj = new Double(1.42);
System.out.println(boolObj); // true System.out.println(charObj); // a ….. …………
=> For Boolean & Character Wrappers (Objects wrappers): Boolean:true Character:a
For Number wrappers: Byte:100 Short:32000 Integer:2000000 Long:500000000000000000 Float:1.42 Double:1.42
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:");
=> Byte:127 Short:32767 Integer:2147483647 Long:9223372036854775807 Float:3.4028235E38 Double:1.7976931348623157E308
int hashCode()static int numberOfLeadingZeros(int i)static int numberOfTrailingZeros(int i)static int reverse(int i)static int reverseBytes(int i)static int rotateLeft(int i, int distance)static int rotateRight(int i, int distance)static String toBinaryString(int i)static String toHexString(int i)static String toOctalString(int i)static String toString(int i, int radix)
Constants POSITIVE_INFINITY & NEGATIVE_INFINITY Constant NaN = Not-a-Number (NaN) value. Methods isNaN(), isInfinite()
import java.util.Map; import java.util.TreeMap;
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); } }
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. We continue by writing the same program with auto boxing, generics, and an enhanced for loop:
Generic implementation rewritten with auto boxing, 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); }}
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.