Collections. Collections. Collections - Arrays. Collections - Arrays

Transcription

1 References: Beginning Java Objects, Jacquie Barker; The Java Programming Language, Ken Arnold and James Gosling; IT350 Internet lectures Collections Collection types Collection wrappers Composite classes revisited Collection classes s Enumerations 9/9/ /9/ Collections A collection is a class that holds and organizes references to objects to be handled as a group Collections must be instantiated before being used: Collection c = new Collection(); Java does not allow whole objects to be stored in a collection -- only the references to the objects Whole objects can t be stored in a collection: 9/9/ Collections The minimum set of methods provided by a collection include adding objects removing objects iterating through the objects in a predetermined order getting a count of the number of objects in the collection reporting whether or not a particular object is in the collection 9/9/ Collections - Arrays Array objects are first-class objects, meaning that all operations in the super class Object are allowed on an array. What class are arrays objects of? The compiler creates an internal class that represents arrays of specific types. Collections - Arrays The following program reveals the internal class name created by the compiler for arrays of SomeClass. public class SomeClass{ public static void main (String[] args) { SomeClasssomeClasses[ ] = new SomeClass[3]; System.out.println (someclasses.getclass().getname()); [LSomeClass; 9/9/ /9/

2 Collections - Arrays Java does not support multidimensional arrays, but you can construct an array of arrays. public class test { int [] [] [] threed; //create an array of 2, where each of the two elements is an //array of 3, where each of the three elements is an array //of 4 integers. threed = new int [2][3][4]; for (int i=0; i < threed.length; i++) { System.out.println( i= + i); for(int j=0; j < threed[i].length; j++) { for(int k=0; k<threed[i][j].length; k++) System.out.print(threeD[i][j][k] + ); System.out.println(); //end for-j //end for-i i=0 i=1 Collections - Arrays N-dimensional arrays do not have to be square. public class test { int [] [] matrix; //create an array of 5 (arays of int) matrix = new int [5][ ]; //note: new int [5][][] would be an array of 5 (array of arrays of int) //each of the 5 arrays will have a different size for (int i=0; i < matrix.length; i++) matrix[i] = new int[i+1]; for(int j=0; j < matrix.length; j++) { for(int k=0; k < matrix[j].length; k++) System.out.print(matrix[j][k] + ); System.out.println(); //end for-j /9/ /9/ Java has other generic collection types besides arrays : Ordered List items can be placed in the collection in a particular order and later retrieved in that same order. Objects can be retrieved based on their position in the list items are added at the end of the list unless explicit instructions given to insert somewhere in the middle when item is removed, the space left is closed up 9/9/ Sorted Ordered List similar to ordered list - but programmer doesn t have to worry about keeping the order the list automatically inserts an object in the appropriate location to maintain sorted order sort key must be defined for the list 9/9/ Set unordered collection we can step through the collection to perform operation on each item we can test whether a given object has been added duplicates are not allowed usage: group students according to the dept they are majoring in Dictionary provides means for sorting each object reference along with a unique key (one of the object s attributes) that can be used to retrieve it later items can be retrieved in ascending key order efficient access using key usage: a course catalog indexed by combination of course number plus section number 9/9/ /9/

3 In Java, collections store references ( handles ) given univ.students registered for a course, we can maintain an ordered list of students to keep track of who registered first for a follow-on course a dictionary so student object can be retrieved based on his/her name a second dictionary that organizes all university students based on ID number Dictionary indexed by Student name Students attending CS191 Adam 4321 Eve 6789 Bobby 2394 s234 sid... Dictionary indexed By Student number All Student Body records s845 sid Ordered List Students waiting to attend CS291 9/9/ /9/ Based on diagram by Jacquie Barker Collections extended You can create your own collection type by extending an existing collection type must be careful not to override methods in the super class that you don t understand in detail by creating a new type from scratch not usually necessary, given all the built-in types in Java by creating a wrapper class that encapsulates one of the existing collection types, to hide details involved in manipulating the collection this is more common 9/9/ Wrapper for Collections Consider a class called EnrollmentCollection for a registration system. The class is to be used by Course objects to manage all enrolled Student objects. The new class would contain as an attribute an ordered list collection type (i.e., a Vector) methods provided by this class might include: enroll() and drop() for adding/removing students isenrolled() for preventing students from enrolling more than once in a course gettotalenrollment() for obvious reasons getnthstudent() for retrieving a specified student object 9/9/ class EnrollmentCollection { private Vector students = new Vector(); Collection Wrapper public boolean enroll(student s) { if (total students exceed course limit) return false; else if (s. isenrolled() ) return false; else if (some prereq not satisfied ) return false; else students.add(s); public boolean unenroll (Student s ) { if (!s.isenrolled() ) return false; else students.remove(s); public int gettotalenrollment() { return students.size(); public boolean isenrolled ( Student s ) { if (students.contains() ) return true; else return false; public Student getnthstudent(int n) { //details omitted Hide the student collection inside a Java Vector Delegate responsibility for adding the student More delegation We can switch the collection from a Vector to a different collection type without changing any client code. 9/9/ Collection Wrapper: Usage class Course { private EnrollmentCollection enrolledstudents = new EnrollmentCollection(); String coursename; int credits;. public boolean enroll(student s) { //pass the Student reference to the collection s enroll method (i.e., delegate // to another method the responsibility for enrolling the student) enrolledstudents.enroll(s ); public boolean unenroll(student s) { //ditto enrolledstudents.unenroll(s ); 9/9/

4 Collection Wrapper - Client Code public class StudentEnrollmentDriver { Course c = new Course(); Student s1 = new Student(); Student s2 = new Student(); Student s3 = new Student(); c.enroll(s1); c.enroll(s2); c.enroll(s3); EnrollmentCollection ec = c.getregisteredstudents (); for (all Student objects in Collection ec) { Student s = ec.getnthstudent(i ); s.printgradereport(); Ask course for a handle on the collection of all registered students 9/9/ Composite Classes Revisited A student is defined by the following attributes: name String id String birthdate Date address String major String gpa float advisor Professor courseload a collection of Course objects transcript a collection of TranscriptEntry objects or Transcript 9/9/ Composite Classes Revisited The courseload attribute is a collection of all Course objects that a Student is currently enrolled in. The transcript attribute is a list of all courses a student has taken since beginning college, including the semester taken and letter grade received. Defining attributes as collections makes the Student class a composite class. 9/9/ Composite Classes Revisited The transcript can be defined as a class, and transcript objects can be placed in a collection. class TranscriptEntry { private Course coursetaken; private String semestertaken; private String gradereceived; System.out.println(course.getCourseNo() + \t + course.gettitle () + course.getcredithourse () + \t + gradereceived() ); // other methods The collection of TranscriptEntry objects is encapsulated in a Transcript wrapper class. Each TranscriptEntry object maintains a handle on its corresponding Course object so it can obtain course information class Student { String name; String id; Transcript transcript; 9/9/ Exercise Consider the abstraction: A book is a collection of chapters, which are each collections of pages Sketch pseudocode for Book, Chapter and Page classes. Invent attributes you think would be relevant, using collections as attributes where appropriate. Methods on Book class should add chapters and pages and determine how many chapters and pages the book contains. Java Collection Classes: is an implementation of the dictionary collection type. Implements the Java Dictionary interface Key and object can be of any object type Has capacity and tools to decide when to grow the table To use, import the java.util package students = new ((); To create objects to be inserted: Object object = new Object(keyValue, Object) 9/9/ /9/

5 Java Collection Classes: Specify a key value to use for retrieval. SSN is the key here. Student s1 = new Student ( , Eve Black ); Student s2 = new Student( , Adam Brown ); Student s3 = new Student( , Bobby Green ); students.put(s1.getssn(), s1); students.put(s2.getssn(), s2); students.put(s3.getssn(), s3); Student s = (Student) students.get( ); Store student handles in hash table Retrieve reference for Eve Black. Must be cast to correct type. 9/9/ implements the following methods from Dictionary: public abstract Object get(object key); //returns null if object with key not found public abstract int size(); //returns number of key/object pairs in table public abstract boolean isempty(); public abstract Object put(object key, Object value); //inserts value with key. If key already there, it overwrites the value and returns it; else it returns null. public abstract Object remove(object key); //deletes reference to object represented by key; the object itself, as it exists outside the table is not affected public abstract Enumeration elements(); //returns an enumeration of the elements in the dictionary public abstract Enumeration keys(); //returns enumeration of the keys in the dictionary 9/9/ also supports the methods: public synchronized boolean containskey(object key); public synchronized boolean contains(object element); /*returns true if element is in the hashtable; more expensive operation than containskey because elements are stored based on key */ public synchronized void clear(); //empties the table public synchronized clone(); /*creates clone of the table; keys and elements themselves are not cloned */ Constructors: (); //default initial capacity and load factor of 0.75 (int initialcapacity); //capacity set to initcapacity;load factor 0.75 (int initialcapacity, float loadfactor); //loadfactor is between 0.0 and 1.0; table will resize itself if number of entries increases to more than current capacity * load factor 9/9/ /9/ For-loops vs Enumerations Before using put, it is important to verify that the key about to be inserted in the table is not a duplicate. Student s1 = new Student ( , Eve Brown ); if ( students.containskey( s1.getssn() ) { //This is a duplicate //Details omitted else students.put( s1.getssn(), s1 ); for-loops cannot be used to access elements of a hashtable because elementat(i) makes no sense with a hashtable; elements have no relative position --no meaningful index. for (i=0; i<enrollment.size(); i++) { Student s = (Student) enrollment.elementat(i); s.computefinalgrade(); The Enumeration interface is an alternate way to iterate through the values in a collection via the method Enumeration elements(); 9/9/ /9/

6 Enumerations An Enumeration is a special type of temporary collection used to step through another collection of object references one by one until the Enumeration is empty. The original collection remains unchanged. Original Collection Enumerations The Enumeration class is an abstract superclass defined in java.util There are two methods in the Enumeration interface: public abstract boolean hasmoreelements(); //returns true is there are more elements. This method can be called more than once between successive calls to nextelement(). public abstract Object nextelement(); //returns next element of the enumeration Copy of object handles made by Enumeration 9/9/ /9/ Enumerations - With Vector Enumerations - With Vector coursestaken= new Vector(); Course c1 = new Course( CS101 ); Course c2 = new Course( CS201 ); Course c3 = new Course( CS352 ); coursestaken.add(c1) coursestaken.add(c2); coursestaken.add(c3); Create the vector and fill it with Course objects public class Test { students = new (); Student s1 = new Student ( , Eve Black ); Student s2 = new Student( , Adam Brown ); Student s3 = new Student( , Bobby Green ); students.put(s1.getssn(), s1); students.put(s2.getssn(), s2); students.put(s3.getssn(), s3); Eve Black Adam Brown Bobby Green Enumeration e = coursestaken.elements(); while (e.hasmoreelements() ) { Course c = (Course) e.nextelement(); System.out.println(c); Create an Enumeration of the Vector objects Iterate through the table Enumeration e = students.elements(); System.out.println ( \ncontents of student hashtable: ); while ( e.hasmoreelements() ) { Student s = (Student) e.nextelement(); System.out.println ( \t + s.getname() s.getssn() ); 9/9/ /9/ Enumerations - A second method retrieves an Enumeration of references to the key objects Keys are String objects Enumeration e = students.keys(); while (e.hasmoreelements() ) { String key = (String) e.nextelement(); Student s = (Student) students.get(key); System.out.println( \t + s.getname() s.getssn()); Use the key to look up the student 9/9/