In all cases, arguments given to methods for these purposes need not fall within the indicated ranges; for example, a date may be specified as January 32 and is interpreted as meaning February 1.

	Let us see the class stucture for the above mentioned facts.

	public  class  java.util.Date extends  java.lang.Object
	{
			// 	Constructors
			public Date();
			/*	Allocates a Date object and initializes it so that it represents the time at which it was allocated measured to the nearest millisecond. 	 
			*/
			public Date(int  year, int  month, int  date);
			/*	Allocates a Date object and initializes it so that it represents midnight, local time, at the beginning of the day specified by the year, month, and date arguments. 
			*/	 
			public Date(int  year, int  month, int  date,int  hrs, int  min);
			/*	Allocates a Date object and initializes it so that it represents the specified hour and minute, local time, of the date specified by the year, month, and date arguments.
			*/
			public Date(int  year, int  month, int  date,int  hrs, int  min, int  sec);
			/*	Allocates a Date object and initializes it so that it represents the specified hour, minute, and second, local time of the date specified by the year, month, and date arguments.
			*/
			public Date(long  date); 
			/*	Allocates a Date object and initializes it to represent the specified number of milliseconds since January 1, 1970, 00:00:00GMT.
			*/
			public Date(String  s);
			/*	Allocates a Date object and initializes it that that it represents the date and time indicated by the string s, which is interpreted as if by the parse method.
			*/
				// Methods
			public boolean after(Date  when); 
			public boolean before(Date  when);	 
			public boolean equals(Object  obj);	 
			public int getDate();	 
			public int getDay(); 
			public int getHours();	 
			public int getMinutes();	 
			public int getMonth(); 
			public int getSeconds();	 
			public long getTime(); 
			public int getTimezoneOffset(); 
			public int getYear();	 
			public int hashCode();	 
			public static long parse(String  s); 
			public void setDate(int  date);	 
			public void setHours(int  hours);	 
			public void setMinutes(int  minutes); 
			public void setMonth(int  month); 
			public void setSeconds(int  seconds);	 
			public void setTime(long  time);	 
			public void setYear(int  year);	 
			public String toGMTString();	 
			public String toLocaleString();	 
			public String toString();	 
			public static long UTC(int  year, int  month, int  date,int  hrs, int  min, int  sec);
		}

	The methods are listed in Table 3.2.

Table 3.2

Table 3.2 (Contd..)

Class Dictionary

The Dictionary class is the abstract parent of any class, such as Hashtable which maps keys to values. Any non-null object can be used as a key and as a value.

	public  abstract  class  java.util.Dictionary extends  java.lang.Object   
	{
			// 	Constructors
		public Dictionary();
		//	The default constructor. 

		// 	Methods
		public abstract Enumeration elements(); 
		public abstract Object get(Object  key);	 
		public abstract boolean isEmpty();	 
		public abstract Enumeration keys();	 
		public abstract Object put(Object  key, Object  value);
		public abstract Object remove(Object  key);	 
		public abstract int size(); 
	}

 	Methods are described in Table 3.3.

Table 3.3

Class Hashtable

This class implements a hash table, which maps keys to values. Any non-null object can be used as a key or as a value.To successfully store and retrieve objects from a hash table, the objects used as keys must implement the hashCode method and the equals method.

An instance of Hashtable has two parameters that affect its efficiency: its capacity and its load factor. The load factor should be between 0.0 and 1.0. When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the capacity is increased by calling the rehash method. Larger load factors use memory more efficiently, at the expense of larger expected time per lookup.

If many entries are to be made into a Hashtable, creating it with a sufficiently large capacity may allow the entries to be inserted more efficiently than letting it perform automatic rehashing as needed to grow the table.

		As an example, following is a code to create a hashtable of numbers. It uses the names of the numbers as keys :
				Hashtable  numbers  =  new  Hashtable();
				numbers.put("one",  new  Integer(1));
				numbers.put("two",  new  Integer(2));
				numbers.put("three",  new  Integer(3));
		
		To retrieve a number use the following code:

				Integer  n  =  (Integer)numbers.get("two");
				if  (n  !=  null)  {
					System.out.println("two  =  "  +  n);
				}

		Now, let us see the class structure.

		
		public  class  java.util.Hashtable 	extends  java.util.Dictionary   
		implements java.lang.Cloneable   
		{
				// 	Constructors
			public Hashtable();	 
			//	Constructs a new empty hashtable.
			public Hashtable(int  initialCapacity);
			/*	Constructs a new, empty hash table with the specified initial capacity. 
				Throws : IllegalArgumentException, if the initial capacity is less than or equal to zero.
			*/
			public Hashtable(int  initialCapacity, float  loadFactor);
			/*	Constructs a new, empty hashtable with the specified initial capacity and the specified load factor.
				Throws : IllegalArgumentException, if the initial capacity is less than or equal to zero, or if the load factor is less than or equal to zero.
			*/
				// 	Methods
			public void clear();	 
			public Object clone();	 
			public boolean contains(Object  value);	 
			public boolean containsKey(Object  key);	 
			public Enumeration elements();	 
			public Object get(Object  key);	 
			public boolean isEmpty();	 
			public Enumeration keys(); 
			public Object put(Object  key, Object  value); 
			protected void rehash();	 
			public Object remove(Object  key);	 
			public int size();	 
			public String toString(); 
		}

	Methods are stated in Table 3.4.

Table 3.4

.

Class Observable

This class represents an observable object, or "data" in the model-view paradigm. It can be subclassed to represent an object that the application wants to have observed.

An observable object can have one or more observers After an observerable instance changes, an application calling the Observerable's notifyObservers method causes all of its observers to be notified of the change by a call to their update method.

	The class structure is as shown below :

	public  class  java.util.Observable
    					extends  java.lang.Object  
	{
        	// 	Constructors
    	public Observable();	
		//	The default constructor. 

        	// 	Methods
    	public void addObserver(Observer  o);	 
    	protected void clearChanged();	 
    	public int countObservers();	 
    	public void deleteObserver(Observer  o);	 
    	public void deleteObservers();	 
    	public boolean hasChanged();	 
    	public void notifyObservers(); 
    	public void notifyObservers(Object  arg);	 
    	protected void setChanged();	 
	}
	
	Methods are described in Table 3.5.

Table 3.5

Class Properties

The Properties class represents a persistent set of properties. The Properties can be saved to a stream or loaded from a stream. Each key and and its corresponding value in the property list is a string.

A property list can contain another property list as its "defaults"; this second property list is searched if the property key is not found in the original property list.

	public  class  java.util.Properties
						extends  java.util.Hashtable  
	{
			// 	Member elements
		protected Properties defaults;
		//	A property list which contains contains default values for any keys not found in this property list. 	 

			// 	Constructors
		public Properties();	 
		//	Creates an empty property list with no default values.
		public Properties(Properties  defaults);
		//	Creates an empty property list with the specified defaults. 	 

			// 	Methods
		public String getProperty(String  key);	 
		public String getProperty(String  key, String  defaultValue);  
		public void list(PrintStream  out);	 
		public void load(InputStream  in);	 
		public Enumeration propertyNames();	 
		public void save(OutputStream  out, String  header);	 
	}
	Methods are listed in Table 3.6.

Table 3.6

Method	Description
getProperty(String key)	Searches for the property with the specified key in this property list. Returns: the value in this property list with the specified key value. If the key is not found in this property list, the default property list and its defaults, recursively, are then checked. The method returns null if the property is not found.
getProperty(String key, String defaultValue)	Searches for the property with the specified key in this property list. Returns: the value in this property list with the specified key value. If the key is not found in this property list, the default property list, and its defaults, recursively, are then checked. The method returns the default value argument if the property is not found.
list(PrintStream out)	Prints this property list out to the specified output stream. This method is useful for debugging.
load(InputStream in)	Reads a property list from an input stream. Throws : IOException, if an error occurred when reading from the input stream.13
propertyNames()	Returns: An enumeration of all the keys in this property list, including the keys in the default property list.
save(OutputStream out, String header)	Stores this property list to the specified output stream. The string header is printed as a comment at the beginning of the stream.

Class Random

An instance of this class is used to generate a stream of pseudo-random numbers. The class uses a 48-bit seed, which is modified using a linear congruential formula.

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers.

Many applications will find the random method in class Math simpler to use.

	public  class  java.util.Random extends  java.lang.Object   
	{
			// 	Constructors
		public Random();
		//	Creates a new random number generator. Its seed is initialized to a value based on the current time.	 
		public Random(long  seed);	
		//	Creates a new random number generator using a single long seed. 

		// 	Methods
		public double nextDouble();	 
		public float nextFloat();	 
		public double nextGaussian(); 
		public int nextInt(); 
		public long nextLong();	 
		public void setSeed(long  seed); 
	}

	Table 3.7 is to list the methods in  this class.

Table 3.7

Class Stack

The Stack class represents a last-in-first-out (LIFO) stack of objects.

	public  class  java.util.Stack extends  java.util.Vector   
	{
        	// 	Constructors
    	public Stack(); 
		//	Creates a new stack with no elements.

        	// 	Methods
    	public boolean empty();	 
    	public Object peek(); 
    	public Object pop();	 
    	public Object push(Object  item);	 
    	public int search(Object  o);	 
	}
	
	Methods are shown in Table 3.8.

Table 3.8

Class StringTokenizer

The string tokenizer class allows an application to break a string into tokens. The tokenization method is much simpler than the one used by the StreamTokenizer class. The StringTokenizer methods do not distinguish among identifiers, numbers, and quoted strings, not does it recognize and skip comments.

The set of delimiters (the characters that separate tokens) may be specified either at creation time or on a per-token basis.

An instance of StringTokenizer behaves in one of two ways, depending on whether it was created with the return Tokens flag having the value true or false:

If the flag is false, delimiter characters merely serve to separate tokens. A token is a maximal sequence of consecutive characters that are delimiters.

If the flag is true, delimiters characters are considered to be tokens. A token is either one delimiter character, or a maximal sequence of consecutive characters that are not delimiters.

	The following is one example of the use of the tokenizer. The code :

	StringTokenizer  st  =  new  StringTokenizer("I love Java !");
			while  (st.hasMoreTokens())  {
       				println(st.nextToken());
			} 
	Prints the following output  : 
			I
			love
			java
			!

	The class is furnished below :
	
	public  class  java.util.StringTokenizer extends  java.lang.Object  
	implements java.util.Enumeration   
	{
			// 	Constructors
		public StringTokenizer(String  str); 
		/*	Constructs a string tokenizer for the specified string. The tokenizer uses the default delimiter set, which is " \t\n\r", the space character, the tab character, the newline character, and the carriage return character.
		*/
		public StringTokenizer(String  str, String  delim);	
		/*	Constructs a string tokenizer for the specified string. The characters in the delim argument are the delimiters for separating tokens.
		*/ 
		public StringTokenizer(String  str, String  delim,  boolean  returnTokens);
		/*	Constructs a string tokenizer for the specified string. The characters in the delim argument are the delimiters for separating tokens. If the returnTokens flag is true, then the delimiter characters are also returned as tokens. Each delimiter is returned as a string of length one. If the flag is false, the delimiter characters are skipped and only serve as separators between tokens.
		*/

			// 	Methods
		public int countTokens();	 
		public boolean hasMoreElements();	 
		public boolean hasMoreTokens(); 
		public Object nextElement();	 
		public String nextToken(); 
		public String nextToken(String  delim);	 
	}

	Methods are described in Table3.9.

Table 3.9

Class Vector

The Vector class implements a growable array of objects. Like an array, it contains components that can be accessed using an integer index. However, the size of a Vector can grow or shrink as needed to accommodate adding and removing items after the Vector has been created.

Each vector tries to optimize storage management by maintaining a capacity and a capacityIncrement. The capacity is always at least as large as the vector size; it is usually larger because as components are added to the vector, the vector's storage increases in chunks the size of capacityIncrement. An application can increase the capacity of a vector before inserting a large number of components; this reduces the amount of incremental reallocation.

	The class Vector is stated below :

	public  class  java.util.Vector extends  java.lang.Object   
	implements java.lang.Cloneable   
	{
        	// 	Member elements
    	protected int capacityIncrement;
		/*	The amount by which the capacity of the vector is automatically incremented when its size becomes greater than its capacity. If the capacity is 0, the capacity of the vector is doubled each time it needs to grow.
 		*/
    	protected int elementCount;
		//	The number of valid components in the vector. 	 
    	protected Object elementData[]; 
		/*	The array buffer into which the components of the vector are stored. The length of this array buffer is the (current) capacity of the vector.
		*/
        	// 	Constructors
    	public Vector();
		//	Constructs an empty vector.
		public Vector(int  initialCapacity);
		//	Constructs an empty vector. Its initial capacity is the specified argument initialCapacity. 
    	public Vector(int  initialCapacity, int  capacityIncrement);
		//	Constructs an empty vector with the specified capacity and the specified capacity increment.

        	// 	Methods
    	public final void addElement(Object  obj); 
    	public final int capacity();	 
    	public Object clone();	 
    	public final boolean contains(Object  elem); 
    	public final void copyInto(Object  anArray[]); 
    	public final Object elementAt(int  index); 
    	public final Enumeration elements(); 
    	public final void ensureCapacity(int  minCapacity); 
    	public final Object firstElement();	 
    	public final int indexOf(Object  elem);	 
    	public final int indexOf(Object  elem, int  index);	 
    	public final void insertElementAt(Object  obj, int  index);	 
    	public final boolean isEmpty(); 
    	public final Object lastElement();	 
    	public final int lastIndexOf(Object  elem);	 
    	public final int lastIndexOf(Object  elem, int  index);	 
    	public final void removeAllElements();	 
    	public final boolean removeElement(Object  obj);	 
    	public final void removeElementAt(int  index); 
    	public final void setElementAt(Object  obj, int  index);	 
    	public final void setSize(int  newSize); 
    	public final int size();	 
    	public final String toString(); 
    	public final void trimToSize();	 
	}
	
	Methods are decribed in Table 3.10.
		

Table 3.10

Table 3.10 (Contd..)

Interface Enumeration

An object that implements the Enumeration interface generates a series of elements, one at a time. Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a Vector v , the code :

	for  (Enumeration  e  =  v.elements();  e.hasMoreElements();)  
	{        			System.out.println(e.nextElement());
	}  

	Methods are provided to enumerate through the elements of a vector, the keys of a hash table , and the values in a hash table. Enumerations are also used to specify the input streams to a SequenceInputStream.

	public  interface  java.util.Enumeration
	{
        	// Methods
    	public abstract boolean hasMoreElements();	
		//	Returns : true if this enumeration contains more elements; false otherwise. 
    	public abstract Object nextElement();	
		/*	Returns : the next element of this enumeration.  Throws : NoSuchElementException, if the element not found. 
		*/
	}

Interface Observer

A class can implement the Observer interface when it wants to be informed if observable objects changes.

	public  interface  java.util.Observer
	{
        	// 	Methods
    	public abstract void update(Observable  o, Object  arg);
		/*	This method is called whenever the observed object is changed. An application calls an observable object's notifyObservers method  to have all the object's observers notified of the change.
		*/ 	 
	}

Class EmptyStackException

Thrown by methods in the Stack class to indicate that the stack is empty.

	public  class  java.util.EmptyStackException extends  java.lang.RuntimeException{
        	// 	Constructors
    	public EmptyStackException();
		//	Constructs a new EmptyStackException with no detail message. 	
	}

Class NoSuchElementException

Thrown by the nextElement method of an Enumeration to indicate that there are no more elements in the enumeration.

	public  class  java.util.NoSuchElementException extends  java.lang.RuntimeException   
	{
        	// 	Constructors
    public NoSuchElementException();
		//	Constructs a NoSuchElementException with no detail message.
 	public NoSuchElementException(String  s);
		//	Constructs a NoSuchElementException with the specified detail message. 	 
	}