Search This Blog

Sunday 10 May 2015

HashMap example in Java


HashMap example in Java

The HashMap class uses a hash table to implement the Map interface. This allows the execution time of basic operations, such as get() and put(), to remain constant even for large sets.
The following constructors are defined: HashMap( )
HashMap(Map m)
HashMap(int capacity)
HashMap(int capacity, float fillRatio)

The first form constructs a default hash map. The second form initializes the hash map by using the elements of m. The third form initializes the capacity of the hash map to capacity. The fourth form initializes both the capacity and fill ratio of the hash map by using its arguments. The meaning of capacity and fill ratio is the same as for HashSet, described earlier.
HashMap implements Map and extends AbstractMap. It does not add any methods of its own. You should note that a hash map does not guarantee the order of its elements. Therefore, the order in which elements are added to a hash map is not necessarily the order in which they are read by an iterator.
The following program illustrates HashMap. It maps names to account balances. Notice how a set-view is obtained and used.
 


import java.util.*;
class HashMapDemo {
public static void main(String args[]) {
// Create a hash map
HashMap hm = new HashMap();
// Put elements to the map
hm.put("Raj", new Double(3434.34));
hm.put("Arun", new Double(123.22));
hm.put("Avi", new Double(1378.00));
hm.put("Paresh", new Double(99.22));
hm.put("Jonan", new Double(-19.08));
// Get a set of the entries
Set set = hm.entrySet();
// Get an iterator
Iterator i = set.iterator();
// Display elements
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("Raj", new Double(balance + 1000));
System.out.println("Raj's new balance: " +
hm.get("Raj"));
}
}


Output from this program is shown here:
Raj: -19.08 
Arun: 123.22
Avi: 3434.34
Paresh: 99.22 

Jonan: 1378.0
Raj's current balance: 4434.34

Thursday 7 May 2015

Java Collection Introduction

Java Collection Introduction


 A collection is an object that contains a group of objects.
Each object in a collection is called an element. Every collection contains a group of objects.
Each different type of collection manages their elements in its own way.
The Collections Framework consists of interfaces, implementation classes, and some utility classes to handle most types of collections.
Java Collections are designed to work only with objects.
All collection classes in Java are declared generic.

Architecture of the Collection Framework

The Java Collections Framework has three main components:
  • Interfaces
  • Implementation Classes
  • Algorithm Classes
An interface in Java Collections Framework represents a specific type of collection.
For example, the List interface represents a list. The Set interface represents a set. The Map interface represents a map.
The data structures defined by interfaces rather than a class has the following advantages: we can provide different implementation for the same interfaces.
The Java Collections Framework also provides implementations of collection interfaces.
We should always try to define the type of the class using interfaces, rather than using their implementation classes.
The following code shows how to use the implementation class ArrayList to create a list:
List<String> names = new ArrayList<>();
If possible we should avoid using the following way to create a list object.
ArrayList<String> names = new ArrayList<>();



Operations

We can perform different actions on a collection.
  • searching through a collection
  • converting a collection of one type to another type
  • copying elements from one collection to another
  • sorting elements of a collection in a specific order