Introduction

Learning Outcomes

Basic Concepts

Arrays

• Stores many values of the same type, in order, under a single name.
• Its size is fixed when the array is created and cannot change afterwards.
• The elements sit side by side in contiguous memory slots.
• Element values can always be updated; "inserting" or "deleting" means shifting elements.
• Used to represent matrices, images (pixels), sound (samples), and similar data.

Basic Concepts

Using Arrays: Access by Index

• An element is reached by its index: arrayName[index].
• The first element has index 0, the last length − 1.
• Because the elements are contiguous and equal in size, each address takes one multiplication and one addition to compute.

int[] arr = {7, 2, 9, 5, 1};
int first = arr[0];      // 7
int last = arr[arr.length - 1];      // 1

Basic Concepts

Kinds of Arrays

Basic Concepts

Arrays: Pros and Cons

Basic Concepts

Array Covariance and ArrayStoreException

• Because String is a subtype of Object, String[] counts as a subtype of Object[].
• So one method that takes an Object[] works with any array of references.
• The price: a store of the wrong type is caught at run time, not at compile time.

String[] names = {"Ann", "Alice"};
Object[] objects = names; // compiles
objects[0] = 42;   // compiles, but
                    // throws at run time!

Arrays in Java

Declaring Arrays

DataType[] arrayName = new DataType[arraySize];

int[] nums = new int[5];
// → [0, 0, 0, 0, 0]

Arrays in Java

Access, Initialization, and length

int[] nums = {10, 20, 30, 40, 50};   // 5 initializers → size 5
int first    = nums[0];            // 10
int second = nums[1];            // 20
nums[4] = 55;                         // last element updated
int size   = nums.length;     // 5

nums = new int[] {1, 2, 3};          // later assignment needs new int[]
int[] bad = new int[3] {1, 2, 3};   // compile error: size + list

Arrays in Java · Step through the code

Code Trace: Reading and Writing an Array

int[] nums = {10, 20, 30, 40, 50};
int first    = nums[0];
int second = nums[1];
nums[4] = 55;
int size   = nums.length;
nums = new int[] {1, 2, 3};

The last line of the previous slide (new int[3] {1, 2, 3}) does not compile.

Arrays in Java

Example: Declare, Fill, Print

public class ArrayExample {
    public static void main(String[] args) {
        int[] nums = new int[5];            // 5-element array
        for (int i = 0; i < nums.length; i++)
            nums[i] = (i + 1) * 10;              // 10, 20, 30, 40, 50

        System.out.println("First element: " + nums[0]);
        System.out.println("Third element: " + nums[2]);

        System.out.print("Elements: ");
        for (int x : nums)                       // for-each: when no index is needed
            System.out.print(x + " ");
    }
}

First element: 10
Third element: 30
Elements: 10 20 30 40 50

Arrays in Java · Step through the code

Code Trace: Fill and Print

int[] nums = new int[5];
for (int i = 0; i < nums.length; i++)
    nums[i] = (i + 1) * 10;
System.out.println("First element: "
        + nums[0]);
System.out.println("Third element: "
        + nums[2]);
System.out.print("Elements: ");
for (int x : nums)
    System.out.print(x + " ");

Arrays in Java

Copying Arrays: Reference or Copy?

int[] arr = {1, 2, 3, 4, 5};
int[] ref = arr;   // same object
int[] copy =
    Arrays.copyOf(arr, arr.length);
ref[0] = 99;

Arrays in Java

Ready-Made Array Operations: java.util.Arrays

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
a == b              // false: different objects
Arrays.equals(a, b) // true: same contents
println(a)          // [I@1b6d3586

Arrays in Java

Varargs (Variable-Length Arguments)

static double average(double... arr) {
    if (arr.length == 0)
        return Double.NaN;  // undefined
    var sum = 0.0;
    for (var value : arr)
        sum += value;
    return sum / arr.length;
}

Arrays in Java · Step through the code

Code Trace: average(4, 8, 15)

static double average(double... arr) {
    if (arr.length == 0)
        return Double.NaN;  // undefined
    var sum = 0.0;
    for (var value : arr)
        sum += value;
    return sum / arr.length;
}

Arrays in Java

Arrays in Memory: Stack and Heap

Arrays in Java

"Static" and "Dynamic" Arrays: C vs. Java

int[] dynArr = new int[n];   // room for n elements on the heap
dynArr = null;               // GC may collect it if no other reference exists

Arrays in Java

Index Out of Bounds

• Accessing an index outside the valid range makes Java throw an ArrayIndexOutOfBoundsException (a subclass of IndexOutOfBoundsException).
• If it isn't caught, the program stops. Java checks every access; C doesn't, and silently writes to some other memory.

int[] arr = new int[5];
arr[5] = 1;  // Index 5 out of
              // bounds for length 5
arr[-1] = 1; // same error

if (index >= 0
        && index < arr.length) {
    int value = arr[index];
} else {
    System.out.println("Invalid");
}

Array Algorithms

Reading an Array from the User

The mean, median, and mode programs all start by reading input the same way, so the shared code goes into a helper (the int[] version for the mode is identical):

import java.util.Scanner;

static double[] readArray(Scanner scanner) {
    System.out.print("Enter the array size: ");
    int size = scanner.nextInt();
    double[] arr = new double[size];  // size known only at run time
    for (int i = 0; i < size; i++) {
        System.out.print("Enter element " + (i + 1) + ": "); // count from 1
        arr[i] = scanner.nextDouble();
    }
    return arr;
}

Array Algorithms · Step through the code

Code Trace: readArray(sc)

static double[] readArray(Scanner scanner) {
  System.out.print("Enter the array size: ");
  int size = scanner.nextInt();
  double[] arr = new double[size];
  for (int i = 0; i < size; i++) {
    System.out.print("Enter element " + (i + 1) + ": ");
    arr[i] = scanner.nextDouble();
  }
  return arr;
}

Array Algorithms

Computing the Mean

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    double[] arr = readArray(sc);
    double sum = 0;
    for (int i = 0; i < arr.length; i++)
        sum += arr[i];
    double average = sum / arr.length;
    System.out.println("Array: "
        + Arrays.toString(arr));
    System.out.println("Average: "
        + average);
    sc.close();
}

Array Algorithms · Step through the code

Code Trace: Computing the Mean

double[] arr = readArray(sc);
double sum = 0;
for (int i = 0; i < arr.length; i++)
    sum += arr[i];
double average = sum / arr.length;
System.out.println("Array: "
    + Arrays.toString(arr));
System.out.println("Average: "
    + average);

Array Algorithms

Computing the Median

static double median(double[] arr) {
    double[] s = arr.clone(); // copy
    Arrays.sort(s);             // O(n log n)
    int size = s.length;
    double median;
    if (size % 2 == 0) {       // even
        int m1 = size/2 - 1, m2 = size/2;
        median = (s[m1] + s[m2]) / 2;
    } else {                    // odd
        median = s[size / 2];
    }
    return median;
}

Array Algorithms · Step through the code

Code Trace: median()

static double median(double[] arr) {
    double[] s = arr.clone(); // copy
    Arrays.sort(s);             // O(n log n)
    int size = s.length;
    double median;
    if (size % 2 == 0) {       // even
        int m1 = size/2 - 1, m2 = size/2;
        median = (s[m1] + s[m2]) / 2;
    } else {                    // odd
        median = s[size / 2];
    }
    return median;
}

Array Algorithms

Mode (the Most Frequent Value)

static int mode(int[] arr) { // not empty
    int[] s = arr.clone();
    Arrays.sort(s);  // equal values side by side
    int best = s[0], bestCount = 1;
    int count = 1;
    for (int i = 1; i < s.length; i++) {
        if (s[i] == s[i - 1]) count++;
        else count = 1;   // new value
        if (count > bestCount) {
            bestCount = count;
            best = s[i];
        }
    }
    return best;
}

Array Algorithms · Step through the code

Code Trace: mode({4, 1, 4, 2, 1, 4})

static int mode(int[] arr) { // not empty
    int[] s = arr.clone();
    Arrays.sort(s);  // equal values side by side
    int best = s[0], bestCount = 1;
    int count = 1;
    for (int i = 1; i < s.length; i++) {
        if (s[i] == s[i - 1]) count++;
        else count = 1;   // new value
        if (count > bestCount) {
            bestCount = count;
            best = s[i];
        }
    }
    return best;
}

Array Algorithms · Step through the code

Reversing an Array in Place

static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start < end) {
        // swap the two outermost elements
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;   // move inward
        end--;
    }
}

Copying back to front into a new array (result[i] = arr[n - 1 - i]) is also O(n) time, but needs O(n) extra space. With an odd number of elements, the middle one stays put.

Array Algorithms · Step through the code

Application: Caesar Cipher encrypt("ZEKA", 3)

static String encrypt(String message, int k) {
    char[] chars = message.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        int pos = chars[i] - 'A';        // 0..25 (A–Z only)
        chars[i] = (char) ('A' + (pos + k) % 26);
    }
    return new String(chars);
}

Multidimensional Arrays

Two-Dimensional Arrays (Matrices)

int[][] matrix = new int[3][3];
matrix[1][2] = 7;   // 2nd row, 3rd column

Multidimensional Arrays

In Java, a Matrix Is an Array of Arrays

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
matrix.length      // 3 (number of rows)
matrix[0].length   // 3 (number of columns)

• The initializer gives no sizes: the number of rows comes from the outer list, the number of columns from the inner lists.
• Each row is a separate array, so rows can differ in length (a jagged array): int[][] tri = new int[3][]; tri[0] = new int[1]; …

Multidimensional Arrays · Step through the code

Jagged Array: Pascal's Triangle

int n = 4;
int[][] p = new int[n][];          // no rows yet
for (int i = 0; i < n; i++) {
    p[i] = new int[i + 1];         // length i + 1
    p[i][0] = p[i][i] = 1;
    for (int j = 1; j < i; j++)
        p[i][j] = p[i-1][j-1] + p[i-1][j];
}

Multidimensional Arrays · Step through the code

Shallow and Deep Copies of a 2D Array

int[][] m = { {1, 2}, {3, 4} };
int[][] s = m.clone();          // shallow copy
s[0][0] = 9;                    // m[0][0] is 9 too!
s[1] = new int[] {7, 8};        // only s changes
int[][] d = new int[2][];       // deep copy:
for (int i = 0; i < 2; i++)
    d[i] = m[i].clone();        // rows too
d[0][1] = 5;                    // m unaffected

Multidimensional Arrays

Example: Fill and Print a Matrix

public class MultiArrayExample {
  public static void main(String[] a) {
    int[][] matrix = new int[3][3];
    // initial values: 1…9
    for (int i = 0; i < 3; i++)      // row
      for (int j = 0; j < 3; j++)    // column
        matrix[i][j] = i * 3 + j + 1;

    System.out.println("Matrix contents:");
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++)
        System.out.print(matrix[i][j] + " ");
      System.out.println();   // new line
    }
  }
}

Matrix contents:
1 2 3
4 5 6
7 8 9

Multidimensional Arrays · Step through the code

Code Trace: Filling the Matrix

int[][] matrix = new int[3][3];
for (int i = 0; i < 3; i++)      // row
  for (int j = 0; j < 3; j++)    // column
    matrix[i][j] = i * 3 + j + 1;
System.out.println("Matrix contents:");
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++)
    System.out.print(matrix[i][j] + " ");
  System.out.println();   // new line
}

Multidimensional Arrays · Step through the code

Code Trace: Printing the Matrix (continued)

int[][] matrix = new int[3][3];
for (int i = 0; i < 3; i++)      // row
  for (int j = 0; j < 3; j++)    // column
    matrix[i][j] = i * 3 + j + 1;
System.out.println("Matrix contents:");
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++)
    System.out.print(matrix[i][j] + " ");
  System.out.println();   // new line
}

Multidimensional Arrays

Three-Dimensional Arrays

• Java allows arrays of three or more dimensions (e.g. time × row × column, or RGB layers).
• Each dimension means one more nested loop: a 3 × 3 × 3 array has 27 elements.

int[][][] array3D =
        new int[3][3][3];
for (int x = 0; x < 3; x++)
  for (int y = 0; y < 3; y++)
    for (int z = 0; z < 3; z++)
      array3D[x][y][z] =
          x * 9 + y * 3 + z + 1;

// printing: the same three loops;
// println after the z loop (y),
// println after the y loop (x)

Non-ASCII letters in a variable name (größe, say) are legal in Java, but ASCII names are preferred for portability.

Multidimensional Arrays

Matrix Transpose

Rows become columns and columns become rows: the transpose of an m×n matrix is n×m.

static int[][] transpose(int[][] m) {
    int rows = m.length;
    int cols = m[0].length;
    int[][] t = new int[cols][rows];
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            t[j][i] = m[i][j];
    return t;
}
static void printMatrix(int[][] m) {
    for (int[] row : m) {
        for (int x : row)
            System.out.print(x + " ");
        System.out.println();
    }
}

Multidimensional Arrays · Step through the code

Code Trace: transpose(m)

static int[][] transpose(int[][] m) {
    int rows = m.length;
    int cols = m[0].length;
    int[][] t = new int[cols][rows];
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            t[j][i] = m[i][j];
    return t;
}

Multidimensional Arrays

Application: Tic Tac Toe

Multidimensional Arrays

Tic Tac Toe: The Main Loop

public class TicTacToe {   // import java.util.Scanner;
    static Scanner scanner = new Scanner(System.in); // single Scanner

    public static void main(String[] args) {
        char[][] board = new char[3][3];   // 3x3 game board
        char player = 'X';                   // X moves first
        boolean gameOn = true;
        initBoard(board);                  // every cell ' '
        while (gameOn) {
            showBoard(board);
            makeMove(board, player);
            gameOn = isGameOn(board, player);
            player = (player == 'X') ? 'O' : 'X';   // switch turns
        }
        showBoard(board);
    }

The cells of new char[3][3] start as '\u0000'; to show empty cells as ' ', the board is filled first. All helper methods are static.

Multidimensional Arrays

Tic Tac Toe: Board and Moves

static void initBoard(char[][] t) {
  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++)
      t[i][j] = ' ';
}
static void showBoard(char[][] t) {
  System.out.println("-------------");
  for (int i = 0; i < 3; i++) {
    System.out.print("| ");
    for (int j = 0; j < 3; j++)
      System.out.print(t[i][j]+" | ");
    System.out.println("\n-------------");
  }
}

static void makeMove(char[][] t,
                     char player) {
  int row, col;
  do {
    System.out.print("Player " + player
      + ": row and column (1-3): ");
    row = scanner.nextInt() - 1;
    col = scanner.nextInt() - 1;
  } while (row < 0 || row > 2
        || col < 0 || col > 2
        || t[row][col] != ' ');
  t[row][col] = player;
}
// the user enters 1-3, the array uses 0-2;
// invalid/occupied cell → ask again

Multidimensional Arrays

Tic Tac Toe: Win or Draw

The 8 winning lines (3 rows + 3 columns + 2 diagonals) are checked with one loop (rows and columns) and a single return (diagonals).

static boolean hasWon(char[][] t, char o) {
    for (int i = 0; i < 3; i++)
        if ((t[i][0] == o && t[i][1] == o && t[i][2] == o)     // row i
         || (t[0][i] == o && t[1][i] == o && t[2][i] == o))    // column i
            return true;
    return (t[0][0] == o && t[1][1] == o && t[2][2] == o)      // main diagonal
        || (t[0][2] == o && t[1][1] == o && t[2][0] == o);     // anti-diagonal
}
static boolean isGameOn(char[][] t, char o) {
    if (hasWon(t, o)) {
        System.out.println("Congratulations, player " + o + " wins!");
        return false;
    }
    for (char[] row : t)
        for (char c : row)
            if (c == ' ') return true;          // an empty cell → continue
    System.out.println("The game is a draw.");
    return false;
}

Multidimensional Arrays · Step through the code

Code Trace: hasWon(t, 'X')

static boolean hasWon(char[][] t, char o) {
  for (int i = 0; i < 3; i++)
    if ((t[i][0] == o && t[i][1] == o
          && t[i][2] == o)   // row i
     || (t[0][i] == o && t[1][i] == o
          && t[2][i] == o))  // column i
      return true;
  return (t[0][0] == o && t[1][1] == o
          && t[2][2] == o)   // main diagonal
      || (t[0][2] == o && t[1][1] == o
          && t[2][0] == o);  // anti-diagonal
}

Complexity

Cost of Array Operations

Complexity describes how running time and memory use grow with the input size n.

Complexity

Accessing an Element: O(1)

• The time doesn't depend on the array's size: it is the same for 5 elements and for 5 million.
• That's because every element's address can be computed: address = start + i × element size.

int[] arr = {10, 20, 30, 40, 50};
int value = arr[2];      // 30 — in one step, O(1)

Complexity · Step through the code

Searching an Array: Linear Search, O(n)

static boolean linearSearch(int[] arr,
                           int target) {
    for (int x : arr)
        if (x == target)
            return true; // found
    return false;
}

Complexity

Finding Common Elements of Two Arrays: O(n·m)

static void printMatches(int[] arr1, int[] arr2) {
    for (int x : arr1)          // n times
        for (int y : arr2)      // m times
            if (x == y)
                System.out.println(
                    "Match: " + x);
}

Complexity · Step through the code

Code Trace: printMatches()