Lab 11. A sample of the class is:

Transcription

1 Lab 11 Lesson 11-2: Exercise 1 Exercise 2 A sample of the class is: public class List // Methods public void store(int item) values[length] = item; length++; public void printlist() // Post: If the list is not empty, the elements are // printed on the screen; otherwise "The list // is empty" is printed on the screen if (length > 0) for (int i = 0; i < length; i++) System.out.println(values[i]); System.out.println("The list is empty"); public int length() // Post: return value is the number of items in the list return length; public boolean isempty() // Post: returns true if list is empty; false otherwise return (length == 0); public boolean isfull() // Post: returns true if there is no more room in the // list; false otherwise return (values.length == length); public List(int maxitems) // Constructor // Post: Empty list is created with maxitems cells values = new int[maxitems]; // Data fields private int length; private int[] values; A sample of the driver is:

2 //********************************************************** // Class MyUseList is a driver for class List. The list // is instantiated, values are read in and printed. //********************************************************** import java.io.*; // Access file classes public class MyUseList // This class is a driver to execute class List public static BufferedReader infile; public static void main(string[] args) throws IOException // Data file for this test is on "int.dat" infile = new BufferedReader(new FileReader("int.dat")); String line; // instantiate a list List list; list = new List(20); // read the file and store the values in the list line = infile.readline(); while (line!= null) if (!list.isfull()) list.store(integer.parseint(line)); System.out.println ("List is full!"); line = infile.readline(); list.printlist(); infile.close(); // Close the input file Lesson 11-2: Exercise 3, 4, and 5: The last four lines are: Note need to add to front of the class import java.io.*; Additional methods for exercises 3, 4 and 5 are: // added for exercises 3, 4, and 5 public PrintWriter outfile; public boolean isthere(int item) // Post: returns true if item is in the list; false otherwise

3 // adapted from page 534 of main text int index = 0; while ((index < length) && (values[index]!= item)) index++; return (index < length); public void removeitem(int item) // Pre: value is in the list // Post: value removed from the list and remaining items shifted up // adapted from page 535 of main text int index = 0; boolean found = false; while ((index < length) &&!found) if (values[index] == item) found = true; index++; if (found) for (int count = index; count < length - 1; count++) values[count] = values[count+1]; length--; public void writelist(string file) throws IOException // Post: values in the list are written to the file outfile = new PrintWriter(new FileWriter(file)); int index; for (index = 0; index < length; index++) outfile.println(values[index]); outfile.close(); Exercise 6: An example of the Driver (extended from Exercise 2) : //********************************************************** // Exercise 5 and 6 // Class MyUseList is a driver for the extended class List. // The list is instantiated, values are read in and printed. //********************************************************** import java.io.*; // Access file classes public class MyUseList2 // This class is a driver to execute class List public static BufferedReader infile;

4 public static void main(string[] args) throws IOException // Data file for this test is on "int.dat" infile = new BufferedReader(new FileReader("int.dat")); String line; // instantiate a list List list; list = new List(20); // read the file and store the values in the list line = infile.readline(); while (line!= null) if (!list.isfull()) list.store(integer.parseint(line)); System.out.println ("List is full!"); line = infile.readline(); // print the List list.printlist(); // Search for values and print result System.out.println("Look for 10 " + list.isthere(10) + " Look for 5" + list.isthere(56)); // delete value 10 and print the list list.removeitem(10); list.printlist(); // added test - write list to file list.writelist("newint.dat"); infile.close(); // Close the input file The output from the program is the file and andint.dat and: Look for 10 true Look for 5false

5 Lesson 11-3 Exercise 1 to 5, and NOTE: I have used the method name store rather than insert. This keeps consistency with naming in Lesson 11-2 and Lesson The constructor is the same as List except called Slist(), the store() needs rebuilding, based on the example on page 548 in the main text. The rest are the same as List. For efficiency reasons, you may consider also changing the isthere() method to use a binary search algorithm, see page 557 of the main text. Store is now: public void store(int item) // Modeled on example on page 548 of main text if (!isfull()) int index = length - 1; //Loop control variable while ((index >= 0) && (item < values[index])) // find insertion point values[index+1] = values[index]; index--; values[index+1] = item; // Insert item length++; // Increment item count Lesson 11-4: Exercise 6 The driver is exactly the same as the driver for Lesson 11-2 exercise 6, except it instantiates a SList object. When you run this please reorder the test data sequence so it is not already in ascending order. This is needed to test the new store method. Exercise 1 and 2: NOTE this lesson is provided for completeness. The contents will not be included in any assessment as there is no working solution provided in either text. NOTE - the class names have been changed to separate the classes from earlier versions. An example of the program is:

6 import java.io.*; public class ListLesson4 extends AbstractList // Methods public void store(int item) values[length] = item; length++; public ListLesson4 (int maxitems) // Constructor uses the AbstractList constructor // Post: Empty list is created with maxitems cells super(maxitems); An example of the AbstractList class is import java.io.*; public abstract class AbstractList // Methods public abstract void store(int item); public void printlist() // Post: If the list is not empty, the elements are // printed on the screen; otherwise "The list // is empty" is printed on the screen if (length > 0) for (int i = 0; i < length; i++) System.out.println(values[i]); System.out.println("The list is empty"); public int length() // Post: return value is the number of items in the list return length; public boolean isempty() // Post: returns true if list is empty; false otherwise return (length == 0); public boolean isfull() // Post: returns true if there is no more room in the // list; false otherwise

7 return (values.length == length); public AbstractList (int maxitems) // Constructor // Post: Empty list is created with maxitems cells values = new int[maxitems]; // Data fields int length; int[] values; // added for exercises 3, 4, and 5 public PrintWriter outfile; public boolean isthere(int item) // Post: returns true if item is in the list; false otherwise // adapted from page 534 of main text int index = 0; while ((index < length) && (values[index]!= item)) index++; return (index < length); public void removeitem(int item) // Pre: value is in the list // Post: value removed from the list and remaining items shifted up // adapted from page 535 of main text int index = 0; boolean found = false; while ((index < length) &&!found) if (values[index] == item) found = true; index++; if (found) for (int count = index; count < length - 1; count++) values[count] = values[count+1]; length--; public void writelist(string file) throws IOException // Post: values in the list are written to the file outfile = new PrintWriter(new FileWriter(file)); int index;

8 for (index = 0; index < length; index++) outfile.println(values[index]); outfile.close(); The output from running the driver is the same. Exercise 3 and 4 Note: in this solution SListLesson4 is derived from ListLesson taking benefit of inheritence. See example on page 547 of the main text. An example of the SListLesson4 class is: import java.io.*; public class SListLesson4 extends ListLesson4 // Methods public void store(int item) // Modelled on example on page 548 of main text if (!isfull()) int index = length - 1; //Loop control variable while ((index >= 0) && (item < values[index])) // find insertion point values[index+1] = values[index]; index--; values[index+1] = item; // Insert item length++; // Increment item count public SListLesson4(int maxitems) // Constructor invokes constructor from List // Post: Empty list is created with maxitems cells super(maxitems); Exercise 5 and 6 The only methods that need to be concrete are the store and constructor which both override those in class ListLesson4. Note; This works because String already has a compareto method. If you used the same abstract class with an object that did not have a compareto you would need to implement the interface Comparable and add a custom compareto. See Section 11.7 in the main text. The new AbstractList is now:

9 import java.io.*; public abstract class AbstractListComparable // Methods public abstract void store(comparable item); public void printlist() // Post: If the list is not empty, the elements are // printed on the screen; otherwise "The list // is empty" is printed on the screen if (length > 0) for (int i = 0; i < length; i++) System.out.println(values[i]); System.out.println("The list is empty"); public int length() // Post: return value is the number of items in the list return length; public boolean isempty() // Post: returns true if list is empty; false otherwise return (length == 0); public boolean isfull() // Post: returns true if there is no more room in the // list; false otherwise return (values.length == length); public AbstractListComparable (int maxitems) // Constructor // Post: Empty list is created with maxitems cells values = new Comparable[maxItems]; // Data fields protected Comparable[] values; protected int length; // added for exercises 3, 4, and 5 public PrintWriter outfile; public boolean isthere(comparable item) // Post: returns true if item is in the list; false otherwise

10 // adapted from page 534 of main text - using generic items int index = 0; while ((index < length) && (values[index].compareto(item)!= 0)) index++; return (index < length); public void removeitem(comparable item) // Pre: value is in the list // Post: value removed from the list and remaining items shifted up // adapted from page 535 of main text int index = 0; boolean found = false; while ((values[index].compareto(item)!= 0) &&!found) if (values[index].compareto(item) == 0) found = true; index++; if (found) for (int count = index; count < length - 1; count++) values[count] = values[count+1]; length--; public void writelist(string file) throws IOException // Post: values in the list are written to the file outfile = new PrintWriter(new FileWriter(file)); int index; for (index = 0; index < length; index++) outfile.println(values[index]); outfile.close(); The new SList with comparable is now: import java.io.*; public class SListLesson4Comparable extends AbstractListComparable // Methods public void store(comparable item)

11 // Modelled on example on page 548 of main text if (!isfull()) int index = length - 1; //Loop control variable String s1 = (String)item; // System.out.println(index + " " + length + s1); if (length!= 0) // not first time through String s2 = (String)values[index]; while ((index >= 0) && (s1.compareto(s2)< 0)) // find insertion point values[index+1] = values[index]; index--; if (index >= 0) // skip if to insert item in front of list // System.out.println(index + (String)values[index]); s2 = (String)values[index]; //end if (index >= 0) // end while ((index >= ). // end if (length!= 0) values[index+1] = item; // Insert item length++; // Increment item count // end public void store public SListLesson4Comparable(int maxitems) // Constructor // Post: Empty list is created with maxitems cells super(maxitems); The new driver is now: //********************************************************** // Lesson 11-4 Exercise 5 and 6 // Class MyUseList is a driver for the extended class List. // The list is instantiated, values are read in and printed. //********************************************************** import java.io.*; // Access file classes public class MyUseSListLesson4Comparable // This class is a driver to execute class List public static BufferedReader infile; public static void main(string[] args) throws IOException // Data file for this test is on "int.dat" infile = new BufferedReader(new FileReader("Strings.dat")); String line;

12 // instantiate a list SListLesson4Comparable list; list = new SListLesson4Comparable(20); // read the file and store the values in the list line = infile.readline(); while (line!= null) if (!list.isfull()) list.store(line); System.out.println ("List is full!"); line = infile.readline(); // print the List list.printlist(); infile.close(); // Close the input file The last two values printed are: white yellow