Wrapper Classes,Scanner Class and Array Class Lab # 10

LAB # 10

WRAPPER CLASSES, SCANNER CLASS

AND ARRAY CLASS

OBJECTIVE:
To get familiar with wrapper classes; Scanner class, and Array class.

THEORY:

10.1 WRAPPER CLASSES IN JAVA

A Wrapper class is a class whose object wraps or contains a primitive data
types. When we create an object to a wrapper class, it contains a field and in
this field, we can store a primitive data types. In other words, we can wrap a
primitive value into a wrapper class object.
Need of Wrapper Classes:

1. They convert primitive data types into objects. Objects are needed if
we wish to modify the arguments passed into a method (because
primitive types are passed by value).
2. The classes in java.util package handles only objects and hence
wrapper classes help in this case also.
3. Data structures in the Collection framework, such
as ArrayList and Vector, store only objects (reference types) and not
primitive types.
4. An object is needed to support synchronization in multithreading.

Primitive Data types and their Corresponding Wrapper class

Object Oriented Programming - OOPs 1

Wrapper Classes,Scanner Class and Array Class Lab # 10

The following program demonstrate the above mentioning description

about wrapper class.

// Java program to demonstrate Wrapping and UnWrapping

// in Java Classes
class WrappingUnwrapping
{
public static void main(String args[])
{
// byte data type
byte a = 1;

// wrapping around Byte object

Byte byteobj = new Byte(a);

// int data type

int b = 10;

//wrapping around Integer object

Integer intobj = new Integer(b);

// float data type

float c = 18.6f;

// wrapping around Float object

Float floatobj = new Float(c);

// double data type

double d = 250.5;

// Wrapping around Double object

Double doubleobj = new Double(d);

// char data type

char e='a';

// wrapping around Character object

Character charobj=e;

// printing the values from objects

System.out.println("Values of Wrapper objects (printing as objects)");
System.out.println("Byte object byteobj: " + byteobj);
System.out.println("Integer object intobj: " + intobj);
System.out.println("Float object floatobj: " + floatobj);
System.out.println("Double object doubleobj: " + doubleobj);
System.out.println("Character object charobj: " + charobj);

// objects to data types (retrieving data types from objects)

// unwrapping objects to primitive data types

Object Oriented Programming - OOPs 2

Wrapper Classes,Scanner Class and Array Class Lab # 10

byte bv = byteobj;
int iv = intobj;
float fv = floatobj;
double dv = doubleobj;
char cv = charobj;

// printing the values from data types

System.out.println("Unwrapped values (printing as data types)");
System.out.println("byte value, bv: " + bv);
System.out.println("int value, iv: " + iv);
System.out.println("float value, fv: " + fv);
System.out.println("double value, dv: " + dv);
System.out.println("char value, cv: " + cv);
}
}

Output:

Byte, Short, Integer, and Long:

The Byte, Short, Integer, and Long classes are wrappers for byte, short,
int, and long integer types, respectively. Their constructors are shown
here:

Byte(byte num) Byte(String str) throws NumberFormatException

Short(short num) Short(String str) throws NumberFormatException

Integer(int num) Integer(String str) throws NumberFormatException

Long(long num) Long(String str) throws NumberFormatException

Object Oriented Programming - OOPs 3

Wrapper Classes,Scanner Class and Array Class Lab # 10

The throw keyword in Java is used to explicitly throw an exception from a

method or any block of code. We can throw either checked or unchecked
exception. The throw keyword is mainly used to throw custom exceptions,
this will be explained in detail later.

As you can see, these objects can be constructed from numeric values or
from strings that contain valid whole number values. The methods defined
by these classes are shown in given Table. They define methods for
converting strings back into integers. Variants of these methods allow you
to specify the radix, or numeric base, for conversion. Common radixes are
2 for binary, 8 for octal, 10 for decimal, and 16 for hexadecimal. The
following constants are defined:
MIN_VALUE Minimum value
MAX_VALUE Maximum value
TYPE The Class object for byte, short, int, or long

Object Oriented Programming - OOPs 4

Wrapper Classes,Scanner Class and Array Class Lab # 10

Character Class:

The Character class of the java.lang package wraps a value of the primitive

datatype char. It offers a number of useful class (i.e., static) methods for
manipulating characters. You can create a Character object with the
Character constructor.

Following are the notable methods of the Character class.

class CharacterClassExample {
public static void main(String[] args) {
char ch1, ch2;
ch1 = '9';
ch2 = 'V';

boolean b1, b2;

b1 = Character.isDigit(ch1);
b2 = Character.isDigit(ch2);

Object Oriented Programming - OOPs 5

Wrapper Classes,Scanner Class and Array Class Lab # 10

String str1 = ch1 + " is a digit is " + b1;

String str2 = ch2 + " is a digit is " + b2;
System.out.println( str1 );
System.out.println( str2 );
}
}

Output:

10.2 SCANNER CLASS

The java.util.Scanner class defines objects that use regular expressions to

scan character input from a variety of sources and present the input as a
sequence of tokens of various primitive types or as strings. For example,
you can use a Scanner object to read data values of various types from a
file or a stream, including the standard stream System.in.

Creating Scanner Objects:

You can create a Scanner object by passing an object encapsulating the
source of the data to be scanned to a Scanner constructor.

Let’s take the obvious example of a source from which you might want to
interpret data. To obtain a Scanner object that will scan input from the
keyboard, you could use the following statement:

java.util.Scanner keyboard = new java.util.Scanner(System.in);

Scanner Class Methods:

Below is a list of some of the methods of the Scanner class.

Object Oriented Programming - OOPs 6

Wrapper Classes,Scanner Class and Array Class Lab # 10

Object Oriented Programming - OOPs 7

Wrapper Classes,Scanner Class and Array Class Lab # 10

Using a Scanner:
Here’s a simple example that just reads a variety of input from the
standard input stream and displays what was read:

import java.util.Scanner;
class TryScanner {
public static void main(String[] args) {
Scanner kbScan = new Scanner(System.in); // Create the scanner
int selectRead = 1; // Selects the read operation
int MAXTRIES = 3; // Maximum attempts at input
int tries = 0; // Number of input attempts
while(tries<MAXTRIES) {

Object Oriented Programming - OOPs 8

Wrapper Classes,Scanner Class and Array Class Lab # 10

switch(selectRead) {
case 1:
System.out.println("Enter an Integer:");
System.out.println("You entered: "+ kbScan.nextLong());
++selectRead; // Select next read operation
tries = 0; // Reset count of tries
case 2:
System.out.print("Enter a floating-point value: ");
System.out.println("You entered: "+ kbScan.nextDouble());
++selectRead; // Select next read operation
tries = 0; // Reset count of tries
case 3:
System.out.print("Enter a boolean value(true or false): ");
System.out.println("You entered: "+ kbScan.nextBoolean());
}
break;
}
}
}

Output:

10.3 ARRAYS CLASS

The Arrays class in java.util package is a part of the Java Collection

Framework. This class provides static methods to dynamically create and
access Java arrays. It consists of only static methods and the methods of
Object class. The methods of this class can be used by the class name itself.

class Hierarchy:
java.lang.Object
↳ java.util.Arrays
Class Declaration:
public class Arrays
extends Object
Syntax to use Array:
Arrays.<function name>;

Object Oriented Programming - OOPs 9

Wrapper Classes,Scanner Class and Array Class Lab # 10

Need for the Java-Arrays Class:

There are often times when loops are used to do some tasks on an array like:
 Fill an array with a particular value.
 Sort an Arrays.
 Search in an Arrays.
 And many more.
Arrays class provides several static methods that can be used to perform
these tasks directly without the use of loops.

Methods in Java Array:

The Arrays class of the java.util package contains several static methods that
can be used to fill, sort, search, etc in arrays. These are:

Following program is for returning a fixed-size list backed by the specified

Arrays using Arrays.asList().

// Java program to demonstrate

// Arrays.asList() method

import java.util.Arrays;

public class Main {

public static void main(String[] args)
{

// Get the Array

int intArr[] = { 10, 20, 15, 22, 35 };

// To convert the elements as List

System.out.println("Integer Array as List: "
+ Arrays.asList(intArr));
}
}

Object Oriented Programming - OOPs 10

Wrapper Classes,Scanner Class and Array Class Lab # 10

Output:

LAB TASK

1. Write a program to take the integer value from the user and convert an
integer into binary, hexadecimal, and octal with the help of methods
defined in wrapper class of Integer and Long.

2. Write a program to display the sign of the Zodiac corresponding to a

birth date entered through the keyboard.

3. Write a program to take 10 integer values from the user and display the
odd values with their indexes and copy of the original array by using
the search and copy method respectively, define in array class.

Example:
Array= {11,22,33,44,55,66,77,88,99,111}

Sample Output:
11 found at index= 1
33 found at index= 3
55 found at index= 5
77 found at index= 7
111 found at index= 9

Array= {11,22,33,44,55,66,77,88,99,111}

Object Oriented Programming - OOPs 11