Java Arrays and Methods

Arrays

• Arrays are fixed-size collections of elements with the same data type.
• Declaration: int[] arrayName;
• Initialization: int[] arrayName = new int[size];
• Array size is set when created.
• Array indexes are zero-based (0 to arrayName.length - 1).
• Array references are passed by reference to methods.
• Arrays can be initialized with input values using a loop:

  for (int i = 0; i < arrayName.length; i++) {
    arrayName[i] = scanner.nextInt();
  }
  

• Arrays can be initialized with random values:

  for (int i = 0; i < arrayName.length; i++) {
    arrayName[i] = (int) (Math.random() * 100);
  }
  

• Elements can be displayed using a loop:

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

• Elements can be summed:

  int total = 0;
  for (int num : arrayName) {
     total += num;
  }
  

Finding the Largest Element

• Initialize max to the first element.
• Iterate through the array:
  • If a number is greater than max, update max.

Passing Arrays to Methods

• Arrays are passed by reference, not by value.

Returning Arrays from Methods

• Methods can return arrays.

Searching in Arrays

• Linear Search: Checks each element sequentially.
  • Example (returns index if found, -1 otherwise):

    int linearSearch(int[] array, int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i;
            }
        }
        return -1;
    }
    

• Binary Search: Efficient for sorted arrays.

Sorting Arrays

• Selection Sort: Finds the smallest element and places it first, then repeats.
• Insertion Sort: Builds a sorted list by inserting elements one by one.

ArrayList

• Resizable array implementation of the List interface.
• Declaration: ArrayList<String> list = new ArrayList<>();
• Add elements: list.add("element");
• Access elements: String element = list.get(index);
• Remove elements: list.remove(index);
• Size: int size = list.size();
• Use when dynamic resizing is needed and frequent insertions/deletions are not required.

Recursion

• A method that calls itself directly or indirectly.
• Contains base case(s) to terminate recursion.
• Problems are reduced in each recursive call.
• Example: Factorial calculation (factorial(n)=n*factorial(n-1))
• Avoid deep recursion.

Two-Dimensional Arrays

• Declaration and initialization: int[][] matrix = new int[rows][columns];
• Common operations, including initialization and displaying elements, are demonstrated using loops.

Error Handling: Debugging

• Three main types of errors: Syntax, Runtime, and Logic.
• Syntax errors: Found by compilers, due to incorrect code construction.
• Runtime errors: Cause program termination during execution. Examples include: division by zero, accessing array elements out of bounds.
• Logic errors: Errors that cause the program to behave incorrectly but not terminate.
• Debugging Techniques include Hand-Tracing, Print statements, and Debugger Utilities.

Java Exceptions

• Exceptions represent problems causing a disruption in the normal program flow.
• Exceptions can be Checked (compilation-time checks) and Unchecked (runtime errors; usually subclasses of RuntimeException).
• try-catch blocks handle exceptions.