Module 8: The Java Library - A First Look

Consider next the class java.lang.Integer:

• The definition of Integer is:

  public final class Integer extends Number {
    // Constructors.

    // Constants.

    // Class methods.
  
    // Instance methods.
  }

• Number is an abstract class that forces implementation of methods like doubleValue (returns the double version of a number).



• An instance of Integer stores a single integer value.



• An Integer instance is often used to wrap an object around a basic int value.



• Integer has two constructors:

    // Takes in the integer value.
    public Integer (int i);

    // Takes in a String and parses it.
    public Integer (String s)
      throws NumberFormat

 

 

• Useful constants in Integer:

    // Largest possible integer.
    public static final int MAX_VALUE;

    // Smallest (most negative) integer.
    public static final int MIN_VALUE;

• Here are some useful class (static) methods in Integer:

    // Parses a String into an int.
    public static int parseInt (String s)
      throws NumberFormatException;
    // A base or radix can be specified.
    public static int parseInt (String s, int radix)
      throws NumberFormatException;

    // Convert int value to binary (String).
    public static String toBinaryString (int i);
    // Convert to hex.
    public static String toHexString (int i);

    // These are different from the standard toString().
    public static String toString (int i);
    public static String toString (int i, int radix);

• Here are some useful instance methods:

    // Return the int as a double.
    public double doubleValue ();

    // equals() and toString() have
    // been overridden.
    public boolean equals (Object obj);
    public String toString ();

Arbitrary precision using java.math.BigInteger

The class java.math.BigInteger can be used for arbitrary precision arithmetic.

Consider computing the powers of 2 using int's:

• An int is 4 bytes (32 bits)
• Thus, the 32-nd power of 2 cannot be represented in an int.

Here is how BigInteger can be used: (source file)

import java.math.*;

public class TestBig {

  public static void main (String[] argv)
  {
    // Initialize.
    int i = 1;
    BigInteger I = new BigInteger ("1");

    // We will need this constant.
    BigInteger Two = new BigInteger ("2");

    // Compute successive powers of 2.
    for (int j=1; j<=64; j++) {
      i = i * 2;
      I = I.multiply (Two);
      System.out.println ("2 to the power " + j);
      System.out.println ("i = " + i);
      System.out.println ("I = " + I);
      System.out.print ("\n");
    }
  }

}

Note:

• BigInteger has several constructors, one of which takes a String as parameter.



• BigInteger provides instance methods like add, subtract, multiply and divide.



• Here are some other useful methods:

   // Absolute value.
   public BigInteger abs ();

   // Comparison.
   public int compareTo (BigInteger I);

   // Usual arithmetic operations.
   public BigInteger add (BigInteger I);
   public BigInteger subtract (BigInteger I);
   public BigInteger multiply (BigInteger I);
   public BigInteger divide (BigInteger I);
   public BigInteger pow (int a);

   // Operations specific to integers.
   public BigInteger mod (BigInteger I);
   public BigInteger remainder (BigInteger I);

   // Overriding methods from Object.
   public boolean equals (Object obj);
   public String toString ();

   // Recover basic types.
   public int intValue ();
   public long longValue ();
   public double doubleValue ();

In-class Exercise 8.1: Write a program to print out numbers in the Fibonacci sequence. Print out the first 200 numbers in the sequence.

Micro-tutorial on Fibonacci numbers:

import java.util.*;

public class TestDate {

  public static void main (String[] argv)
  {
    Date d = new Date ();
    System.out.println (d);
  }

}

Mon Oct 05 15:46:12 EDT 1998

    Date d2 = new Date ("October 5, 1998");
    System.out.println (d2);

• java.util.Date:
• Date represents a time-date combination using a single long value.
• Use a Date instance usually as a temporary way to pass data from a GregorianCalendar instance to a SimpleDateFormat instance.



• java.util.Calendar:
• Calendar is an abstract class.
• GregorianCalendar is an implementation of this abstract class that you will most likely use.
• However, you will use Calendar for documentation, since inherited constants and methods are described here.
• Instead of using GregorianCalendar below, you can get an instance using Calendar.getInstance().
• Calendar defines an int constant for each month and each day of the week, as well as for other things like AM and PM.
• Example: Calendar.OCTOBER is an int code for October.
• Calendar defines important methods like before, after and set that are inherited by GregorianCalendar.



• java.util.GregorianCalendar:
• GregorianCalendar inherits from the abstract class Calendar.
• See the Calendar documentation for many of GregorianCalendar's methods and constants.
• There are two advantages to using GregorianCalendar over a Calendar instance: it has useful constructors and has a isLeapYear() method.
• However, code can be made system-dependent by using a Calendar instance.

(At this time, only a Gregorian Calendar is implemented in Java).




• java.text.SimpleDateFormat.
• This class inherits from DateFormat but is easier to use.
• It has two main functions: extract a date from a String and converting a date to a String.
• To use it (for either parsing or formatting), you have to specify the format of the String
• Specifying the format consists of using a peculiar code to describe the string format, such as "dd MMM yy".
• The entire code is given in the libary description for SimpleDateFormat.

(You can also use only Calendar and DateFormat, but using them is more complicated).

A simple creation of a date: (source file)

import java.util.*;
import java.text.*;

public class TestDate2 {

  public static void main (String[] argv)
  {
    GregorianCalendar cal = new GregorianCalendar (
       1998,                       // Year
       GregorianCalendar.OCTOBER,  // Month
       5,                          // Day
       14,                         // Hour of day (2 pm)
       30,                         // Minutes
       22                          // Seconds
    );

    // Get a Date instance.
    Date d = cal.getTime ();

    // Print.
    System.out.println (d);
  }

}

Note:

• The constructor was passed everything from year to seconds.



• Other constructors take fewer parameters.



• Alternatively, one of several set methods can be used: (source file)

    GregorianCalendar cal = new GregorianCalendar ();
    cal.set (
       1998,                       // Year
       GregorianCalendar.OCTOBER,  // Month
       5,                          // Day
       14,                         // Hour of day (2 pm)
       30,                         // Minutes
       22                          // Seconds
    );

• Individual fields can be set: (source file)

    GregorianCalendar cal = new GregorianCalendar ();
    cal.set (Calendar.YEAR, 1998);
    cal.set (Calendar.MONTH, Calendar.OCTOBER);
    cal.set (Calendar.DAY_OF_MONTH, 5);
    cal.set (Calendar.HOUR_OF_DAY, 14);  // Use this instead of 
                                         // Calendar.HOUR
    cal.set (Calendar.MINUTE, 30);
    cal.set (Calendar.SECOND, 22);
    cal.set (Calendar.MILLISECOND, 13);

    // Get a Date instance.
    Date d = cal.getTime ();

    // Print.
    System.out.println (d);

• GregorianCalendar does not override toString.



• Hence, a Date is extracted with its getTime() method and printed.

More about GregorianCalendar:

Since creating a pattern string can be complicated, let's do this in small steps:

• We will consider parsing first: a date-time combination is input as a string and we need to tell the parser what the string will look like.



• First, let's look at some examples of pattern strings:
1. "yyyy MM d"
2. "yy, MMM, EEEE, dd, HH, a"



• The first thing to note is that pattern strings contain strange looking codes like yyyy and EEEE.



• Each code specifies what to expect in actual data.



• For example, the pattern string "yyyy MM d" says that input strings will have a 4-digit year, a 2-digit month and a 1-or-2 digit day, with whitespace between.



• Here's a sample input string that matches the pattern: "1998 10 5" (October 5, 1998).



• Note:
• It's important NOT to think that the number of letters have anything to do with length:
• For example, "MM" is a month-number, but "MMM" is a month name like July.



• Here are some sample codes:
• Year:
• yyyy: 4-digit, e.g. 1998.
• yy: 2-digit, e.g., 98.
• Month:
• MMMM: full name, e.g., September.
• MMM: 3-letter name, e.g., Sep.
• MM: 2-digit number, e.g., 09.
• M: 1-or-2 digit number, e.g, 9 or 11.
• Day:
• dd: 2-digit number, e.g., 03.
• d: 1-or-2 digit number, e.g., 3 or 25
• Day of week:
• EEEE: full name, e.g., Wednesday.
• EEE: 3-letter name, e.g., Wed.
• Hour:
• HH: 2-digit number in [0,24], e.g. 16 (4 pm).
• hh: 2-digit number in [0,12], e.g. 04. (Specify am/pm separately).
• AM/PM:
• (Default - nothing written): AM.
• a: specifies PM (Confusing, isn't it?).
• Minutes, seconds, milliseconds:
• mm: 2-digit minute, e.g., 05.
• ss: 2-digit second, e.g., 09.
• SSS: 3-digit millisecond, e.g., 321.



• Now, let us use pattern strings in parsing: (source file)

import java.util.*;
import java.text.*;

public class TestDate7 {

  public static void main (String[] argv)
  {
    // Create three patterns.
    SimpleDateFormat 
      sdf1 = new SimpleDateFormat ("yyyy MMMM dd"),
      sdf2 = new SimpleDateFormat ("EEEE, MMM dd, yyyy"),
      sdf3 = new SimpleDateFormat ("M d HH mm ss");

    // try is required: parse can throw an exception.
    try {
      // In the form "yyyy MMM dd"
      Date d1 = sdf1.parse ("1998 October 06");
      System.out.println ("Date 1: " + d1);

      // In the form "EEEE, MMM dd, yyyy".
      // Note the commas.
      Date d2 = sdf2.parse ("Tuesday, Oct 06, 1998");
      System.out.println ("Date 2: " + d2);

      // In the form "M d HH mm ss"
      Date d3 = sdf3.parse ("12 25 17 30 11");
      System.out.println ("Date 3: " + d3);

      // Let's deliberately provide bad input.
      Date d4 = sdf1.parse ("October 6, 1998");
      System.out.println ("Date 4: " + d4);
    }
    catch (ParseException e) {
      System.out.println (e);
    }
  }

}

Here's what gets printed out:

Date 1: Tue Oct 06 03:00:00 EDT 1998
Date 2: Tue Oct 06 03:00:00 EDT 1998
Date 3: Fri Dec 25 20:30:11 EST 1970
java.lang.NumberFormatException: Octo
        at java.lang.Integer.parseInt(Integer.java)
        at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java)
        at java.text.SimpleDateFormat.parse(SimpleDateFormat.java)
        at java.text.DateFormat.parse(DateFormat.java)
        at TestDate7.main(TestDate7.java:27)

The same pattern strings are also used for output:

• Specify the desired output format using a pattern string.



• Then, use the format method to obtain a String from a Date.



• Example: (source file)

    // Create three patterns.
    SimpleDateFormat 
      sdf1 = new SimpleDateFormat ("yyyy MMMM dd"),
      sdf2 = new SimpleDateFormat ("EEEE, MMM dd, yyyy"),
      sdf3 = new SimpleDateFormat ("M d HH mm ss");

    // try is required: parse can throw an exception.
    try {
      // Format a date from an string.
      Date d1 = sdf1.parse ("1998 October 06");
      System.out.println ("Date 1: " + d1);

      // Next, we will format the output differently.
      String s2 = sdf2.format (d1);
      System.out.println (s2);

      String s3 = sdf3.format (d1);
      System.out.println (s3);
    }
    catch (ParseException e) {
      System.out.println (e);
    }

The result is:

Date 1: Tue Oct 06 03:00:00 EDT 1998
Tuesday, Oct 06, 1998
10 6 00 00 00

Now we are in a position to combine these classes:

• Here are the steps:
1. Parse an input date using a SimpleDateFormat instance.
2. In parsing, it keeps the date internally in a Calendar instance.
3. Obtain this Calendar instance from SimpleDateFormat.
4. Make changes, comparisons etc.
5. Set up a SimpleDateFormat instance with the desired output format.
6. Pass it the Date from the Calendar instance.
7. Call the format method to obtain the output String.



• Example: (source file)

    // Create input and output patterns.
    SimpleDateFormat 
      input_format = new SimpleDateFormat ("yyyy MMMM dd"),
      output_format = new SimpleDateFormat ("EEEE, MMM dd, yyyy, HH mm ss");

    try {
      // Provide a format for input.
      Date d1 = input_format.parse ("1998 October 06");
      System.out.println ("Date: " + d1);

      // Next, wrap a Calendar around a date.
      GregorianCalendar cal = (GregorianCalendar) input_format.getCalendar();

      // Make changes as desired.
      cal.set (Calendar.HOUR_OF_DAY, 17);
      cal.set (Calendar.MINUTE, 22);
      cal.set (Calendar.SECOND, 35);
     
      // Get back the date.
      d1 = cal.getTime();

      // Format the output.
      String s = output_format.format (d1);

      // Print.
      System.out.println (s);
    }
    catch (ParseException e) {
      System.out.println (e);
    }

Miscellany:

• Note that, for date output, you can use SimpleDateFormat to move the day ahead of the month (British style).



• As an alternative to SimpleDateFormat, you can use a DateFormat instance directly:
• DateFormat is an abstract class.
• However, you can get an instance by calling one of several static methods, e.g.,

   public static final DateFormat getDateTimeInstance ();

• The advantage is that several "standard" formats have been defined for you:
• There are 5 pre-defined styles for dates and 5 styles for times
• These are specified using 5 constants: DateFormat.DEFAULT, DateFormat.FULL, DateFormat.LONG, DateFormat.MEDIUM, DateFormat.SHORT.
• For example: (source file)

    // Create a date.
    GregorianCalendar cal = new GregorianCalendar (
       1998,                       // Year
       GregorianCalendar.OCTOBER,  // Month
       5,                          // Day
       14,                         // Hour of day (2 pm)
       30,                         // Minutes
       22                          // Seconds
    );

    // Extract the date.
    Date d = cal.getTime();

    // Use the default format.
    DateFormat def = DateFormat.getDateInstance (DateFormat.DEFAULT);
    String s = def.format (d);
    System.out.println ("DEFAULT: " + s);

    // The full format.
    DateFormat full = DateFormat.getDateInstance (DateFormat.FULL);
    s = full.format (d);
    System.out.println ("FULL: " + s);

    // The long format.
    DateFormat lg = DateFormat.getDateInstance (DateFormat.LONG);
    s = lg.format (d);
    System.out.println ("LONG: " + s);

    // Medium and default are the same.
    DateFormat med = DateFormat.getDateInstance (DateFormat.MEDIUM);
    s = med.format (d);
    System.out.println ("MEDIUM: " + s);

    // Short format.
    DateFormat sh = DateFormat.getDateInstance (DateFormat.SHORT);
    s = sh.format (d);
    System.out.println ("SHORT: " + s);

Here's the output:

DEFAULT: 05-Oct-98
FULL: Monday, October 5, 1998
LONG: October 5, 1998
MEDIUM: 05-Oct-98
SHORT: 10/5/98




• The Locale class is used to accomodate local custom in formatting:
• Dates and times can be output according to various local conventions.
• Various countries (only a few, actually) are represented by constants in java.util.Locale.
• Examples: Locale.JAPAN, Locale.GERMANY.
• These constants can be passed to a DateFormat instance.
• Example: (source file)

    // Create a date.
    GregorianCalendar cal = new GregorianCalendar (
       1998,                       // Year
       GregorianCalendar.OCTOBER,  // Month
       5,                          // Day
       14,                         // Hour of day (2 pm)
       30,                         // Minutes
       22                          // Seconds
    );

    // Extract the date.
    Date d = cal.getTime();

    DateFormat usa = DateFormat.getDateInstance (DateFormat.FULL,
                                                Locale.US);
    String s = usa.format (d);
    System.out.println ("USA: " + s);

    DateFormat uk = DateFormat.getDateInstance (DateFormat.FULL, 
                                                Locale.UK);
    s = uk.format (d);
    System.out.println ("UK: " + s);

    DateFormat france = DateFormat.getDateInstance (DateFormat.FULL, 
                                                Locale.FRANCE);
    s = france.format (d);
    System.out.println ("FRANCE: " + s);

    DateFormat germany = DateFormat.getDateInstance (DateFormat.FULL, 
                                                Locale.GERMANY);
    s = germany.format (d);
    System.out.println ("GERMANY: " + s);

This prints out:

USA: Monday, October 5, 1998
UK: Monday, 5 October 1998
FRANCE: lundi, 5 octobre 1998
GERMANY: Montag, 5. Oktober 1998

• Timing code execution:
• You can obtain execution times by obtaining the system time in milliseconds before and after a piece of code.
• Example: (source file)

    long start = System.currentTimeMillis ();
    for (int i=1; i<=100000; i++) {
      int j = i*i;
    }
    long stop = System.currentTimeMillis ();
    System.out.println ("Time taken: " + (stop-start));

In-Class Exercise 8.2: Use class GCal above (in this file) and the complete() method to find all years this century in which October 7 falls on a Wednesday. Print the years in reverse chronological order.

    for (int i=0; i<=1000; i+=200) {
      int sqr = i * i;
      double root = Math.sqrt (i);
      System.out.println ("The square of " + i + " is " + sqr +
                          " and the square root is " + root);

The square of 0 is 0 and the square root is 0.0
The square of 200 is 40000 and the square root is 14.142135623730951
The square of 400 is 160000 and the square root is 20.0
The square of 600 is 360000 and the square root is 24.49489742783178
The square of 800 is 640000 and the square root is 28.284271247461902
The square of 1000 is 1000000 and the square root is 31.622776601683793

class EasyFormat {

  // Pad blanks as required (for both int's and double's).
  static String pad_blanks (String s, int target_len, boolean is_int)
  {
    int slen = s.length();

    // No decimal point to worry about with int's.
    if (is_int) {
      if (slen >= target_len) 
        return s;
      // Otherwise we pad from front
      for (int i=1; i <= target_len-slen; i++)
        s = ' ' + s;
      return s;
    }

    // Otherwise check up to decimal point
    int i = s.indexOf ('.');
    if ((i < 0) || (i >= slen)) {
      System.out.println ("ERR: pad_blanks: no decimal point");
      System.exit(1);
    }
    if (i+1 >= target_len) 
      return s;

    // Otherwise, pad with blanks
    for (int j=1; j < =target_len-(i+1); j++)
      s = ' ' + s;
    return s;
  }

  // Format integers.
  public static String format (long i, int width) 
  {
    DecimalFormat df_i = new DecimalFormat ("#");    
    String s_i = df_i.format (i);
    s_i = pad_blanks (s_i, width, true);
    return s_i;
  }

  // Format double's.
  public static String format (double d, int before_dec_pt, 
                                    int after_dec_pt) 
  {
    // Use '#' symbols before decimal point.
    String s = "";
    for (int i=1; i < before_dec_pt; i++)
      s = s + '#';

    // Force a zero for numbers less than 1.0
    s = s + "0.";

    // Include zeroes as specified by width.
    for (int i=1; i < =after_dec_pt; i++)
      s = s + '0';

    DecimalFormat df_d = new DecimalFormat (s);    
    String s_d = df_d.format (d);

    // Pad blanks.
    s_d = pad_blanks (s_d, before_dec_pt, false);
    return s_d;
  }

}


public class TestNumber4 {
  public static void main (String[] argv)
  {
    for (int i=0; i<=1000; i+=200) {
      String s = EasyFormat.format (i, 4);

      int sqr = i * i;

      String sqr_string = EasyFormat.format (sqr, 8);

      double root = Math.sqrt (i);
      String root_string = EasyFormat.format (root, 5, 3);

      System.out.println ("The square of " + s + " is " + sqr_string +
                          " and the square root is " + root_string);
    }
  }
}

The square of    0 is        0 and the square root is    0.000
The square of  200 is    40000 and the square root is   14.142
The square of  400 is   160000 and the square root is   20.000
The square of  600 is   360000 and the square root is   24.494
The square of  800 is   640000 and the square root is   28.284
The square of 1000 is  1000000 and the square root is   31.622

public class Object {
  // ...
  public final native Class getClass();
  // ...
}

    String s = "hello";      // A String is a class.
    Class c = s.getClass (); // Get info about String's.
    System.out.println (c);  // Print.

class java.lang.String

class Obj_A {

  // Data.
  int n;
  double x;

  // Constructors.
  public Obj_A (int n, double x)
  {
    this.n = n;  this.x = x;
  }

  public Obj_A ()
  {
    this (0, 0);
  }

  // Methods.
  public static void print ()
  {
    System.out.println ("Obj_A");
  }

  public String toString ()
  {
    return "Obj_A: n=" + n + ", x=" + x;
  }
}

    Obj_A a = new Obj_A ();
    c = a.getClass ();
    System.out.println (c);    

    // Get constructors of Obj_A.
    Constructor[] ctor = c.getConstructors ();
    System.out.println ("Obj_A has " + ctor.length + " constructors");

    // Get methods of Obj_A.
    Method[] method = c.getMethods();
    System.out.println ("Obj_A has " + method.length + " methods: ");
    for (int i=0; i < method.length; i++) {
      String name = method[i].getName();
      System.out.println ("  " + name);
    }

import java.lang.reflect.*;

class Obj_A {

  // Data.
  int n;
  double x;

  // Constructors.
  public Obj_A (int n, double x)
  {
    this.n = n;  this.x = x;
  }

  public Obj_A ()
  {
    this (0, 0);
  }

  // Methods.
  public static void print ()
  {
    System.out.println ("Obj_A");
  }

  public String toString ()
  {
    return "Obj_A: n=" + n + ", x=" + x;
  }
}


public class TestClass {

  public static void call_toString (String obj_name)
  {
    try {
      // Get the Class instance first.
      Class c = Class.forName (obj_name);

      // Get a list of methods.
      Method[] method = c.getMethods();

      // Go through and look for toString()
      for (int i=0; i < method.length; i++) {

        // Get name of i-th method.
        String name = method[i].getName();

        // If it is toString ...
        if (name.equals ("toString")) {
          System.out.println (obj_name + " has a toString() method");
          try {
            // Create an instance of the object on the fly.
            Object instance = c.newInstance ();

            // No parameters, so a size=0 array is passed.
            Object[] obj_array = new Object[0];

            // Call the powerful invoke() method.
            // Note: toString returns a string.
            String output = (String) method[i].invoke (instance, obj_array);

            // Print out the string returned from toString()
            System.out.println ("String returned: " + output);
          }
          // Catch a whole bunch of exceptions.
          catch (InstantiationException e) {
            System.out.println (e);
          }
          catch (IllegalAccessException e) {
            System.out.println (e);
          }
          catch (InvocationTargetException e) {
            System.out.println (e);
          }
        }
      }
    }
    catch (ClassNotFoundException e) {
      System.out.println (e);
    }
  }

  public static void main (String[] argv)
  {
    call_toString ("Obj_A");
  }
}

Obj_A has a toString() method
String returned: Obj_A: n=0, x=0.0