I have tried to get this program working and have made some progress but am stuck figuring out how to do it. Here are the requirements.
a) Constructors
(i) The first constructor just needs to set all bits to false (or zero). The method clearAll() does the same thing.
(ii) The second constructor takes a character string as input. Each character of the string is either a t (for true) or f (for false) value. The bits with a t character are to be set on in the bit map; bits with an f character should be set off in the bit map. Throw an ArithmeticException if the input string has characters other than ‘t’, ‘T’, ‘f’, or ‘F’ appear. Throw IndexOutOfBoundsException if the string is too long.
(iii) The third constructor works just like the second except the input is a boolean array. The bits corresponding to the array elements that have a true value should be set to a value of one; the elements having a false value shoule be set to a value of zero.

b) Primary Methods
The methods, setBit(int), clearBit(int), and checkBit(int) respectively set a given bit on, off or check a bits current value. The method, countTrue() returns the total number of bits that are set. It can be used by the compareTo() method. The method setAll() turns on all the bits. This method and clearAll() can each be coded with one statement. Both setAll() and clearAll() methods can be written with one instruction.

c) Comparable interface
The compareTo() and equals() methods should be provided to conform to the standard way that java programs compare objects. One BitMap object is considered less than another if it contains less true bits. In effect, this method of comparison can be used to determine if one BitMap object has more bits on than another. The equals() method can compare whether two BitMaps have all of their on and off bits in the same positions.

d) The toString() method should return an appropriate string of 't' and 'f' values. The System.out.print methods use this method.

2) The next step is to debug the class that was created in the above step. I provide the program driver.java for this purpose; its code is at the bottom of this document. Don’t modify this program in any way; use it to test your class. It contains a menu that has options to test every option. Once the testing is complete, BitMap, could be used as a general tool for working with bits and could be used in many programs.

This is the Driver Class that was provided
package lab3;
 
// Driver program to test the BitMap class. 
 
import java.io.*;
 
public class Driver
{  static BitMap bitMap[];
   static BufferedReader in = new BufferedReader 
                           (new InputStreamReader(System.in));
 
   // Method to start the driver program. 
   public static void main(String[] args)
   {  int    bit, map, option;
      BitMap bitMap = new BitMap();
      BitMap secondMap;
 
      // Use a menu to test all of the other options.
      option = menu();
      while (option != 10)
      {  switch (option)
         { case 1: // Set bit.
              bit = getBit();
              bitMap.setBit(bit);
              System.out.println(bitMap);
              break;
           case 2: // Clear bit.
              bit = getBit();
              bitMap.clearBit(bit);
              System.out.println(bitMap);
              break;
           case 3: // Check bit.
              bit    = getBit();
              if (bitMap.checkBit(bit)) 
                    System.out.println("Bit is set");
              else  System.out.println("Bit is not set");
              System.out.println(bitMap);
              break;
           case 4:  // Clear all bits.
              bitMap.clearAll();
              System.out.println(bitMap);
              break;
           case 5:  // Set all bits.
              bitMap.setAll();
              System.out.println(bitMap);
              break;
           case 6:  // Count number of true bits.
              System.out.println(bitMap);
              System.out.println(bitMap.countTrue() 
                                             + " bits are set");
              break;
           case 7:  // Compare to bit maps.
              secondMap = getMap();
              System.out.println(bitMap);
              System.out.println(secondMap);
              System.out.println("compareTo = " 
                                 + bitMap.compareTo(secondMap));
              break;
           case 8:  // See if maps equal.
              secondMap = getMap();
              System.out.println(bitMap);
              System.out.println(secondMap);
              if (bitMap.equals(secondMap))
              {  System.out.println("Maps equal" ); }
              else
              {  System.out.println("Maps not equal" ); }
              break;
           case 9:  // toString.
              System.out.println(bitMap);
              break;
           default: 
              System.out.println("Illegal Option - try again");
              break;
          }
          option = menu();
      }
      System.out.println("End of Driver for BitMap");
   }  // End main.
 
   // Method to display menu and get selection.
   public static int menu()
   {  System.out.println("Menu of driver options");
      System.out.println(" 1 = setBit");
      System.out.println(" 2 = cleartBit");
      System.out.println(" 3 = checkBit");
      System.out.println(" 4 = clearAll");
      System.out.println(" 5 = setAll");
      System.out.println(" 6 = countTrue");
      System.out.println(" 7 = compareTo");
      System.out.println(" 8 = equals");
      System.out.println(" 9 = toString");
      System.out.println("10 = exit");
      System.out.print("Enter option: ");
      return readInt(1,10);
   }  // End menu().
 
   // Method to accept a bit number.
   public static int getBit()
   {  int bit;
      System.out.print("Enter bit number: ");
      bit = readInt(0,BitMap.BITSIZE-1);
      return bit;
   }  // End getBit().
 
   // Method to instantiate either a boolean or string bit map.
   public static BitMap getMap()
   {  boolean success = false;
      BitMap  bitMap  = null;
 
      do
      {  try
         {  System.out.println(
                    "Enter string of 't','T','f', or 'F' ");
            String values = in.readLine().toLowerCase();
 
            System.out.println(
                    "Enter 'b' or 'B' for Boolean map");
            String type = in.readLine().toLowerCase();
 
            if (type.length()!=0 && type.charAt(0)=='b')
            {  boolean bools[] = new boolean[values.length()];
               for (int i=0; i<values.length(); i++)
               { if(Character.toLowerCase(values.charAt(i))=='t')
                       bools[i] = true;
                  else bools[i] = false;  
                  bitMap = new BitMap(bools);
            }  }
            else bitMap = new BitMap(values);
            success = true;
         }
         catch (Exception e) {System.out.println(e); }
      }  while (!success);
      return bitMap;
   }  // End getMap().
 
   // Method to get an integer between min and max.
   public static int readInt(int min, int max) 
   {  String  token;
      int     value = 0;
      boolean ok = false;
 
      while (!ok)
      {  ok = true;
         try 
         {  token = in.readLine();
            value = Integer.parseInt (token); 
            if (value<min || value>max) ok = false;
         } 
         catch (Exception exception) {ok = false;}
         if (!ok) 
         {  System.out.print("Illegal input, enter between " 
                               + min + " and " + max + ": ");
      }  }
      return value;
   }  // End readInt().
}  // End class.

Here is the BitMap program so far
package lab3;
 
import java.io.*; 
 
public class BitMap implements Comparable, Serializable
 
{   public static final int  BITSIZE = 64;
 
    private long bitString;
 
 
// Three constructors.
    public  BitMap()
    {
        clearAll();
 
    }
 
    public  BitMap(String s)
            throws IndexOutOfBoundsException,ArithmeticException
    {
        try{
             BitMap bitMap = new BitMap(s);
             while(s != "t" || s != "T" || s != "f" || s!= "F")
             {
                 throw new IndexOutOfBoundsException();
             }
           }
     catch(IndexOutOfBoundsException ioe){System.out.println("Invalid entry needs to be (T,t,F,f) Please try re-enter.");}
     catch(ArithmeticException ae){throw new ArithmeticException();}
    }
    public  BitMap(boolean[] bits)
            throws IndexOutOfBoundsException
    {
     try{
 
        }
     catch(IndexOutOfBoundsException ie){throw new IndexOutOfBoundsException();}
    }
 
 
 
 
    private long    bitMask(int B) // Other class methods.
    {
 
        return B;
    }
    public  void    setBit(int B)
    {
        bitString = bitString | bitMask(B);
    }
 
    public  void    clearBit(int B)
    {
       bitString &= bitMask(B);
    }
 
    public  boolean checkBit(int B)
    {
        bitString = bitString ^ bitMask(B);
        return true;
    }
 
    public  int  countTrue()
    {
       int count = 0;
       for(int i = 0; i <= BITSIZE; i++)
       {
 
       }
 
       return count;
    }
 
    public  void    clearAll()
    {
        bitString = 0;
    }
 
    public  void    setAll()
    {
        bitString = 1;
    }
 
    public  int     compareTo(Object bm) //For Comparable.
    {
 
        return 0;
    }
    public  boolean equals(BitMap bm)
    {
 
        return true;
    }
    public  String  toString()
    {
 
 
      return String.valueOf(bitString);
    }
}