Minimum and Maximum

The key insight: initialize your running min/max to the first element, then loop from index 1 onward comparing each element.

// Maximum
public static int findMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

// Minimum — identical structure, just flip the comparison
public static int findMin(int[] arr) {
    int min = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

Sum and Average

public static double average(int[] arr) {
    int total = 0;
    for (int x : arr) {
        total += x;
    }
    return (double) total / arr.length;
}

Linear Search

Linear search scans every element from left to right until it finds the target. There are two versions depending on what you need to return.

Version 1: Does the target exist? (returns boolean)

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

The return true is inside the loop — it exits the moment the target is found. The return false is outside — it only runs if the entire array was searched without a match.

Version 2: Where is the target? (returns index)

public static int indexOf(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

Returns the index if found, -1 if not. The convention of returning -1 for "not found" is standard Java practice — String.indexOf() uses the same pattern.

Frequency Count

Count how many elements satisfy a condition:

// Count elements greater than a threshold
public static int countAbove(int[] arr, int threshold) {
    int count = 0;
    for (int x : arr) {
        if (x > threshold) {
            count++;
        }
    }
    return count;
}

The counter starts at 0 and increments every time the condition is true. This pattern handles any condition — equal to a value, greater than, even/odd, negative, etc.

Applying These Algorithms to Object Arrays

All five patterns work identically on arrays of objects — just call the appropriate getter instead of reading a primitive directly:

// Find student with highest score
public static int highestScore(Student[] roster) {
    int max = roster[0].getScore();
    for (int i = 1; i < roster.length; i++) {
        if (roster[i].getScore() > max) {
            max = roster[i].getScore();
        }
    }
    return max;
}

// Count students who passed (score >= 70)
public static int countPassing(Student[] roster) {
    int count = 0;
    for (Student s : roster) {
        if (s.getScore() >= 70) {
            count++;
        }
    }
    return count;
}

Summary

• Min/Max: Initialize to arr[0], loop from index 1, update when a better value is found.
• Sum/Average: Accumulate with total += x; cast to double before dividing for average.
• Linear search (exists): Return true inside loop on match; return false after loop.
• Linear search (index): Return the index inside loop on match; return -1 after loop.
• Frequency count: Initialize count = 0, increment inside loop when condition is true.
• All patterns apply to object arrays by calling getter methods instead of reading primitives.

int[] nums = {3, 7, 2, 9, 4};
findMax(nums);

int max = 0;

int max = arr[0];

int max = Integer.MAX_VALUE;

int max = arr.length;

public static int mystery(int[] arr) {
    int total = 0;
    for (int x : arr) {
        total += x;
    }
    return total / arr.length;
}

int[] arr = {5, 3, 8, 3, 2};
indexOf(arr, 3);

for (int x : arr) {
    if (x == target) {
        return true;
    }
}
return false;

for (int x : arr) {
    if (x == target) {
        return true;
    }
}
return false; // after loop

for (int x : arr) {
    if (x == target) {
        return true;
    }
    return false; // inside loop
}

for (int x : arr) {
    if (x != target) {
        continue;
    }
    return true;
}
return false;

int min = 0;
for (Song s : playlist) {
    if (s.getDuration() < min) {
        min = s.getDuration();
    }
}
return min;

int min = playlist[0].getDuration();
for (int i = 1; i < playlist.length; i++) {
    if (playlist[i].getDuration() < min) {
        min = playlist[i].getDuration();
    }
}
return min;

int min = playlist[0].getDuration();
for (int i = 0; i < playlist.length; i++) {
    if (playlist[i].getDuration() > min) {
        min = playlist[i].getDuration();
    }
}
return min;

int min = playlist.length;
for (Song s : playlist) {
    if (s.getDuration() < min) {
        min = s.getDuration();
    }
}
return min;

int[] vals = {-3, 0, 5, -1, 2, 8};
countAbove(vals, 0);

double sum = 0;
for (double d : data) {
    sum += d;
}
return sum / data.length;

int sum = 0;
for (double d : data) {
    sum += d;
}
return sum / data.length;

double sum = 0;
for (double d : data) {
    sum += d;
}
return (int) sum / data.length;

double sum = 0;
for (int i = 1; i < data.length; i++) {
    sum += data[i];
}
return sum / data.length;

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        return i;
    }
}
return -1;

for (int i = arr.length - 1; i >= 0; i--) {
    if (arr[i] == target) {
        return i;
    }
    return -1;
}

int lastIndex = -1;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        lastIndex = i;
    }
}
return lastIndex;

for (int i = arr.length; i >= 0; i--) {
    if (arr[i] == target) {
        return i;
    }
}
return -1;

int count = 0;
for (Student s : roster) {
    if (s.getName() == 11) {
        count++;
    }
}
return count;

int count = 0;
for (Student s : roster) {
    if (s.getGrade() == 11) {
        count++;
    }
}
return count;

int count = 0;
for (Student s : roster) {
    if (s.getGrade() > 11) {
        count++;
    }
}
return count;

int count = 0;
for (Student s : roster) {
    if (s.getGrade() == 11) {
        return count;
    }
}
return count;