1 / 39

Chapter 7

Chapter 7. Arrays: Part 2. Outline. Declaring and Using Arrays Arrays of Objects Variable Length Parameter Lists Two-Dimensional Arrays The ArrayList Class. Arrays of Objects. The elements of an array can be object references

tiponya
Download Presentation

Chapter 7

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 7 Arrays: Part 2

  2. Outline Declaring and Using Arrays Arrays of Objects Variable Length Parameter Lists Two-Dimensional Arrays The ArrayList Class © 2004 Pearson Addison-Wesley. All rights reserved

  3. Arrays of Objects • The elements of an array can be object references • The following declaration reserves space to store 5 references to String objects String[] words = new String[5]; • It does NOT create the String objects themselves •  Initially an array of objects holds null references • Each object stored in an array must be instantiated separately © 2004 Pearson Addison-Wesley. All rights reserved

  4. - words - - - - Arrays of Objects • The words array when initially declared: • At this point, the following reference would throw a NullPointerException: System.out.println (words[0]); because the ‘value’ of words[0] is null; that is, it does NOT point to an object. © 2004 Pearson Addison-Wesley. All rights reserved

  5. “friendship” words “loyalty” “honor” - - Arrays of Objects • After some String objects are created and stored in the array: the reference addresses ‘point’ to real String objects. © 2004 Pearson Addison-Wesley. All rights reserved

  6. Arrays of Objects – One way to initialize an array of String objects. • Keep in mind that String objects can be created using literals • (or they may be created by interactive inputs or by command line inputs or by reading from a file, as we will do in Program 5) • The following declaration creates an array object called verbs and fills it with four String objects created using string literals String[] verbs = {"play", "work", "eat", "sleep"}; These are referenced by verbs[0] through verbs[3]. © 2004 Pearson Addison-Wesley. All rights reserved

  7. Arrays of Objects • Now let's look at an example that manages a collection of CD objects • See Tunes.java(page 387) • See CDCollection.java (page 388) • See CD.java (page 391) © 2004 Pearson Addison-Wesley. All rights reserved

  8. Tunes CDCollection - collection : CD[] - count : int - totalCost : double + main (args : String[]) : void + addCD (title : String, artist : String, cost : double, tracks : int) : void + toString() : String - increaseSize() : void CD - title : String - artist : String - cost : double - tracks : int 1 * + toString() : String Arrays of Objects “uses” • A UML diagram for the Tunes program: Note the multiplicity: 1 to ‘0 or more’ Note the aggregation: CD Collection has_a CD…Equivalently, a CD ‘is a part of’ a CD Collection Aggregation: special kind of association © 2004 Pearson Addison-Wesley. All rights reserved

  9. // Tunes.java Author: Lewis/Loftus// Demonstrates the use of an array of objects.//********************************************************************public class Tunes{ // Creates a CDCollection object and adds some CDs to it. Prints // reports on the status of the collection. public static void main (String[] args) { CDCollection music = new CDCollection ();// sets up array of references music.addCD ("Storm Front", "Billy Joel", 14.95, 10); music.addCD ("Come On Over", "Shania Twain", 14.95, 16); music.addCD ("Soundtrack", "Les Miserables", 17.95, 33); music.addCD ("Graceland", "Paul Simon", 13.90, 11); System.out.println (music); music.addCD ("Double Live", "Garth Brooks", 19.99, 26); music.addCD ("Greatest Hits", "Jimmy Buffet", 15.95, 13); System.out.println (music); } // end main()} // end Tunes // Let’s see what methods we get from CD Collection…Invokes Constructor © 2004 Pearson Addison-Wesley. All rights reserved

  10. // CDCollection.java Author: Lewis/Loftus// Represents a collection of compact discs.import java.text.NumberFormat; public class CDCollection{ private CD[] collection; // tells us that there is an array of CDs called collection. CDs are objects. private int count; private double totalCost; // Constructor: Creates an initially empty collection. public CDCollection () // Constructor { collection = new CD[100]; count = 0; totalCost = 0.0; } // Adds a CD to the collection, increasing the size of thecollection if necessary. public void addCD (String title, String artist, double cost, int tracks) { if (count == collection.length) increaseSize(); collection[count] = new CD (title, artist, cost, tracks); totalCost += cost; count++; } © 2004 Pearson Addison-Wesley. All rights reserved

  11. // Returns a report describing the CD collection. public String toString() { NumberFormat fmt = NumberFormat.getCurrencyInstance(); // note this is “local” String report = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"; report += "My CD Collection\n\n"; report += "Number of CDs: " + count + "\n"; report += "Total cost: " + fmt.format(totalCost) + "\n"; report += "Average cost: " + fmt.format(totalCost/count); report += "\n\nCD List:\n\n"; for (int cd = 0; cd < count; cd++) report += collection[cd].toString() + "\n"; // invokes toString for the CDs. (see previous // slide for collection declaration and next slide for the toString for the collection // objects. return report; } // end toString() //----------------------------------------------------------------- // Increases the capacity of the collection by creating a // larger array and copying the existing collection into it. //----------------------------------------------------------------- private void increaseSize () { CD[] temp = new CD[collection.length * 2]; for (int cd = 0; cd < collection.length; cd++) temp[cd] = collection[cd]; collection = temp; } // end increaseSize()} // end CD Collection © 2004 Pearson Addison-Wesley. All rights reserved

  12. // CD.java Author: Lewis/Loftus// Represents a compact disc.import java.text.NumberFormat;public class CD{ private String title, artist; private double cost; private int tracks; // Creates a new CD with the specified information. public CD (String name, String singer, double price, int numTracks) //Constructor { title = name; artist = singer; cost = price; tracks = numTracks; } // end Constructor // Returns a string description of this CD. public String toString() // toString { NumberFormat fmt = NumberFormat.getCurrencyInstance(); String description; description = fmt.format(cost) + "\t" + tracks + "\t"; description += title + "\t" + artist; return description; } // end toString()} // end CD © 2004 Pearson Addison-Wesley. All rights reserved

  13. Command-Line Arguments(Covered earlier in course) • The signature of the main method indicates that it takes an array of String objects as a parameter • These values come from command-line arguments that are provided when the interpreter is invoked • For example, the following invocation of the interpreter passes three String objects into main: > java StateEval pennsylvania texas arizona • These strings are stored at indexes 0-2 of the array parameter of the main method • See NameTag.java (page 393) © 2004 Pearson Addison-Wesley. All rights reserved

  14. Outline Declaring and Using Arrays Arrays of Objects Variable Length Parameter Lists Two-Dimensional Arrays The ArrayList Class © 2004 Pearson Addison-Wesley. All rights reserved

  15. Variable Length Parameter Lists • Suppose we wanted to create a method that processed a different amount of data from one invocation to the next • For example, let's define a method called average that returns the average of a set of integer parameters // one call to average three values mean1 = average (42, 69, 37); // another call to average seven values mean2 = average (35, 43, 93, 23, 40, 21, 75); © 2004 Pearson Addison-Wesley. All rights reserved

  16. Variable Length Parameter Lists • We could define overloaded versions of the average method •  Downside: we'd need a separate version of the method for each parameter count • We could define the method to accept an array of integers • Downside: we'd have to create the array and store the integers prior to calling the method each time •  Instead, Java provides a convenient way to create variable length parameter lists © 2004 Pearson Addison-Wesley. All rights reserved

  17. Indicates a variable length parameter list element type array name Variable Length Parameter Lists • Using special syntax in the formal parameter list, we can define a method to accept any number of parameters of the same type • For each call, the parameters are automatically put into an array for easy processing in the method public double average (int ... list) { // whatever } © 2004 Pearson Addison-Wesley. All rights reserved

  18. Variable Length Parameter Lists public double average (int ... list) { double result = 0.0; if (list.length != 0) { int sum = 0; for (int num : list) sum += num; result = (double)num / list.length; } return result; } Here, ‘num’ is created to be an int and contain the elements of the list: one at a time… © 2004 Pearson Addison-Wesley. All rights reserved

  19. Variable Length Parameter Lists • The type of the parameter can be any primitive (shown in previous slide) or object type (shown in this slide) public void printGrades (Grade ... grades) { for (Grade letterGrade : grades) System.out.println (letterGrade); } Here, Grade is the class and letterGrade is an object of type Grade that will ‘be’ an element of the array, grades: one at a time. Since this is a System.out.println (letterGrade) we are using the toString method of Grade. We are also using the iterator form of the ‘for’. This also assumes that an array of Grades(i.e.grades) has already been built, etc. © 2004 Pearson Addison-Wesley. All rights reserved

  20. //********************************************************************//******************************************************************** // GradeRange.java Author: Lewis/Loftus // // Demonstrates the use of an array of objects. //******************************************************************** public class GradeRange { //----------------------------------------------------------------- // Creates an array of Grade objects and prints them. //----------------------------------------------------------------- public static void main (String[] args)  Note: driver. { Grade[] grades = // creating an array of pointers to grades followed by { // the actual creation of 12 grade objects…. new Grade("A", 95), new Grade("A-", 90), new Grade("B+", 87), new Grade("B", 85), new Grade("B-", 80), new Grade("C+", 77), new Grade("C", 75), new Grade("C-", 70), new Grade("D+", 67), new Grade("D", 65), new Grade("D-", 60), new Grade("F", 0) }; // Note: could have read these in from a file (which we haven’t had yet…) for (Grade letterGrade : grades) // Here, using iterator form of the ‘for’, we System.out.println (letterGrade); // are printing grades using Grade toString } // Can see that after initializing the array } // grades, we are merely printing them out. © 2004 Pearson Addison-Wesley. All rights reserved

  21. // Grade.java Author: Lewis/Loftus Represents a school grade. public class Grade { private String name; private int lowerBound; // Constructor: Sets up this Grade object w/specified grade name and numeric lower bound. public Grade (String grade, int cutoff) //  Used to initialize each of the twelve grade objects. { name = grade; lowerBound = cutoff; } // Returns a string representation of this grade. public String toString() //  Used a lot in next slide. Print out individual grades… { return name + "\t" + lowerBound; } // Name mutator. public void setName (String grade) { name = grade; } // Lower bound mutator. public void setLowerBound (int cutoff) { lowerBound = cutoff; } // Name accessor. public String getName() { return name; } // Lower bound accessor. public int getLowerBound() { return lowerBound; } } © 2004 Pearson Addison-Wesley. All rights reserved

  22. Variable Length Parameter Lists • A method that accepts a variable number of parameters can also accept other parameters • The following method accepts an int, a String object, and a variable number of double values into an array called nums public void test (int count, String name, double ... nums) { // whatever } © 2004 Pearson Addison-Wesley. All rights reserved

  23. Variable Length Parameter Lists • The varying number of parameters must come last in the formal arguments • A single method cannot accept two sets of varying parameters • Constructors can also be set up to accept a variable number of parameters • See VariableParameters.java (page 396) • See Family.java (page 397) © 2004 Pearson Addison-Wesley. All rights reserved

  24. //********************************************************************//******************************************************************** // VariableParameters.java Author: Lewis/Loftus // // Demonstrates the use of a variable length parameter list. //******************************************************************** public class VariableParameters { //----------------------------------------------------------------- // Creates two Family objects using a constructor that accepts // a variable number of String objects as parameters. //----------------------------------------------------------------- public static void main (String[] args) { Family lewis = new Family ("John", "Sharon", "Justin", "Kayla"); Family camden = new Family ("Stephen", "Annie", "Matt", "Mary", "Simon", "Lucy", "Ruthie", "Sam", "David"); System.out.println(lewis); System.out.println(); System.out.println(camden); } } © 2004 Pearson Addison-Wesley. All rights reserved

  25. // Family.java Author: Lewis/Loftus // Demonstrates the use of variable length parameter lists. //******************************************************************** public class Family { private String[] members; //----------------------------------------------------------------- // Constructor: Sets up this family by storing the (possibly // multiple) names that are passed in as parameters. //----------------------------------------------------------------- public Family (String ... names) { members = names; } //----------------------------------------------------------------- // Returns a string representation of this family. //----------------------------------------------------------------- public String toString() { String result = ""; for (String name : members) result += name + "\n";  What does this do? return result; } // end toString() } // end Family © 2004 Pearson Addison-Wesley. All rights reserved

  26. Outline Declaring and Using Arrays Arrays of Objects Variable Length Parameter Lists Two-Dimensional Arrays The ArrayList Class © 2004 Pearson Addison-Wesley. All rights reserved

  27. one dimension two dimensions Two-Dimensional Arrays • A one-dimensional array stores a list of elements • A two-dimensional array can be thought of as a table of elements, with rows and columns © 2004 Pearson Addison-Wesley. All rights reserved

  28. Two-Dimensional Arrays •  To be precise, in Java a two-dimensional array is an array of arrays • A two-dimensional array is declared by specifying the size of each dimension separately: int[][] scores = new int[12][50]; You may interpret this as an array of 12 rows and 50 columns (short, fat…) • A array element is referenced using two index values: value = scores[3][6] •  The array stored in one row can be specified using one index (very important!) (scores[3] is a 1d array.) © 2004 Pearson Addison-Wesley. All rights reserved

  29. Two-Dimensional Arrays • See TwoDArray.java (page 399) • See SodaSurvey.java(page 400) © 2004 Pearson Addison-Wesley. All rights reserved

  30. public class TwoDArray{ //----------------------------------------------------------------- // Creates a 2D array of integers, fills it with increasing // integer values, then prints them out. //----------------------------------------------------------------- public static void main (String[] args) { int[][] table = new int[5][10]; // Load the table with values for (int row=0; row < table.length; row++) for (int col=0; col < table[row].length; col++) table[row][col] = row * 10 + col; //What is being loaded into table elements? // Print the table for (int row=0; row < table.length; row++) { for (int col=0; col < table[row].length; col++) System.out.print (table[row][col] + "\t"); System.out.println(); } // end for } // end main() } // end TwoDArray Make sure you totally understand what is going on here… © 2004 Pearson Addison-Wesley. All rights reserved

  31. // Demonstrates the use of a two-dimensional array.import java.text.DecimalFormat;public class SodaSurvey{ // Determines and prints the average of each row (soda) and each // column (respondent) of the survey scores. public static void main (String[] args) { int[][] scores = { {3, 4, 5, 2, 1, 4, 3, 2, 4, 4},  Here, loading array with hard-coded values… {2, 4, 3, 4, 3, 3, 2, 1, 2, 2}, {3, 5, 4, 5, 5, 3, 2, 5, 5, 5}, {1, 1, 1, 3, 1, 2, 1, 3, 2, 4} }; final int SODAS = scores.length;  See problem description in text to understand problem. final int PEOPLE = scores[0].length; int[] sodaSum = new int[SODAS]; int[] personSum = new int[PEOPLE]; for (int soda=0; soda < SODAS; soda++) for (int person=0; person < PEOPLE; person++) { sodaSum[soda] += scores[soda][person]; personSum[person] += scores[soda][person]; } DecimalFormat fmt = new DecimalFormat ("0.#"); System.out.println ("Averages:\n"); for (int soda=0; soda < SODAS; soda++) System.out.println ("Soda #" + (soda+1) + ": " + fmt.format ((float)sodaSum[soda]/PEOPLE)); System.out.println (); for (int person =0; person < PEOPLE; person++) System.out.println ("Person #" + (person+1) + ": " + fmt.format ((float)personSum[person]/SODAS)); } // end main()} // end SodaSurvey © 2004 Pearson Addison-Wesley. All rights reserved

  32. Multidimensional Arrays • An array can have many dimensions – if it has more than one dimension, it is called a multidimensional array • Each dimension subdivides the previous one into the specified number of elements •  Each dimension has its own length constant • Because each dimension is an array of array references, the arrays within one dimension can be of different lengths • these are sometimes called ragged arrays © 2004 Pearson Addison-Wesley. All rights reserved

  33.  junk[0]  junk[3] Here is an example of a ragged array. It has five rows; Equivalently, it is five single-dimensional arrays – each having a different number of elements. If array were called junk, we could pass junk[0] or junk[4] to another method for processing. Both junk[0] and junk[4] are both arrays but have different lengths. Hence the entire array, junk, is said to be a “ragged array.” If the number of columns were the same above, the array would not be considered ‘ragged’ rather, it would be rectangular. © 2004 Pearson Addison-Wesley. All rights reserved

  34. Outline Declaring and Using Arrays Arrays of Objects Variable Length Parameter Lists Two-Dimensional Arrays The ArrayList Class © 2004 Pearson Addison-Wesley. All rights reserved

  35. The ArrayList Class • The ArrayList class is part of the java.util package • Like an array, it can store a list of values and reference each one using a numeric index •  However, you cannot use the bracket syntax with an ArrayList object • Furthermore, an ArrayList object grows and shrinks as needed, adjusting its capacity as necessary. • Thus we do NOT need an increaseSize() method as we have done in the past! • This is a super nice feature of Java (C does not have this!) • This is called ‘dynamic storage allocation.” Remember this. © 2004 Pearson Addison-Wesley. All rights reserved

  36. The ArrayList Class • Elements can be inserted or removed with a single method invocation • When an element is inserted, the other elements "move aside" to make room • Likewise, when an element is removed, the list "collapses" to close the gap • The indexes of the elements adjust accordingly •  You will be using this in Data Structures. © 2004 Pearson Addison-Wesley. All rights reserved

  37. The ArrayList Class • An ArrayList stores references to the Object class, which allows it to store any kind of object • See Beatles.java (page 405) (next slide…) • We can also define an ArrayList object to accept a particular type of object • The following declaration creates an ArrayList object that only stores Family objects ArrayList<Family> reunion = new ArrayList<Family> • This is an example of generics, which are discussed further in Chapter 12 © 2004 Pearson Addison-Wesley. All rights reserved

  38. // Beatles.java Author: Lewis/Loftus// Demonstrates the use of a ArrayList object.import java.util.ArrayList;public class Beatles{ // Stores and modifies a list of band members. public static void main (String[] args) { ArrayList band = new ArrayList(); band.add ("Paul"); band.add ("Pete"); band.add ("John"); band.add ("George"); System.out.println (band); int location = band.indexOf ("Pete"); band.remove (location); System.out.println (band); System.out.println ("At index 1: " + band.get(1)); band.add (2, "Ringo"); System.out.println (band); System.out.println ("Size of the band: " + band.size()); } // end main()} // end Beatles © 2004 Pearson Addison-Wesley. All rights reserved

  39. ArrayListEfficiency • The ArrayList class is implemented using an underlying array • The array is manipulated so that indexes remain continuous as elements are added or removed • If elements are added to and removed from the end of the list, this processing is fairly efficient • But as elements are inserted and removed from the front or middle of the list, the remaining elements are shifted and this tends to become somewhat inefficient. © 2004 Pearson Addison-Wesley. All rights reserved

More Related