Java SE 8 for Programmers, Third Edition Advanced Java Programming Java SE 8 for Programmers, Third Edition

Contents I Multidimensional Arrays Introduction to Collections and Class ArrayList Object-Oriented Programming(cont’d) Interfaces final Methods and Classes Creating and Using Interfaces Interface Enhancements Exception Handling

Contents II Swing GUI Components Simple GUI-Based Input/Output with JOptionPane Overview of Swing Components Displaying Text and Images in a Window Text Fields and an Introduction to Event Handling with Nested Classes Buttons That Maintain State JComboBox; Using an Anonymous Inner Class for Event Handling Mouse Event Handling Adapter Classes JPanel Subclass for Drawing with the Mouse Introduction to Layout Managers

Contents III Graphics and Java 2D Strings, Characters and Regular Expressions Class String Files, Streams and Object Serialization

Two-Dimensional Arrays with Rows of Different Lengths

Arrays of One-Dimensional Arrays int[][] b = {{1, 2}, {3, 4}} Multidimensional arrays are maintained as arrays of one-dimensional arrays. The initial values are grouped by row in braces. 1 and 2 initialize b[0][0] and b[0][1], 3 and 4 initialize b[1][0] and b[1][1], The compiler counts the number of nested array initializers to determine the number of rows in array b. The compiler counts the initializer values in the nested array initializer for a row to determine the number of columns in that row. array b is actually composed of two separate one-dimensional arrays one containing the value first nested initializer list {1, 2} one containing the values in the second nested initializer list {3, 4}. array b itself is anof two elements, each a one-dimensional array of int values.

Two-Dimensional Arrays with Rows of Different Lengths int[][] b = {{1, 2}, {3, 4, 5}}; creates integer array b with two elements Representing the rows of the two-dimensional array. Each element of b is a reference to a one-dimensional array of int variables. The int array for row 0 is a one-dimensional array with two elements (1 and 2), the int array for row 1 is a one-dimensional array with three elements (3, 4 and 5).

Creating Two-Dimensional Arrays with Array-Creation Expressions int[][] b = new int[3][4]; we use the values 3 and 4 to specify the number of rows and number of columns, but this is not required. Programs can use variables to specify array dimensions new creates arrays at execution time—not at compile time. The elements of a multidimensional array are initialized when the array object is created.

Creating Two-Dimensional Arrays with Array-Creation Expressions A multidimensional array in which each row has a different number of columns can be created int[][] b = new int[2][]; // create 2 rows b[0] = new int[5]; // create 5 columns for row 0 b[1] = new int[3]; // create 3 columns for row 1 This statements create a two-dimensional array with two rows. Row 0 has five columns Row 1 has three columns

Two-Dimensional Array Example: Displaying Element Values public class InitArray { // create and output 2D arrays public static void main(String[] args) int[][] array1 = {{1, 2, 3}, {4, 5, 6}}; int[][] array2 = {{1, 2}, {3}, {4, 5, 6}}; System.out.println ("Values in array1 by row are"); outputArray(array1); // displays array1 by row System.out.printf ("%nValues in array2 by row are%n"); outputArray(array2); // displays array2 by row } // output rows and columns of a 2D array public static void outputArray(int[][] array) { // loop through array's rows for (int row = 0; row < array.length; row++) { // loop through columns of current row for (int column = 0; column < array[row].length; column++) System.out.printf("%d ", array[row][column]); System.out.println(); } } // end class InitArray

Values in array1 by row are 1 2 3 4 5 6 Values in array2 by row are 1 2 3

Common Multidimensional-Array Manipulations Performed with for Statements Many common array manipulations use for statements. The following for statement sets all the elements in row 2 of array a to zero: for (int column = 0; column <a[2].length; column++) a[2][column] = 0; We specified row 2 we know that the first index is always 2 (0 is the first row, and 1 is the second row). This for loop varies only the second index (i.e., the column index). If row 2 of array a contains four elements, then the preceding for statement is equivalent to the assignment statements a[2][0] = 0; a[2][1] = 0; a[2][2] = 0; a[2][3] = 0;

Common Multidimensional-Array Manipulations Performed with for Statements The nested for statement totals the values of all the elements in array a: int total = 0; for (int row = 0; row < a.length; row++) { for (int column = 0; column < a[row].length; column++) total += a[row][column]; } These nested for statements total the array elements one row at a time. The outer for statement begins by setting the row index to 0 so that the first row’s elements can be totaled by the inner for statement. The outer for increments row to 1 so that the second row can be totaled. The outer for increments row to 2 so that the third row can be totaled. The variable total can be displayed when the outer for statement terminates.

// an example of two-dimensional array int[][] grades = {{87, 96, 70}, {68, 87, 90}, {94, 100, 90}, {100, 81, 82}, {83, 65, 85}, {78, 87, 65}, {85, 75, 83}, {91, 94, 100}, {76, 72, 84}, {87, 93, 73}};

Introduction to Collections and Class ArrayList The Java API provides several predefined data structures, called collections, used to store groups of related objects in memory. These classes provide efficient methods that organize, store and retrieve your data without requiring knowledge of how the data is being stored. This can reduce application-development time and help you produce higher-quality, better-performing software.

Introduction to Collections and Class ArrayList Arrays are used to store sequences of objects. Arrays do not automatically change their size at execution time to add additional elements. The collection class ArrayList<T> (package java.util) provides a convenient solution to this problem it can dynamically change its size to accommodate more elements. The T (by convention) is a placeholder when declaring a new ArrayList, replace it with the type of elements that you want the ArrayList to hold.

Class ArrayList<T> java.lang.Object java.util.AbstractCollection<T> java.util.AbstractList<T> java.util.ArrayList<T>

Introduction to Collections and Class ArrayList ArrayList<String> list; declares list as an ArrayList collection that can store only Strings. Classes with this kind of placeholder that can be used with any type are called generic classes. Only nonprimitive types can be used to declare variables and create objects of generic classes. Boxing mechanism allows primitive values to be wrapped as objects for use with generic classes.

Boxing Mechanism ArrayList<Integer> integers; declares integers as an ArrayList that can store only Integers. When you place an int value into an ArrayList<Integer>, the int value is boxed (wrapped) as an Integer object, When you get an Integer object from an ArrayList<Integer>, then assign the object to an int variable, the int value inside the object is unboxed (unwrapped).

Some methods and properties of class ArrayList<T>.

an ArrayList<String> Example import java.util.ArrayList; public class ArrayListCollection { public static void main(String[] args) // create a new ArrayList of Strings with an initial capacity of 10 ArrayList<String> items = new ArrayList<String> (); items.add("red"); // append an item to the list items.add(0, "yellow"); // insert "yellow" at index 0 //header System.out.print( "Display list contents with counter- controlled loop:"); for (int i = 0; i < items.size(); i++) System.out.printf(" %s", items.get(i));

an ArrayList<String> Example // display colors using enhanced for in the display method display(items, "%nDisplay list contents with enhanced for statement:"); items.add("green"); // add "green" to the end of the list items.add("yellow"); // add "yellow" to the end of the list display(items, "List with two new elements:"); items.remove("yellow"); // remove the first "yellow" display(items, "Remove first instance of yellow:"); items.remove(1); // remove item at index 1 display(items, "Remove second list element (green):"); // check if a value is in the List System.out.printf("\red \" is %s in the list%n", items.contains("red") ? "": "not "); // display number of elements in the List System.out.printf("Size: %s%n", items.size()); }

an ArrayList<String> Example // display the ArrayList's elements on the console public static void display(ArrayList<String> items, String header) { System.out.printf(header); // display header // display each element in items for (String item : items) System.out.printf(" %s", item); System.out.println(); } } // end class ArrayListCollection

Output Display list contents with counter-controlled loop: yellow red Display list contents with enhanced for statement: yellow red List with two new elements: yellow red green yellow Remove first instance of yellow: red green yellow Remove second list element (green): red yellow "red" is in the list Size: 2