kristofer / ArrayList class

# Java ArrayLists: A Dynamic Alternative to Arrays While Java arrays are powerful, they have a significant complication: their size is fixed once created. Enter ArrayLists - a more flexible, dynamic alternative that automatically grows and shrinks as needed. ArrayLists are part of Java's Collections Framework and offer enhanced functionality for managing groups of objects. ## What Is an ArrayList? An ArrayList is a resizable array implementation of the List interface. Unlike regular arrays, ArrayLists can dynamically change in size during program execution. They store objects rather than primitive types, though Java's autoboxing feature allows them to work seamlessly with primitives too. ## ArrayList vs. Array Key differences between ArrayLists and traditional arrays: - **Dynamic Size**: ArrayLists grow automatically as elements are added - **Object Storage**: ArrayLists store objects, not primitives - **Built-in Methods**: ArrayLists come with useful methods for common operations - **Type Safety**: Generic type parameters ensure type safety at compile time - **Performance**: Traditional arrays have slightly better performance for fixed-size operations ## Creating an ArrayList ```java // Import ArrayList class import java.util.ArrayList; // Create an ArrayList of Strings ArrayList<String> names = new ArrayList<String>(); // Since Java 7, you can use the diamond operator ArrayList<String> names = new ArrayList<>(); // Initialize with elements ArrayList<String> fruits = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange")); ``` The `<String>` syntax represents a generic type parameter, specifying that this ArrayList will contain String objects. ## Common ArrayList Operations ### Adding Elements ```java ArrayList<String> languages = new ArrayList<>(); // Add element at the end languages.add("Java"); languages.add("Python"); // Add element at specific index languages.add(1, "JavaScript"); // Inserts at index 1 // Now contains: [Java, JavaScript, Python] ``` ### Accessing Elements ```java // Get element at specific index String language = languages.get(0); // Returns "Java" // Find index of specific element int index = languages.indexOf("Python"); // Returns 2 ``` ### Modifying Elements ```java // Change element at specific index languages.set(1, "C++"); // Replaces "JavaScript" with "C++" // Now contains: [Java, C++, Python] ``` ### Removing Elements ```java // Remove by index languages.remove(2); // Removes "Python" // Remove by value languages.remove("Java"); // Removes "Java" // Remove all elements languages.clear(); ``` ### Checking Size and Contents ```java // Check if empty boolean isEmpty = languages.isEmpty(); // Returns true if no elements // Get current size int size = languages.size(); // Check if contains element boolean hasJava = languages.contains("Java"); ``` ## Iterating Through ArrayLists ```java // Using standard for loop for (int i = 0; i < languages.size(); i++) { System.out.println(languages.get(i)); } // Using enhanced for loop (for-each) for (String language : languages) { System.out.println(language); } // Using Iterator import java.util.Iterator; Iterator<String> iterator = languages.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } ``` ## AutoBoxing with Primitive Types Since ArrayLists store objects, Java uses autoboxing to convert primitives to their wrapper classes: ```java // ArrayList of Integers (not int) ArrayList<Integer> numbers = new ArrayList<>(); numbers.add(5); // Autoboxing: int to Integer int num = numbers.get(0); // Auto-unboxing: Integer to int ``` ## Practical Examples ### Building a Dynamic To-Do List ```java ArrayList<String> todoList = new ArrayList<>(); todoList.add("Complete assignment"); todoList.add("Read chapter 5"); todoList.add("Call John"); // Mark a task as complete by removing it todoList.remove("Call John"); // Add a high-priority task at the beginning todoList.add(0, "Submit application"); ``` ### Converting Between Arrays and ArrayLists ```java // Convert Array to ArrayList String[] namesArray = {"Alice", "Bob", "Charlie"}; ArrayList<String> namesList = new ArrayList<>(Arrays.asList(namesArray)); // Convert ArrayList to Array String[] backToArray = namesList.toArray(new String[0]); ``` ## When to Use ArrayLists Choose ArrayLists when you: - Don't know the exact size needed in advance - Need to frequently add or remove elements - Need to use the built-in methods for searching, sorting, etc. - Want to avoid manual array resizing logic ## Summary ArrayLists provide a powerful, flexible alternative to traditional arrays in Java. While slightly less efficient for fixed-size operations, they offer significant advantages through their dynamic sizing and rich set of methods. As you develop more complex Java applications, ArrayLists will become an indispensable tool in your programming toolkit. In your next programming exercises, try replacing some of your fixed arrays with ArrayLists and explore how this flexibility simplifies your code and expands your capabilities.