Topic 8: Arrays

Part One

• 8.1 Array elements
• 8.2 Declaring and using arrays
• 8.3 Arrays as objects
• 8.4 Command-line arguments
• 8.5 Variable-length parameter lists

(8.1) Array elements

• Arrays are "programming constructs that group data into lists."
  • Not the only kind of lists
  • Less flexible than Python lists

• Referencing an array element:

  x[0]      // minimum index
  x[5]
  x[5] + 1  // part of expression
  x[i + 1]  // computed index
  

(8.2) Declaring and using arrays

• Java arrays are objects; variables must be declared.

  int [] x;
  Object [] objs;
  

• Array types
  • include type of element
  • do not include number of elements

• Creating arrays:

  x = new int[10];
  objs = new Object[5];
  

Example

• Listing 8.1 BasicArray
• Declares, initializes, and prints the elements of an array.

• The for loop is handy:

  for (int i = 0; i < x.length; i++)
    System.out.println(x[i]);
  

  or

  for (int y : x)
    System.out.println(y);
  

Bounds checking

• Java checks index bounds
  • ArrayIndexOutOfBoundsException
  • Compare C, C++
• x.length is the number of elements in array x
  • No parentheses

Example

• Listing 8.2 ReverseOrder
• Uses iteration with reverse indexing to print a list of numbers backward.

Example

• Listing 8.3 LetterCount
• Uses two arrays to count upper and lowercase letters in a String.
• Depends on initializing array elements to zeroes
• String (array-like) is indexed using charAt method
• Calculated subscripts

Alternate array syntax

int [] x; // preferred
int x[];  // also permitted but less perspicuous

The type of x is int [].

Initializer lists

• Arrays can be initialized as they're declared.

• Example:

  int [] x = new int[] {1, 7, -10, 4, 29};
  

• Size of list determines size of array

• Variations

  int [] x = 
    new int[5] {1, 7, -10, 4, 29}; // syntax error
  int [] x = {1, 7, -10, 4, 29}; // not recommended
  

Examples

• Inits.java
• Listing 8.4 Primes
  • Uses an initialization list

Arrays as parameters

1. Entire array as parameter:

   foo(x);
   

   • What is copied?
   • What can the called method mutate?

2. New array object as parameter:

   foo(new int[] {7, 21, 23});
   

3. Array element as a parameter:

   bar(x[5]);
   

   • Same questions

(8.3) Arrays of Objects

An array can be declared with either primitive or reference type elements.

int [] age = new int[4];
String [] size = new String[4];

Primitive Type Elements (1)

int [] age = new int[4];

Array of int, before initialization

Primitive Type Elements (2)

age[0] = 7; age[1] = 25; age[2] = -3; age[3] = 54;

Array of int, after initialization

Reference type elements (1)

String [] size = new String[4];

Array of String, before initialization

Reference type elements (2)

size[0] = "large"; size[1] = "small"; 
size[2] = "medium"; size[3] = "x-large";

Array of String, after initialization

Example

• Listings 8.5/6 GradeRange/Grade
• Uses an array of objects (Grades) to print a table of grades and cutoffs.

Example

• Listings 8.7/9 Movies/DVDCollection/DVD
• Uses a DVDCollection object which contains an array of DVDs
• addDVD inserts new DVD at the end of the list
  • When array is full,
    • Creates new array of twice the size
    • Copies old array into new

(8.4) Command-line arguments

The mystery of public static void main (String [] args)

• String [] args is an array of String
• It captures the command line parameters when the program is run

Example

• Listing 8.10 NameTag

• Expects two arguments; run as

  java NameTag GREETING NAME
  

  (Replace GREETING and NAME with actual values.)

Another Example

Write a program which adds the numbers on its command line and prints the sum.

• Example:

  $ java Adder 10 20 30 40
  100
  

• These parameters are always Strings
• To interpret as numbers, they must be converted
  • Integer.parseInt(args[i])

• Design, develop, and test …

Solution

Variable length parameter lists

• Allows calling a method with variable numbers of parameters:

  foo(12, 9, 8);
  foo(new int [] {12, 9, 8}); // also works
  foo(7, 2, -14, 21, 28, 39);
  

• Declaring the method:

  public void foo (int ... data) { ... }
  

• Varying parameters must be of same type

Syntactic sugar

• Within foo, data is actually an array
• Caller of foo does not need to explicitly create array

• Compiler transforms method declaration and call into:

  public void foo (int [] data) { ... }
  
  foo(new int [] {12, 9, 8});
  foo(new int [] {7, 2, -14, 21, 28, 39});
  

Other Parameters

• Any other named parameters must precede varying parameters

  // okay
  public void foo (int a, int b, int ... data)
  
  // wrong
  public void foo (int ... data, int a, int b)
  

Example

• Listing 8.11/12 VariableParameters/Family
• Uses a constructor with a variable length parameter list

Discussion

Topic 8: Arrays

Part Two

• 8.6 Two-dimensional arrays
• 8.7 Polygons and polylines
• 8.8 Mouse events
• 8.9 Key events

(8.6) Two-dimensional arrays

• Usually represent a table with rows and columns

• Require two subscripts:

  t[2][5] // row, column
  

Example

• Listing 8.13 TwoDArray
• Shows the common use of nested for loops to process a two-dimensional array
  • table.length = number of rows
  • table[row].length = number of columns in current row
  • Rows may have different numbers of elements

Example

• Listing 8.14 SodaSurvey
• Uses nested initialization lists {{...}}
• Computes two averages
  • Row average (four flavors)
  • Column average (10 tasters)

Multidimensional arrays

• Arrays can have more than two dimensions
• Not always the best solution
• An array of objects, with objects containing arrays, is sometimes better

Java Collections Framework (JCF)

• Java has many "collections" classes
• ArrayList is the first one we meet
• In general, collections can store Objects
• But with new generic types, collections can store a specific type of object
  • Any reference type

Generic Types Example

ArrayList<Musician> band = new ArrayList<Musician>();

Advantages:

1. Stricter type checking for elements put into collection
2. Eliminates need for cast when retrieving elements

Without Generic Types

An ArrayList can store any Object as an element.

ArrayList band = new ArrayList();
band.add(new Musician("J. S. Bach"));
band.add(new String("abc")); // undetected error

// retrieval
Object obj = band.get(0);
if (obj instanceof Musician) {
    Musician mus = (Musician) obj; 
    ... 
} 
else 
    System.err.println("Error: ...");

With Generic Types

An ArrayList can store only Musician elements.

ArrayList<Musician> band = new ArrayList<Musician>();
band.add(new Musician("J. S. Bach"));
band.add(new String("abc")); // compiler detects error

// retrieval
Musician mus = band.get(0); // safe and simple

ArrayList Efficiency

(In)efficiency of insert and delete far from the rear of the list, and of expanding and contracting the array.

• Inserting at position k requires moving elements at k + 1 and higher over to make room
• Removing from position k requires moving elements at k + 1 and higher back to fill vacuum
• Insert an element that increases the size of the ArrayList requires copying the existing elements into a new (internal) array that is bigger.

Efficient Collections

• Efficient storage of collections of data is a big subject
• More information in CSCI-C243 Introduction to Data Structures
• Many more interesting structures besides arrays and array lists!

(8.7) Polygons and polylines

• Both contain multiple points
  • Polygon: closed
  • Polyline: open

Drawing Methods

• java.awt.Graphics class

  drawPolygon(xs, ys, n)
  fillPolygon(xs, ys, n)
  drawPolyline(xs, ys, n)
  

• xs, ys: int [] arrays of coordinates

• n: number of points used

Polygon class

• java.awt.Polygon encapsulates xs, ys, n into an object

• Constructors

  Polygon()
  Polygon(xs, ys, n)
  

• Public fields

  int [] xpoints
  int [] ypoints
  int npoints
  

Polygon class, continued

• Some public methods

  addPoint(x, y) // ints
  contains(x, y)
  contains(p)    // Point object
  getBounds()    // bounding rectangle
  translate(dx, dy)
  

• Details: Fig. 8.6

Example

• Listings 8.15/16 Rocket/RocketPanel
• Uses two polygons and a polyline to draw a space ship

Exercise

Revise the Rocket example using Polygon objects

(8.8) Mouse events

One class and two interfaces

• MouseEvent
• MouseListener
• MouseMotionListener

MouseListener Interface

Methods with MouseEvent argument (Fig. 8.7):

mousePressed(event) // mouse button down
mouseReleased(event) // mouse button up
mouseClicked(event) // down then up
mouseEntered(event) // mouse enters component
mouseExited(event) // mouse leaves component

To implement MouseListener, a class must define all five!

MouseMotionListener Interface

Methods:

mouseMoved(event) // mouse moves
mouseDragged(event) // mouse moves with button down

MouseEvent class

• Each of these 7 methods receives a MouseEvent argument

• MouseEvent method

  getPoint() // returns a Point
  

Point class

• java.awt.Point
• Public instance variables x and y

Examples

• Listings 8.17/18 Dots/DotsPanel
• Uses ArrayList to store Points
• Mouse click adds new Point to list and redraws window
• Each point is drawn as a small green circle

Example

• Listings 8.19/20 RubberLines/RubberLinesPanel
• Allows user to draw a line segment
• Mouse press: store one endpoint
• Mouse drag: set opposite endpoint and draw

(8.9) Key events

• Occur when a keyboard key is pressed, released, or typed
• "Typing" is normally pressing and releasing a key
• KeyEvent class
• KeyListener interface

KeyListener Interface

Methods (Fig. 8.8):

• keyTyped: high level
• keyPressed: low level
• keyReleased: low level
• Each receives a KeyEvent argument

Differences

• See API documentation KeyEvent
• "key typed": higher level, represents Unicode character input
  • Some keys do not generate a character (F1, Up)
  • Some characters require a combination of keys (Ctrl+A)
• "key pressed" and "key released": lower level, represent physical actions
  • Ctrl+A
  • Arrows to move objects
  • Shift key to fire "weapons"

Autorepeat

• Holding a key down may cause it to emit its character repeatedly and rapidly
• Controlled by window manager or X Window system
• One key press, one key release, multiple key typed

Focus

• A window or graphics component has keyboard focus if it's the one that receives keyboard input
• Usually a mouse click gives focus
  • Other options (hovering) can be configured in your window manager

• Java method

  setFocusable(true|false)
  

Example

• Listing 8.21/22 Direction/DirectionPanel
• Draws an arrow which moves in response to the arrow keys

• Displays one of four images depending on direction

  new ImageIcon(filename) // create image object
  icon.paintIcon(observer, graphics, x, y)
     // observer can be a JPanel
  

Discussion