chapter 7
Download
Skip this Video
Download Presentation
Chapter 7

Loading in 2 Seconds...

play fullscreen
1 / 39

Arrays: Part 2 - PowerPoint PPT Presentation


  • 118 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Arrays: Part 2' - tiponya


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapter 7

Chapter 7

Arrays: Part 2

outline
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

arrays of objects
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

arrays of objects4

-

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

arrays of objects5

“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

arrays of objects one way to initialize an array of string objects
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

arrays of objects7
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

arrays of objects8

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

slide9

// 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

slide10

// 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

slide11

// 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

slide12

// 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

command line arguments covered earlier in course
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

outline14
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

variable length parameter lists
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

variable length parameter lists16
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

variable length parameter lists17

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

variable length parameter lists18
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

variable length parameter lists19
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

slide20

//********************************************************************//********************************************************************

// 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

slide21

// 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

variable length parameter lists22
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

variable length parameter lists23
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

slide24

//********************************************************************//********************************************************************

// 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

slide25

// 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

outline26
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

two dimensional arrays

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

two dimensional arrays28
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

two dimensional arrays29
Two-Dimensional Arrays
  • See TwoDArray.java (page 399)
  • See SodaSurvey.java(page 400)

© 2004 Pearson Addison-Wesley. All rights reserved

slide30

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

slide31

// 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

multidimensional arrays
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

slide33

 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

outline34
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

the arraylist class
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

the arraylist class36
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

the arraylist class37
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

slide38

// 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

arraylist efficiency
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

ad