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

2. 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

3. 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

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

5. Two-Dimensional Arrays with Rows of Different Lengths

6. 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.

7. 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).

8. 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.

9. 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

10. 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

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

12. 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;

13. 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.

14. // 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}};

15. 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.

16. 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.

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

18. 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.

19. 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).

20. Some methods and properties of class ArrayList<T>.

21. 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));

22. 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()); }

23. 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

24. 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