The highArray.java Example

Out next example program shows an improved interface for the storage structure class, called HighArray . Using this interface, the class user (the HighArrayApp class) no longer needs to think about index numbers. The setElem() and getElem()

methods are gone; they’re replaced by insert() , find() , and delete() . These new methods don’t require an index number as an argument because the class takes responsibility for handling index numbers. The user of the class ( HighArrayApp ) is free to concentrate on the what instead of the how—what’s going to be inserted,

deleted, and accessed, instead of exactly how these activities are carried out. Figure 2.4 shows the HighArray interface, and Listing 2.3 shows the highArray.java

program.

Class Interfaces 49

Private Data

highArra y()

Interface FIGURE 2.4 The HighArray interface.

LISTING 2.3 The highArray.java Program // highArray.java

// demonstrates array class with high-level interface // to run this program: C>java HighArrayApp //////////////////////////////////////////////////////////////// class HighArray

{ private long[] a; // ref to array a private int nElems; // number of data items //----------------------------------------------------------- public HighArray(int max) // constructor

{ a = new long[max]; // create the array nElems = 0; // no items yet }

//----------------------------------------------------------- public boolean find(long searchKey)

{ // find specified value int j; for(j=0; j<nElems; j++) // for each element,

if(a[j] == searchKey) // found item?

50 CHAPTER 2 Arrays

LISTING 2.3 Continued break; // exit loop before end

if(j == nElems) // gone to end?

return false; // yes, can’t find it else

return true; // no, found it } // end find() //----------------------------------------------------------- public void insert(long value) // put element into array

{ a[nElems] = value; // insert it nElems++; // increment size }

//----------------------------------------------------------- public boolean delete(long value)

{ int j; for(j=0; j<nElems; j++) // look for it

if( value == a[j] ) break; if(j==nElems) // can’t find it return false; else // found it { for(int k=j; k<nElems; k++) // move higher ones down

a[k] = a[k+1]; nElems--; // decrement size return true; }

} // end delete() //----------------------------------------------------------- public void display() // displays array contents

{ for(int j=0; j<nElems; j++) // for each element,

System.out.print(a[j] + “ “); // display it System.out.println(“”); }

//----------------------------------------------------------- } // end class HighArray

//////////////////////////////////////////////////////////////// class HighArrayApp

Class Interfaces 51

LISTING 2.3 Continued {

int maxSize = 100; // array size HighArray arr; // reference to array arr = new HighArray(maxSize); // create the array

arr.insert(77); // insert 10 items arr.insert(99); arr.insert(44); arr.insert(55); arr.insert(22); arr.insert(88); arr.insert(11); arr.insert(00); arr.insert(66); arr.insert(33);

arr.display(); // display items int searchKey = 35; // search for item

if( arr.find(searchKey) ) System.out.println(“Found “ + searchKey); else System.out.println(“Can’t find “ + searchKey);

arr.delete(00); // delete 3 items arr.delete(55); arr.delete(99);

arr.display(); // display items again } // end main()

} // end class HighArrayApp ////////////////////////////////////////////////////////////////

The HighArray class is now wrapped around the array. In main() , we create an array of this class and carry out almost the same operations as in the lowArray.java program: We insert 10 items, search for an item—one that isn’t there—and display the array contents. Because deleting is so easy, we delete 3 items (0, 55, and 99) instead of 1 and finally display the contents again. Here’s the output:

77 99 44 55 22 88 11 0 66 33 Can’t find 35

52 CHAPTER 2 Arrays

Notice how short and simple main() is. The details that had to be handled by main() in lowArray.java are now handled by HighArray class methods.

In the HighArray class, the find() method looks through the array for the item whose key value was passed to it as an argument. It returns true or false , depending

on whether it finds the item. The insert() method places a new data item in the next available space in the array.

A field called nElems keeps track of the number of array cells that are actually filled with data items. The main() method no longer needs to worry about how many items are in the array.

The delete() method searches for the element whose key value was passed to it as an argument and, when it finds that element, shifts all the elements in higher index cells down one cell, thus writing over the deleted value; it then decrements nElems .

We’ve also included a display() method, which displays all the values stored in the array.

The highArray.java Example