7.4 Developing Algorithms Using ArrayLists

Developing Algorithms Using ArrayLists

Introduction to Developing Algorithms Using ArrayLists

ArrayLists are one of the most versatile data structures in Java. They allow dynamic resizing, easy manipulation of elements, and provide robust methods for handling data. When it comes to Developing Algorithms Using ArrayLists, these features make ArrayLists indispensable for creating efficient and reusable code. In this guide, we will explore various algorithms tailored for ArrayLists, each explained with examples and practical applications.

Standard Algorithms for ArrayLists

Using the traversal techniques and methods specific to ArrayLists, you can implement many algorithms. Below are detailed examples of common algorithms, with annotations to ensure a clear understanding.

Modifying Array Values

Doubling Each Element

/** Doubles each element of the ArrayList */
public static void doubleArray(ArrayList<Integer> array) {
    for (int i = 0; i < array.size(); i++) {
        array.set(i, array.get(i) * 2); // Doubles each individual element
    }
}

This algorithm iterates through the ArrayList and doubles each element.

Modifying Instance Variables of Objects in an ArrayList

Resetting Object Properties

/** Represents a student */
public class Student {
    private String name;

    /** Sets the name of the Student */
    public void setName(String name) {
        this.name = name;
    }
}

// IN ANOTHER CLASS
/** Resets all students' names */
public static void resetStudentNames(ArrayList<Student> array, String defaultName) {
    for (Student student : array) {
        student.setName(defaultName); // Sets each student's name to a default name
    }
}

This algorithm demonstrates modifying instance variables within objects stored in an ArrayList.

Finding the Minimum and Maximum

Finding the Maximum

/** Finds the maximum value in the ArrayList */
public static int maximum(ArrayList<Integer> array) {
    int maxValue = array.get(0);
    for (int number : array) {
        if (number > maxValue) {
            maxValue = number;
        }
    }
    return maxValue;
}

Finding the Minimum

/** Finds the minimum value in the ArrayList */
public static int minimum(ArrayList<Integer> array) {
    int minValue = array.get(0);
    for (int number : array) {
        if (number < minValue) {
            minValue = number;
        }
    }
    return minValue;
}

Tip: Always initialize minValue and maxValue to the first element of the ArrayList to avoid incorrect results.

Finding a Sum

/** Sums up all elements in the ArrayList */
public static int sum(ArrayList<Integer> array) {
    int sum = 0;
    for (int number : array) {
        sum += number;
    }
    return sum;
}

This algorithm calculates the total sum of elements in the ArrayList.

Finding a Mean

/** Finds the mean/average of the ArrayList */
public static double mean(ArrayList<Integer> array) {
    int sum = sum(array); // Use the sum method
    return (double) sum / array.size();
}

This algorithm computes the average value of elements in the ArrayList.

Finding a Mode

/** Finds the mode of the ArrayList */
public static int mode(ArrayList<Integer> array) {
    int mostCommon = 0;
    int mostCommonFrequency = 0;
    for (int i = 0; i < array.size() - 1; i++) {
        int currentFrequency = 1;
        for (int j = i + 1; j < array.size(); j++) {
            if (array.get(j).equals(array.get(i))) {
                currentFrequency++;
            }
        }
        if (currentFrequency > mostCommonFrequency) {
            mostCommon = array.get(i);
            mostCommonFrequency = currentFrequency;
        }
    }
    return mostCommon;
}

Determining If All Values Have a Certain Property

/** Checks if all values are even */
public static boolean isEven(ArrayList<Integer> array) {
    for (int number : array) {
        if (number % 2 != 0) {
            return false;
        }
    }
    return true;
}

This algorithm verifies if all elements in the ArrayList satisfy a specific condition.

Accessing All Consecutive Sequences of Length n

/** Returns all consecutive sequences of length n */
public static void returnAllConsecutiveSequences(ArrayList<Integer> array, int length) {
    for (int i = 0; i <= array.size() - length; i++) {
        for (int j = 0; j < length; j++) {
            System.out.print(array.get(i + j) + " ");
        }
        System.out.println();
    }
}

This algorithm prints all consecutive subsequences of a given length.

Checking for Duplicates

/** Checks if there are duplicate elements */
public static boolean duplicates(ArrayList<Integer> array) {
    for (int i = 0; i < array.size() - 1; i++) {
        for (int j = i + 1; j < array.size(); j++) {
            if (array.get(j).equals(array.get(i))) {
                return true;
            }
        }
    }
    return false;
}

Shifting Elements

Shifting Left

/** Shifts elements one index to the left */
public static ArrayList<Integer> shiftLeft(ArrayList<Integer> array) {
    int firstItem = array.get(0);
    for (int i = 0; i < array.size() - 1; i++) {
        array.set(i, array.get(i + 1));
    }
    array.set(array.size() - 1, firstItem);
    return array;
}

Shifting Right

/** Shifts elements one index to the right */
public static ArrayList<Integer> shiftRight(ArrayList<Integer> array) {
    int lastItem = array.get(array.size() - 1);
    for (int i = array.size() - 1; i > 0; i--) {
        array.set(i, array.get(i - 1));
    }
    array.set(0, lastItem);
    return array;
}

Reversing an ArrayList

/** Reverses the ArrayList */
public static ArrayList<Integer> reverse(ArrayList<Integer> array) {
    ArrayList<Integer> newArray = new ArrayList<>();
    for (int i = array.size() - 1; i >= 0; i--) {
        newArray.add(array.get(i));
    }
    return newArray;
}

Converting Between Arrays and ArrayLists

ArrayList to Array

/** Converts an ArrayList to an Array */
public static int[] arrayListToArray(ArrayList<Integer> array) {
    int[] newArray = new int[array.size()];
    for (int i = 0; i < array.size(); i++) {
        newArray[i] = array.get(i);
    }
    return newArray;
}

Array to ArrayList

/** Converts an Array to an ArrayList */
public static ArrayList<Integer> arrayToArrayList(int[] array) {
    ArrayList<Integer> newArray = new ArrayList<>();
    for (int i : array) {
        newArray.add(i);
    }
    return newArray;
}

Conclusion

Developing Algorithms Using ArrayLists equips programmers with the ability to handle dynamic data efficiently. From basic operations like finding the sum to advanced tasks like reversing an ArrayList or checking for duplicates, the versatility of ArrayLists is unmatched. Practice these algorithms regularly to build a solid foundation in Java programming.