Collection and framework

ARRAYS
 The ARRAY class provides various methods that are useful when
working with arrays.
 The asList() method returns a List that is backed by a specified
array.
static List asList(Object []array)

binarySearch():
 To find a specified value in the given array.
 The following methods are used to apply the binarySearch(),
 static int binarySearch(byte[] array,byte value)
 static int binarySearch(char[] array,char value)
 static int binarySearch(double[] array,double value)
 static int binarySearch(int[] array,int value)
 static int binarySearch(Object[] array,Object value)

equals():
 To check whether two arrays are equal.
 The following methods are used to apply the equal(),
 static boolean equals(boolean array1[],boolean array2[])
 static boolean equals(byte array1[],byte array2[])
 static boolean equals(char array1[],char array2[])
 static boolean equals(double array1[],double array2[])
 static boolean equals(int array1[],int array2[])

Fill()
 Assigns a value to all elements in an array.
 Fills with a specified value.
 It has two versions,
 First version,
Fills an entire array,
 static void fill(boolean array[],boolean value)
 static void fill(byte array[],byte value)
 static void fill(char array[],char value)
 static void fill(double array[],double value)

Contd,
 Second version,
 Assigns a value to a subset of an array.
 static void fill(boolean array[],int start,int end,boolean value)
 static void fill(byte array[],int start,int end,byte value)
 static void fill(char array[],int start,int end,char value)
 static void fill(double array[],int start,int end,double value)
 static void fill(int array[],int start,int end,int value)
 static void fill(Object array[],int start,int end,Object value)
 Here value is assigned to the elements in array from position start to end
position.

Sort()
 Sorts an array in ascending order.
 Two versions,
 First version,
 Sorts entire array,
 Static void sort(byte array[])
 Static void sort(char array[])
 Static void sort(double array[])
 Static void sort(int array[])
 Static void sort(Object array[])

Contd,
 Second version,
 Specify a range within an array that you want to sort.
 Static void sort(byte array[],int start,int end)
 Static void sort(char array[],int start,int end)
 Static void sort(double array[],int start,int end)
 Static void sort(int array[],int start,int end)
 Static void sort(Object array[],int start,int end)

// Demonstrate Arrays
import java.util.*;
class ArraysDemo {
public static void main(String args[]) {
// allocate and initialize array
int array[] = new int[10];
for(int i = 0; i < 10; i++)
array[i] = -3 * i;
// display, sort, display
System.out.print("Original contents: ");
display(array);
Arrays.sort(array);
System.out.print("Sorted: ");
PROGRAM

display(array);
// fill and display
Arrays.fill(array, 2, 6, -1);
System.out.print("After fill(): ");
display(array);
// sort and display
Arrays.sort(array);
System.out.print("After sorting again: ");
display(array);
// binary search for -9
System.out.print("The value -9 is at location ");

int index = Arrays.binarySearch(array, -9);
System.out.println(index);
}
static void display(int array[]) {
for(int i = 0; i < array.length; i++)
System.out.print(array[i] + " ");
System.out.println("");
}
}

OUTPUT:
Original contents: 0 -3 -6 -9 -12 -15 -18 -21 -24 -27
Sorted: -27 -24 -21 -18 -15 -12 -9 -6 -3 0
After fill(): -27 -24 -1 -1 -1 -1 -9 -6 -3 0
After sorting again: -27 -24 -9 -6 -3 -1 -1 -1 -1 0
The value -9 is at location 2

STACK
 Stack is a subclass of Vector that implements a standard last-in,
first-out stack.
 Stack only defines the default constructor, which creates an
empty stack.
 To put an object on the top of the stack, call push( ).
 To remove and return the top element, call pop( ).
 An EmptyStackException is thrown if you call pop( ) when the
invoking stack is empty.

Method Description
boolean empty( ) Returns true if the stack is empty, and returns false
if the stack contains elements.
Object peek( ) Returns the element on the top of the stack, but
does not remove it.
Object pop( ) Returns the element on the top of the stack,
removing it in the process.
Object push(Object element) Pushes element onto the stack. element is also
returned.
int search(Object element) Searches for element in the stack. If found, its offset
from the top of the stack is returned. Otherwise, –1
is returned.

PROGRAM
// Demonstrate the Stack class.
import java.util.*;
class StackDemo {
static void showpush(Stack st, int a) {
st.push(new Integer(a));
System.out.println("push(" + a + ")");
System.out.println("stack: " + st);
}
static void showpop(Stack st) {
System.out.print("pop -> ");
Integer a = (Integer) st.pop();
System.out.println(a);
}

Stack st = new Stack();
showpush(st, 42);
showpush(st, 66);
showpush(st, 99);
showpop(st);
showpop(st);
showpop(st);
try {
showpop(st);
} catch (EmptyStackException e) {
System.out.println("empty stack");
}
}
}

Output:
stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

MAPS
 A map is an object that stores associations between
keys and values or key/value.
 A key must be unique and value may be duplicated.
 With help of key, value can be found easily.
 Some maps accept NULL for both key and value but not all.

Map Interface
 Map interfaces define the character and nature of maps.
 Following are interfaces support maps,
INTERFACE DESCRIPTION
Map Maps unique keys to values
Map.Entry Describes an element in a map. This is
an inner class of map.
SortedMap Extends map so that the keys are
maintained in ascending order.

Map Interface
 Map interface maps unique keys to values.
 A key is an object that is used to retrieve a value.
 Can store key and values into the map object.
 After the value is stored, it can retrieve by using its key.
 NoSuchElementException- it occurs when no items exist in
the invoking map.
 ClassCastException –it occurs when object is incompatible
with the elements.

Map Interface
 NullPointerException- it occurs when an attempt is made to
use a NULL object.
 UnsupportedOperationException- it occurs when an
attempt is made to change unmodifiable map.
 Map has two basic operations:
 get()– passing the key as an argument, the value
is returned.
 put()-it used to put a value into a map.

Method Description
void clear( ) Removes all key/value pairs from the
invoking map.
boolean containsKey(Object k) Returns true if the invoking map contains k
as a key. Otherwise, returns false.
Set entrySet( ) Returns a Set that contains the entries in the
map. The set contains objects of type
Map.Entry. This method provides a set-
view of the invoking map.
Object get(Object k) Returns the value associated with the key k.
Object put(Object k, Object v) Puts an entry in the invoking map,
overwriting any previous value associated
with the key. The key and value are k and v,
respectively. Returns null if the key did not
already exist. Otherwise, the previous value
linked to the key is returned.

Map.Entry Interfaces
 Map.entry interface enables to work with a map
entry.
 Recall entrySet() method declared by Map interface
returns a set containing the map entries.
 Each of these elements is a Map.Entry object.

SortedMap Interface
 Sorted map interface extends Map. It ensures that the entries
are maintained in ascending key order.
 Sorted map allow very efficient manipulations of
submaps(subset of maps).
 To obtain submaps use,
 headMap()
 tailMap()
 subMap()

SortedMap Interface
Class Description
Object firstKey( ) Returns the first key in the
invoking map.
Object lastKey( ) Returns the last key in the
invoking map.
SortedMap headMap(Object end) Returns a sorted map for those
map entries with keys that are
less than end.
SortedMap subMap(Object start, Object end) Returns a map containing those
entries with keys that are greater
than or equal to start and less
than end.
SortedMap tailMap(Object start) Returns a map containing those
entries with keys that are greater
than or equal to start

Map Classes
Class Description
AbstractMap Implements most of the Map interface.
EnumMap Extends AbstractMap for use with enum keys.
HashMap Extends AbstractMap to use a hash table.
TreeMap Extends AbstractMap to use a tree.
WeakHashMap Extends AbstractMap to use a hash table with
weak keys.
LinkedHashMap Extends HashMap to allow insertion-order
iterations.
IdentityHashMap Extends AbstractMap and uses reference equality
when comparing documents.

HASHMAP CLASS
 The HashMap class uses a hash table to implement the Map interface.
 The HashMap class extends AbstractMap and implements the Map
interface.
 The following constructors are defined:
 HashMap( )- constructs a default hash map.
 HashMap(Map m)- initializes the hash map by using the
elements of m.
 HashMap(int capacity)- initializes the capacity of the hash map
to capacity.
 HashMap(int capacity, float fillRatio)- initializes both the capacity
and fill ratio of the hash map by using its arguments.

PROGRAM
import java.util.*;
class HashMapDemo {
// Create a hash map.
HashMap hm = new HashMap();
// Put elements to the map
hm.put("John Doe", new
Double(3434.34));
hm.put("Tom Smith", new
Double(123.22));
hm.put("Jane Baker", new
Double(1378.00));
hm.put("Tod Hall", new Double(99.22));
hm.put("Ralph Smith", new Double(-
19.08));
//Get an iterator
Iterator i = set.Iterator();
While(i.hasNext()) {
Map.Entry me=(Map.Entry)i.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
System.out.println();
// Deposit 1000 into John Doe's account.
double balance = ((Double)hm.get("John
Doe")) .doubleValue();
hm.put("John Doe",new Double( balance +
1000));
System.out.println("John Doe's new
balance: " +
hm.get("John Doe")); }}

OUTPUT:
Ralph Smith: -19.08
Tom Smith: 123.22
John Doe: 3434.34
Tod Hall: 99.22
Jane Baker: 1378.0
John Doe’s new balance: 4434.34

TREEMAP CLASS
 The treemap class implements the Map interface by using a tree.
 A treemap provides an efficient means of storing key/value pairs
in sorted order and allows rapid retrieval.

TREEMAP CLASS
Constructors Description
TreeMap( ) constructs an empty tree map that will be
sorted by using the natural order of its keys.
TreeMap(Map m) initializes a tree map with the entries from
m, which will be sorted by using the natural
order of the keys.
TreeMap(SortedMap sm) initializes a tree map with the entries from
sm, which will be sorted in the same order
as sm.

Tree Map Demo Program
import java.util.*;
class TreeMapDemo {
// Create a tree map.
TreeMap<String, Double> tm = new TreeMap<String, Double>();
// Put elements to the map.
tm.put("John Doe", new Double(3434.34));
tm.put("Tom Smith", new Double(123.22));
tm.put("Jane Baker", new Double(1378.00));
tm.put("Tod Hall", new Double(99.22));
tm.put("Ralph Smith", new Double(-19.08));
// Get a set of the entries.

Set<Map.Entry<String, Double>> set = tm.entrySet();
// Display the elements.
for(Map.Entry<String, Double> me : set) {
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
System.out.println();
// Deposit 1000 into John Doe's account.
double balance = tm.get("John Doe");
tm.put("John Doe", balance + 1000);
System.out.println("John Doe's new balance: " +
tm.get("John Doe"));
}
}

Output:
Jane Baker: 1378.0
John Doe: 3434.34
Ralph Smith: -19.08
Todd Hall: 99.22
Tom Smith: 123.22
John Doe’s current balance: 4434.34

LinkedHashMap Class
 LinkedHashMap extends HashMap. It maintains a linked list
of the entries in the map, in the order in which they were
inserted.
 It allows insertion-order iteration over the map. i.e.,when
iterating through a collection-view of a LinkedHashMap, the
elements will be returned in the order in which they were
inserted.
 Can create a LinkedHashMap that returns its elements in the
order in which they were last accessed

LinkedHashMap Constructors:
Constructors Description
LinkedHashMap( ) constructs a default LinkedHashMap.
LinkedHashMap(Map m) initializes the LinkedHashMap with the
elements from m.
LinkedHashMap(int capacity) initializes the capacity.
LinkedHashMap(int capacity, float fillRatio) initializes both capacity and fill ratio. The
meaning of capacity and fill ratio are the same
as for HashMap. The default capacity is 16.
The default ratio is 0.75.
LinkedHashMap(int capacity, float fillRatio,
boolean Order)
allows you to specify whether the elements
will be stored in the linked list by insertion
order, or by order of last access. If Order is
true, then access order is used. If Order is

The EnumMap Class
 EnumMap extends AbstractMap and implements Map. It is
specifically for use with keys of an enum type.
 EnumMap defines the following constructors:
 EnumMap(Class Type)- creates an empty EnumMap of type
kType.
 EnumMap(Map m)- creates anEnumMap map that contains the
same entries as m.
 EnumMap(EnumMap em)- creates an EnumMap initialized with
the values in em.

REFERENCES:
 JavaTheCompleteReference,5TH ed.
 Introduction.to.Java.Programming.8th.Edition.
 www.Wikipedia.org./java/collections

Collection and framework

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Collection and framework (20)

Recently uploaded (20)

Collection and framework