jonWade()

Vectors in Java. Learning objectives and exercises from the University of London BSc in Creative Computing.

LEARNING OBJECTIVES

1. Explain the similarities and differences between a Vector and an a array.

A Vector is similar to an array. Arrays hold elements of specific types (like int, char, double). Vectors hold elements of type Object. Whereas we need to specify how large an array should be when we initialise it, Vectors can grow or shrink as the program is running.

2. Explain how Vectors are used for storing arbitrarily large amounts of data.

If you don’t know how many elements you are going to need in an array in advance, you can use a Vector. There are several instance methods that are useful for the Vector class.

• void addElement() :adds an object to the end of a Vector
• Object elementAt(int i) :returns the ith element of the Vector
• int Size() :returns the number of elements in the Vector
• void removeElementAt(int i) :removes the ith element of the Vector
• void setElementAt(Object x, int i) :changes the ith element to x

 
The following program courtesy of ©UoL allows us to store as much data as we like and find the largest element.

CODE: LargestInVec2.java

package Lecture23;
import java.util.*; //always needed if you use vectors
import java.util.Scanner;
public class LargestInVec2
{
    public static void main(String[] args)
    {
        Vector <Integer> v = new Vector<Integer>();
        v = readInVectorOfIntegers();
        System.out.println("The largest you typed in was " +
        largest(v));
    }
    
    public static Vector <Integer> readInVectorOfIntegers()
    {
        Scanner in = new Scanner(System.in);
        Vector <Integer> w = new Vector<Integer>();
        while (in.hasNextInt()) w.addElement(in.nextInt());
        return w;
    }
    
    public static int largest(Vector <Integer> v)
    {
        int largestsofar;
        if (v.size()>0)
        {
            largestsofar = v.elementAt(0);
            for (int i=0; i<v.size(); i++)
            if (largestsofar< v.elementAt(i))
                largestsofar = v.elementAt(i);
            return largestsofar;
        }
        return 0;
    }
}

In the code above we have defined the type of the Vector using . Vectors can be untyped, but we can also assign a type to them if we want them to hold only one type of data. This is useful as it helps when passing data from Vectors to other variables and helps us keep track of what a Vector is holding, avoiding bugs. Note we specify the type as and not .

3. Explain how to sort Vectors

Vectors can be sorted using exactly the same algorithm as we do for arrays. The code below from ©UoL shows one method of sorting a Vector.

CODE: SortVector.java

package Lecture23;
import java.util.*;
class SortVector
{
    public static void main(String[] args)
    {
        System.out.println("Enter some integers terminated by a non-"
        + "integer: ");
        Vector <Integer> vec = LargestInVec2.readInVectorOfIntegers();
        Vector <Integer> answer = sort(vec);
        System.out.println("Sorted gives: ");
        for (int i=0; i<answer.size(); i++)
        {
            System.out.println(answer.elementAt(i));
        }
        System.out.println("The original order was: ");
        for (int i=0; i<vec.size(); i++) 
        {
            System.out.println(vec.elementAt(i));
        }
    }
    
    public static void swap (Vector w, int i, int j)
    {
        Object temp = w.elementAt(i);
        w.setElementAt(w.elementAt(j),i);
        w.setElementAt(temp,j);
    }
    
    public static Vector <Integer> sort(Vector <Integer> v)
    {
        Vector <Integer> w = new Vector<Integer>();
        for (int i=0; i<v.size(); i++)
        {
            w.addElement(v.elementAt(i));
        }
        for (int i=0; i<w.size()-1; i++)
        {
            for (int j=i+1; j<w.size(); j++)
            {
                if (w.elementAt(i) > w.elementAt(j))
                {
                    swap(w,i,j);
                }
            }
        }
    return w;   
    }
}
    

4. Explain how to manipulate the contents of files by storing them in a Vector and then manipulating the Vector.

We can read the contents of a file into a Vector of a char at a time using the read() and addElement() methods and by creating a new FileReader object. Alternatively, we can read the contents of a file into a Vector of s a line at a time using a new Scanner object and new FileReader object and the methods nextLine() and addElement().

From that point, we can manipulate the Vector rather than the file and finally, if required, write the Vector back out to file. The code to demonstrate all of these concepts is shown in the exercises section.

EXERCISES

Q: Work out the output of the code below, which uses an untyped Vector.

CODE: Vector1.java

package Lecture23;
import java.util.*;
class Vector1
{
    public static void main(String[] args)
    {
        int k=5;
        Vector nums = new Vector();
        for (int i=0; i<k; i++)
        {
            nums.addElement(i);
        }
        nums.addElement('z');
        nums.addElement("zz");
        nums.addElement("Goldsmiths is great");
        for (int i=nums.size()-1; i>=0; i--)
        {
            System.out.println(nums.elementAt(i));
        }
    }
}

The code above outputs the following:

Goldsmiths is great
zz
z
4
3
2
1
0


Q: What does the following code do?

CODE: RefParama

package Lecture23;
import java.util.*;
class RefParams
{
    public static void main(String[] args)
    {
        System.out.println("Enter some integers terminated by a non-"
        + "integer: ");
        Vector <Integer> vec = LargestInVec2.readInVectorOfIntegers();
        Vector <Integer> answer = sort(vec);
        System.out.println("Sorted gives: ");
        for (int i=0; i<answer.size(); i++)
        {
            System.out.println(answer.elementAt(i));
        }
        System.out.println("The original order was: ");
        for (int i=0; i<vec.size(); i++) 
        {
            System.out.println(vec.elementAt(i));
        }
    }
    
    public static void swap (Vector w, int i, int j)
    {
        Object temp = w.elementAt(i);
        w.setElementAt(w.elementAt(j),i);
        w.setElementAt(temp,j);
    }
    
    public static Vector <Integer> sort(Vector <Integer> v)
    {
        for (int i=0; i<v.size(); i++)
            for (int j=i+1; j<v.size(); j++)
            {
                if (v.elementAt(i) > v.elementAt(j))
                {
                    swap(v,i,j);
                }
            }
        return v;   
    }
}
    

The code above prints out to screen the integers entered in ascending order. When it tries to print out the original order it also prints out the sorted order becuase the original Vector has been over-written in the sort() method.

Q: Write a program that reads some numbers (terminated by a non-integer), stores them in a Vector and prints out the smallest element entered.

CODE: SmallestInVec2.java

package Lecture23;
import java.util.*; //always needed if you use vectors
import java.util.Scanner;
public class SmallestInVec2
{
    public static void main(String[] args)
    {
        Vector <Integer> v = new Vector<Integer>();
        v = readInVectorOfIntegers();
        System.out.println("The smallest you typed in was " +
        smallest(v));
    }
    
    public static Vector <Integer> readInVectorOfIntegers()
    {
        Scanner in = new Scanner(System.in);
        Vector <Integer> w = new Vector<Integer>();
        while (in.hasNextInt()) w.addElement(in.nextInt());
        return w;
    }
    
    public static int smallest(Vector <Integer> v)
    {
        int smallestsofar;
        if (v.size()>0)
        {
            smallestsofar = v.elementAt(0);
            for (int i=0; i<v.size(); i++)
            if (smallestsofar> v.elementAt(i))
                smallestsofar = v.elementAt(i);
            return smallestsofar;
        }
        return 0;
    }
}

Q: Write a program that reads some numbers (terminated by a non-integer), stores them in a Vector and prints out the the sum of all elements entered.

CODE: SumVector.java

package Lecture23;
import java.util.*; //always needed if you use vectors
import java.util.Scanner;
public class SumVector
{
    public static void main(String[] args)
    {
        Vector <Integer> v = new Vector<Integer>();
        v = readInVectorOfIntegers();
        System.out.println("The sum you typed in was " +
        sum(v));
    }
    
    public static Vector <Integer> readInVectorOfIntegers()
    {
        Scanner in = new Scanner(System.in);
        Vector <Integer> w = new Vector<Integer>();
        while (in.hasNextInt()) w.addElement(in.nextInt());
        return w;
    }
    
    public static int sum(Vector <Integer> v)
    {
        int sum = 0;
        if (v.size()>0)
        {
            for (int i=0; i<v.size(); i++)
            sum = sum + v.elementAt(i);
            return sum;
        }
        return 0;
    }
}

Q: Write a program that reads some numbers (terminated by a non-integer), stores them in a Vector and prints out the the average of all elements entered.

CODE: AverageVector.java

package Lecture23;
import java.util.*; //always needed if you use vectors
import java.util.Scanner;
public class AverageVector
{
    public static void main(String[] args)
    {
        Vector <Integer> v = new Vector<Integer>();
        v = readInVectorOfIntegers();
        System.out.println("The average you typed in was " +
        average(v));
    }
    
    public static Vector <Integer> readInVectorOfIntegers()
    {
        Scanner in = new Scanner(System.in);
        Vector <Integer> w = new Vector<Integer>();
        while (in.hasNextInt()) w.addElement(in.nextInt());
        return w;
    }
    
    public static double average(Vector <Integer> v)
    {
        int sum = 0;
        if (v.size()>0)
        {
            for (int i=0; i<v.size(); i++)
            sum = sum + v.elementAt(i);
            return (sum / v.size());
        }
        return 0;
    }
}

Q: Write a program that asks the user to enter some numbers (terminated by a non-integer) and then prints them out in the opposite order to which they were entered.

CODE: ReverseVector.java

package Lecture23;
import java.util.*;
class ReverseVector
{
    public static void main(String[] args)
    {
        System.out.println("Enter some integers terminated by a non-"
        + "integer: ");
        Vector <Integer> vec = LargestInVec2.readInVectorOfIntegers();
        //Vector  answer = reverse(vec);
        System.out.println("Reversed gives: ");
        for (int i=vec.size()-1; i>=0; i--)
        {
            System.out.println(vec.elementAt(i));
        }       
        System.out.println("The original order was: ");
        for (int i=0; i<vec.size(); i++) 
        {
            System.out.println(vec.elementAt(i));
        }
    }
    
}


Q: Write a program where first the user enters some numbers and then the program asks the user to pick a number. The program tells the user how many of the these numbers the user entered. For example, if the user entered 7 4 4 3 1 7 and then the number 7 was chosen. the program would output 2 because the user had entered two sevens previously.

CODE: NumberMatch.java

package Lecture23;
import java.util.*;
class NumberMatch
{
    public static void main(String[] args)
    {
        System.out.println("Enter some integers terminated by a non-"
        + "integer: ");
        Vector <Integer> vec = LargestInVec2.readInVectorOfIntegers();
        
        System.out.println("Number to match?> ");
        Scanner inputObj = new Scanner(System.in);
        int numIn = inputObj.nextInt();
        
        System.out.println();
        System.out.println("Number of matches = " + match(vec, numIn));
        
    }
    
    public static int match(Vector <Integer> v, int n)
    {
        int count = 0;
        for (int i = 0; i<v.size(); i++)
        {
            if (v.elementAt(i) == n) count++;
        }
        return count;
    }
}


Q: Write a program where the user types in a number of Strings stored in a Vector of Strings and then the program prints out the longest String.

CODE: longestStringVector.java

package Lecture23;
import java.util.*; //always needed if you use vectors
import java.util.Scanner;
public class longestStringVector
{
    public static void main(String[] args)
    {
        Vector <String> v = new Vector<String>();
        v = readInVectorOfStrings();
        System.out.println("The longest String you typed in was '" +
        longestString(v) + "'");
    }
    
    public static Vector <String> readInVectorOfStrings()
    {
        System.out.println("Input your strings, terminate by typing "
        + "EXIT> ");
        Scanner in = new Scanner(System.in);
        Vector <String> w = new Vector<String>();
        String s=null;
        boolean exit = false;
        while (exit==false) 
        {
            s = in.nextLine();
            w.addElement(s);
            if (s.compareTo("EXIT")==0) exit=true;      
        }
        return w;
    }
    
    public static String longestString(Vector <String> v)
    {
        String longestsofar="";
        if (v.size()>0)
        {
            longestsofar = v.elementAt(0);
            for (int i=0; i<v.size(); i++)
            if (longestsofar.length() < v.elementAt(i).length())
                longestsofar = v.elementAt(i);
            return longestsofar;
        }
        return null;
    }
}

Q: Write a method that reads in a series of integers from the user but sorts them into ascending order as it puts them into the Vector.

CODE: SortIntVectorOnInput.java

package Lecture23;
import java.util.*;
import java.util.Scanner;
public class SortIntVectorOnInput
{
    public static void main(String[] args)
    {
        Vector <Integer> store = new Vector <Integer>();
        System.out.println("Input your integers> ");
        
        
        Scanner inObj = new Scanner(System.in);
        int s;
        int count = 0;
        while (inObj.hasNextInt())
        {
            s = inObj.nextInt();
            store.addElement(s);
            //count ++;
            findWhereToInsertAscending(s, store /*, count*/);
        }
        
        
        System.out.println();
        System.out.println("In Ascending Order: ");
        for (int i=0; i<store.size(); i++)
        {
            System.out.println(store.elementAt(i));
        }
        System.out.println();
    }
    
    
    public static void shuffle(int elementPos, Vector <Integer> v)
    {
        Vector <Integer> clone = new Vector <Integer>();
        for (int j=0; j<v.size(); j++)
        {
            clone.addElement(v.elementAt(j));
        }
        for (int i=elementPos; i<v.size()-1; i++) 
        {
            //System.out.println("Shuffling...");
            //System.out.println("Setting value of object at " + (i+1
            //+ " element to " + clone.elementAt(i));
            v.setElementAt((clone.elementAt(i)), i+1);
        }
    }
        
        
    public static void 
    findWhereToInsertAscending(int s, Vector <Integer> v)
    {
        int pos=0;
        boolean exit=false;
        for (int i=0; i<v.size(); i++)
        {
            //System.out.println("Value of object at " + i + 
            //" element = " + v.elementAt(i));
            if (s < v.elementAt(i)) 
            {
                //System.out.println(s + 
                //" should be inserted at element " + i); 
                shuffle(i, v);
                v.setElementAt(s, i);
                return;
            }
            //System.out.println();
            
        }
        return;
    }
}
        

Q: Adjust the code above to sort the elements in descending order on input.

CODE: SortIntVectorOnInputDesc.java

package Lecture23;
import java.util.*;
import java.util.Scanner;
public class SortIntVectorOnInputDesc
{
    public static void main(String[] args)
    {
        Vector <Integer> store = new Vector <Integer>();
        System.out.println("Input your integers> ");
        
        
        Scanner inObj = new Scanner(System.in);
        int s;
        int count = 0;
        while (inObj.hasNextInt())
        {
            s = inObj.nextInt();
            store.addElement(s);
            //count ++;
            findWhereToInsertAscending(s, store /*, count*/);
        }
        
        
        System.out.println();
        System.out.println("In Ascending Order: ");
        for (int i=0; i<store.size(); i++)
        {
            System.out.println(store.elementAt(i));
        }
        System.out.println();
    }
    
    
    public static void shuffle(int elementPos, Vector <Integer> v)
    {
        Vector <Integer> clone = new Vector <Integer>();
        for (int j=0; j<v.size(); j++)
        {
            clone.addElement(v.elementAt(j));
        }
        for (int i=elementPos; i<v.size()-1; i++) 
        {
            //System.out.println("Shuffling...");
            //System.out.println("Setting value of object at " + (i+1
            //+ " element to " + clone.elementAt(i));
            v.setElementAt((clone.elementAt(i)), i+1);
        }
    }
        
        
    public static void 
    findWhereToInsertAscending(int s, Vector <Integer> v)
    {
        int pos=0;
        boolean exit=false;
        for (int i=0; i<v.size(); i++)
        {
            //System.out.println("Value of object at " + i + 
            //" element = " + v.elementAt(i));
            if (s > v.elementAt(i)) 
            {
                //System.out.println(s + 
                //" should be inserted at element " + i); 
                shuffle(i, v);
                v.setElementAt(s, i);
                return;
            }
            //System.out.println();
            
        }
        return;
    }
}
        

Entirely the same code only with a > symbol rather than a < symbol in the line if (s > v.elementAt(i)).

Q: Write a method that does a binary search for an Integer in a Vector. It must return the position of the Integer in the Vector and -1 if it's not there. Assume the Vector is sorted in ascending order.

CODE: InputBinarySearchVec.java

package Lecture23;
import java.util.*;
import java.util.Scanner;
public class InputBinarySearchVec
{
    public static void main(String[] args)
    {
        Vector <Integer> store = new Vector <Integer>();
        System.out.println("Input your integers> ");
        
        
        Scanner inObj = new Scanner(System.in);
        int s;
        int count = 0;
        while (inObj.hasNextInt())
        {
            s = inObj.nextInt();
            store.addElement(s);
            //count ++;
            findWhereToInsertAscending(s, store /*, count*/);
        }
        
        System.out.println("Input integer to search for> ");
        
        Scanner inSrchObj = new Scanner(System.in);
        int sObj = inSrchObj.nextInt();
        
        System.out.println();
        System.out.println("Array Position = " 
        + binarySearchPos(store, sObj));
        
        /*
        
        This stuff is just printing out the vector - don't need it
        for this particular exercise
        
        System.out.println();
        System.out.println("In Ascending Order: ");
        for (int i=0; i         {
            System.out.println(store.elementAt(i));
        }
        System.out.println();
        
        */
        
    }
    
    //the following is the same algorithm as the one we used previously
    //to search through arrays
    
    public static int binarySearchPos (Vector <Integer> v, int x)
    {
        int first=0, last=(v.size()-1);
        int mid;
        while (first <=last)
        {
            mid = first + (last-first)/2;
            if (v.elementAt(mid)==x) return mid;
            else if (v.elementAt(mid) > x) last = mid-1;
            else first=mid+1;
        }
        return -1;
    }

    
    public static void shuffle(int elementPos, Vector <Integer> v)
    {
        Vector <Integer> clone = new Vector <Integer>();
        for (int j=0; j<v.size(); j++)
        {
            clone.addElement(v.elementAt(j));
        }
        for (int i=elementPos; i<v.size()-1; i++) 
        {
            //System.out.println("Shuffling...");
            //System.out.println("Setting value of object at " + (i+1
            //+ " element to " + clone.elementAt(i));
            v.setElementAt((clone.elementAt(i)), i+1);
        }
    }
        
        
    public static void 
    findWhereToInsertAscending(int s, Vector <Integer> v)
    {
        int pos=0;
        boolean exit=false;
        for (int i=0; i<v.size(); i++)
        {
            //System.out.println("Value of object at " + i + 
            //" element = " + v.elementAt(i));
            if (s < v.elementAt(i)) 
            {
                //System.out.println(s + 
                //" should be inserted at element " + i); 
                shuffle(i, v);
                v.setElementAt(s, i);
                return;
            }
            //System.out.println();
            
        }
        return;
    }
}
        

The method that the exercise requested is binarySearchPos().

Q: Write a method for removing all duplicates from a Vector of Objects.

CODE: removeDup.java

package Lecture23;
import java.util.*;
public class removeDup
{
    public static void main(String[] args)
    {
        //first create a Vector of Objects
        
        Vector vOO = new Vector();
        vOO.addElement("Hello");
        vOO.addElement(1);
        vOO.addElement(2);
        vOO.addElement("Hello");
        vOO.addElement(2);
        
        /*
        
        Bug check code
        
        for (int i=0; i         {
            System.out.println(vOO.elementAt(i));
        }
        
        */
        
        removeDupes(vOO);
        printVec.printVector(vOO);  //wrote a method to print out Vector
                                    //as bored of writing the same
                                    //code in each class
        
    }
    
    public static void removeDupes(Vector v)
    {
        
        Object check=null;
        Object compare=null;
        
        for (int j=0; j<v.size(); j++)
        {
            check = v.elementAt(j);
            //System.out.println("Checking for duplicates of "
            //+ v.elementAt(j));
            //System.out.println();
            for (int i=(j+1); i<(v.size()); i++)
            {
                compare = v.elementAt(i);
                //System.out.println("Comparing to " + v.elementAt(i));
                //System.out.println();
                if (check.equals(compare)==true) 
                {
                    //System.out.println("duplicate");
                    v.removeElementAt(i);
                }
            }           
        }
    }
}
        

Q: Write a program that reads a file into a Vector of Strings, one element per line and then finds the longest line (and in so doing find the longest word in the English language by assessing the file words).

CODE: longestLineInVec.java
\
package Lecture23;
import java.io.*;
import java.util.*;
public class longestLineInVec
{
    /* this section reads the file into a Vector */
    
    public static Vector <String> fileToVector(String s) throws
    Exception
    {
        Vector <String> v = new Vector <String> ();
        Scanner inone = new Scanner(new FileReader(s));
        while (inone.hasNextLine()) 
        {
            v.addElement(inone.nextLine());
        }
        return v;
    }
    
    /* this is where the hard work is done */
    public static Object lenLonLineInObj(Vector <String> v)
    {
        Object qIsLong = null;  //holds the object for length testing       String s = null;
        int maxlen = 0; //holds the maximum String length so far of all
                        //objects tested
        int len = 0;    //holds the length of String to be tested
        int counter = 0;    //holds the position in the Vector of the
                            //object with the maximum length
        for (int i=0; i<v.size(); i++)
        {
            qIsLong = v.elementAt(i);   //read in object to be tested
            s = qIsLong.toString();     //convert object to String
            len = s.length();           //work out length of String
            if (len>maxlen)             //check if longest String
            {
                maxlen = len;           //if it is, set maxlen to 
                                        //new maximum String length
                counter = i;            //set marker in Vector so we
                                        //know which element is longest
            }       
        }
        return v.elementAt(counter);    //return longest Object
    }
    
    public static void main(String[] args) throws Exception
    {
        //use command line input to specify the file to assess
        Object longest = lenLonLineInObj(fileToVector(args[0]));
        //print out to screen longest Object
        System.out.println(longest);
    }
}

//works like a DREAM!!!!

Q: Write a program occ1.java which prints out the number of occurrences of each printable character in a file. Assume the printable characters are those whose Unicode values lie between 30 and 126 inclusive.

Struggled with this one - wrote a routine which used a Vector to store all the characters from the file and another to store the occurrences of those characters. Had a lot of duplicates in it, so then had to clean out the duplicates from both Vectors. The algorithm for that was problematic. Worked fine for small files, but ran out of memory and took too long when using it on larger files.

Here is the very elegant solution provided by the ©UoL.

CODE: fileToVector.java

package Lecture23;
import java.io.*;
import java.util.*;
public class fileToVector
{
    public static Vector <Character> fileToVector(String s)
    throws Exception
    {
        Vector <Character> w = new Vector();
        FileReader inone = new FileReader(s);
        int t=inone.read();
        while (t!=-1)
        {
            w.addElement((char)t);
            t=inone.read();
        }
        return w;
    }
}

CODE: occ1.java

package Lecture23;
import java.io.*;
import java.util.*;
public class occ1
{
    public static int occurrences(char x, Vector <Character> v)
    {
        int total = 0;
        for (int i=0; i<v.size(); i++)
        {
            if (v.elementAt(i)==x) total = total + 1;
        }
        return total;
    }
    public static void main(String[] args) throws Exception
    {
        Vector <Character> v = fileToVector.fileToVector(args[0]);
        for (int i=30; i<127; i++)
        {
            int n = occurrences((char)i,v);
            if (n>0) System.out.println((char)i + " " + n);
        }
    }
}

Q: Using a Vector, write another program like occ1.java which prints out the occurrences of each character in a file but, this time, prints them in order of popularity. Order the output so that the most frequently occurring characters comes first.

CODE: occSorted.java

package Lecture23;
import java.io.*;
import java.util.*;
public class occSorted
{
    public static int occurrences(char x, Vector <Character> v)
    {
        int total = 0;
        for (int i=0; i<v.size(); i++)
        {
            if (v.elementAt(i)==x) total = total + 1;
        }
        return total;
    }
    public static void main(String[] args) throws Exception
    {
        Vector <Character> v = fileToVector.fileToVector(args[0]);
        Vector <Character> chStore = new Vector <Character>();
        Vector <Integer> intStore = new Vector <Integer>();
        for (int i=30; i<127; i++)
        {
            int n = occurrences((char)i,v);
            if (n>0) 
            {
                //System.out.println((char)i + " " + n);
                
                //create two new Vectors to hold chars and ints
                chStore.addElement((char)i);
                intStore.addElement(n);
            }
        }
        //print out in reverse order
        System.out.println();
        System.out.println("In reverse order...");
        while (chStore.size()>0)
        {
            //find the largest occurrence and save position
            int largestsofar;
            int largestpos=0;
            if (intStore.size()>0)
            {
                largestsofar = intStore.elementAt(0);
                for (int i=0; i<intStore.size(); i++)
                {
                    if (largestsofar<intStore.elementAt(i))
                    {   
                        largestsofar = intStore.elementAt(i);
                        largestpos = i;
                    }
                }
            }
            //print out largest occurring char and frequency
            System.out.println(chStore.elementAt(largestpos) + " " 
            + intStore.elementAt(largestpos) + " ");
            //remove both values from their respective Vectors
            chStore.removeElementAt(largestpos);
            intStore.removeElementAt(largestpos);
        }               
    }
}

Q: Complete the previous exercise without using a Vector - use an array instead.

The solution below is ©UoL. The algorithm is really interesting because it was something I was considering using for the frequency exercise. As there are only 255 Unicode characters, you can set up a 'score board' within an array for each Unicode character. As each one occurs, we increment the score on the array 'score board'. The method cat() below does the scoring.

CODE: occs3.java

package Lecture23;
import java.io.*;
import java.util.*;
public class occs3
{
    public static int biggest(int[] a) throws Exception
    {
        int biggestsofar=0, position=0;
        for(int i=0; i<a.length; i++)
        if (a[i]> biggestsofar)
        {
            biggestsofar=a[i];
            position=i;
        }
        return position;
    }
    
    public static void cat(String s, int[] a) throws Exception
    {
        FileReader inone = new FileReader(s);
        int t = inone.read();
        for (int i=0; i<a.length; i++) a[i]=0;
        while (t!=-1)
        {
            a[t]=a[t]+1;
            t=inone.read();
        }
    }
    
    public static void main(String[] args) throws Exception
    {
        final int max = 255;
        int[] occs = new int[max];
        cat(args[0],occs);
        int huge=biggest(occs);
        while (occs[huge]!=0)
        {
            System.out.println((char) huge + " " + occs[huge]);
            occs[huge]=0;
            huge=biggest(occs);
        }
    }
}

Q: Write a program occs4.java which you can use to find the frequency as a percentage of each character in a piece of text.

CODE: occs4.java

package Lecture23;
import java.io.*;
import java.util.*;
public class occs4
{
    public static int biggest(int[] a) throws Exception
    {
        int biggestsofar=0, position=0;
        for(int i=0; i<a.length; i++)
        if (a[i]> biggestsofar)
        {
            biggestsofar=a[i];
            position=i;
        }
        return position;
    }
    
    public static void cat(String s, int[] a) throws Exception
    {
        FileReader inone = new FileReader(s);
        int t = inone.read();
        for (int i=0; i<a.length; i++) a[i]=0;
        while (t!=-1)
        {
            a[t]=a[t]+1;
            t=inone.read();
        }
        a[10]=0;    //remove line returns
    }
    
    
    public static int sum(int[] a)
    {
        int sum=0;
        for (int i=0; i<a.length; i++)
        {
            sum=sum+a[i];
        }
        return sum;
    }
    
    public static double roundTwoDec(double d)
    {
        int i = (int)(d*100.0);
        double d2 = ((double)i)/100.0;
        return d2;
    }
    
    
    public static void main(String[] args) throws Exception
    {
        final int max = 255;
        int[] occs = new int[max];
        cat(args[0],occs);
        int huge=biggest(occs);
        double total = sum(occs);

        while (occs[huge]!=0)
        {
            double d = roundTwoDec((((occs[huge]/total)*100)));
            System.out.println((char) huge + " " + d + "%");
            occs[huge]=0;
            huge=biggest(occs);
        }
    }
}

Notice the method roundTwoDec() which allows us to round a double to two decimal places by converting it into an int and scaling it by 100.0, then converting back to a double and dividing by 100.0.

Q: Write a program searchDictionary.java so that a command line argument 'fred' causes the program to say 'yes' if 'fred' is an English word and 'no' if it isn't.

CODE: fileToVectorLines.java ©UoL

package Lecture23;
import java.io.*;
import java.util.*;
public class fileToVectorLines
{
    public static Vector <String> fileToVectorLines(String s)
    throws Exception
    {
        Vector v = new Vector();
        Scanner inone = new Scanner(new FileReader(s));
        while (inone.hasNextLine()) v.addElement(inone.nextLine());
        return v;
    }
}

CODE: dictionarySearch.java

package Lecture23;
import java.io.*;
import java.util.*;
public class dictionarySearch
{
    public static void main(String[] args) throws Exception
    {
    
        Vector <String> search = new Vector <String>();
        search.addElement(args[0]);
        Vector <String> dictionary = new Vector(
                fileToVectorLines.fileToVectorLines("words.txt"));
        
        boolean flag = false;
        for (int i=0; i<dictionary.size(); i++)
        {
            if
            (search.elementAt(0).equals(dictionary.elementAt(i))==true)
            {
                System.out.println("Yes");
                flag = true;
            }
        }
        if (flag==false) System.out.println("No");
    }
}

Q: Write a program firstlast.java that can be used to print out all English words that start and end with the same letter. The choice of the letter should be a command line argument.

Took a while, but solution (including debug code commented out) below.

CODE: firstlast.java

package Lecture23;
import java.io.*;
import java.util.*;
public class firstlast
{
    public static String firstLastMatch(Object v, Object search)
    {
        String s = v.toString();
        //System.out.println("s = " + s);
        int len = s.length();
        char first = s.charAt(0);
        //System.out.println("First char = " + first);
        //System.out.println("(int)first = " + (int)first);
        char last  = s.charAt(len-1);
        //System.out.println("Last char = " + last);
        //System.out.println("(int)last = " + (int)last);
        boolean match = false;
        int intf = (int) first;
        int intsearchf = (int)(search.toString().charAt(0));
        //System.out.println("intf = " + intf);
        //System.out.println("intsearchf = " + intsearchf);
        if (((int)first == (int)last) && (intf==intsearchf))
        
        //above we have already checked that the first and last letter
        //are the same, so the second condition in the if statement
        //checks if the first letter of the dictionary word and the 
        //first letter of the search string are the same. Only if they
        //are both the same do we return a match, else 'no match'
        
        {
            match=true;
            //System.out.println("Match = " + match);
        }
        if (match == true) return s;
        else return "no match";
    }

    public static void main(String[] args) throws Exception
    {
    
        Vector <String> letter = new Vector <String>();
        letter.addElement(args[0]);
        Vector <String> dictionary = new Vector(
                fileToVectorLines.fileToVectorLines("words.txt"));
        
        for (int i = 0; i<dictionary.size(); i++)
        {
            String s = firstLastMatch(dictionary.elementAt(i), 
            letter.elementAt(0));
            
            if (s!="no match")
            {
            System.out.println(firstLastMatch(dictionary.elementAt(i),
            letter.elementAt(0)));
            }
        }
    }
}