Learn Java Programming

// Declare and initialize with values
int[] numbers = {10, 20, 30, 40, 50};
String[] fruits = {"Apple", "Banana", "Cherry"};

// Declare with size (elements get default values)
int[] scores = new int[5];         // [0, 0, 0, 0, 0]
String[] names = new String[3];    // [null, null, null]
boolean[] flags = new boolean[4];  // [false, false, false, false]

// Access and modify elements (zero-indexed)
numbers[0] = 100;                 // change first element
System.out.println(numbers[0]);   // 100
System.out.println(numbers[4]);   // 50
System.out.println(numbers.length); // 5

// ArrayIndexOutOfBoundsException if index >= length or < 0
// numbers[5] = 60;  // RUNTIME ERROR!

int[] nums = {5, 10, 15, 20, 25};

// 1. Traditional for loop (when you need the index)
for (int i = 0; i < nums.length; i++) {
    System.out.println("Index " + i + ": " + nums[i]);
}

// 2. Enhanced for-each (preferred for simple iteration)
for (int n : nums) {
    System.out.println(n);
}

// 3. While loop
int i = 0;
while (i < nums.length) {
    System.out.println(nums[i]);
    i++;
}

// 4. Streams (Java 8+)
import java.util.Arrays;
Arrays.stream(nums).forEach(System.out::println);

// 2D array (matrix)
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Access: matrix[row][col]
System.out.println(matrix[0][0]);  // 1
System.out.println(matrix[1][2]);  // 6
System.out.println(matrix[2][1]);  // 8

// Iterate 2D array
for (int row = 0; row < matrix.length; row++) {
    for (int col = 0; col < matrix[row].length; col++) {
        System.out.printf("%3d", matrix[row][col]);
    }
    System.out.println();
}

// Jagged array (rows with different lengths)
int[][] jagged = new int[3][];
jagged[0] = new int[]{1, 2};
jagged[1] = new int[]{3, 4, 5};
jagged[2] = new int[]{6};

import java.util.Arrays;

int[] data = {5, 2, 8, 1, 9, 3};

// Sort
Arrays.sort(data);  // [1, 2, 3, 5, 8, 9]

// Binary search (array MUST be sorted first)
int index = Arrays.binarySearch(data, 5);  // returns index of 5

// Fill
int[] zeros = new int[10];
Arrays.fill(zeros, 42);  // all elements become 42

// Copy
int[] copy = Arrays.copyOf(data, data.length);     // full copy
int[] partial = Arrays.copyOfRange(data, 1, 4);    // [2, 3, 5]

// Compare
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(Arrays.equals(a, b));     // true (content comparison)
System.out.println(a == b);                  // false (reference comparison)

// Print (toString)
System.out.println(Arrays.toString(data));   // [1, 2, 3, 5, 8, 9]
System.out.println(Arrays.deepToString(matrix)); // [[1,2,3],[4,5,6],[7,8,9]]

// Convert to List
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// Note: asList returns a fixed-size list backed by the array

int[] numbers = {4, 7, 2, 9, 1, 5, 8};

// Find maximum value
int max = numbers[0];
for (int n : numbers) {
    if (n > max) max = n;
}
System.out.println("Max: " + max);  // 9

// Sum all elements
int sum = 0;
for (int n : numbers) {
    sum += n;
}
System.out.println("Sum: " + sum);  // 36

// Reverse an array in-place
int left = 0, right = numbers.length - 1;
while (left < right) {
    int temp = numbers[left];
    numbers[left] = numbers[right];
    numbers[right] = temp;
    left++;
    right--;
}

// Check if array contains a value
boolean found = false;
for (int n : numbers) {
    if (n == 9) { found = true; break; }
}
// Or with streams: Arrays.stream(numbers).anyMatch(n -> n == 9);