💻AP Computer Science A Unit 7 – ArrayList in AP Computer Science A

What's an ArrayList?

• Dynamic resizable array allows adding, removing, and modifying elements during runtime
• Implements the List interface provides a way to store and manipulate ordered collections
• Can contain duplicate elements and maintains insertion order
• Increases in size automatically when elements added and grows to accommodate new elements
• Can only hold objects cannot store primitive types directly
• Elements can be accessed by their index position starting at 0 for the first element
• Provides more flexibility than traditional arrays but may have slower performance for certain operations

Creating and Initializing ArrayLists

• Declare an ArrayList using the ArrayList class followed by the type of elements in angle brackets

  ArrayList<Type> name;

• Create an instance of ArrayList using the new keyword

  ArrayList<String> list = new ArrayList<>();

  • Diamond operator

    <>

    allows type inference, so the type can be omitted on the right side
• Initialize an ArrayList with elements using array initializer syntax

  ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3));

• Specify an initial capacity to optimize performance if the number of elements is known

  ArrayList<String> names = new ArrayList<>(20);

• Create an empty ArrayList and add elements later using the add() method
• Initialize an ArrayList from another collection using the constructor that takes a Collection parameter

  ArrayList<Integer> newList = new ArrayList<>(oldList);

Adding and Removing Elements

• Add elements to the end of an ArrayList using the add() method

  list.add("apple");

• Insert elements at a specific index using the add(index, element) method shifts subsequent elements to the right

  list.add(1, "banana");

• Remove an element by specifying its value with the remove(Object) method

  list.remove("apple");

  • Removes the first occurrence of the specified element
• Remove an element at a specific index using the remove(int index) method

  list.remove(2);

  • Shifts subsequent elements to the left to fill the gap
• Clear all elements from an ArrayList using the clear() method

  list.clear();

• Check if an ArrayList contains a specific element using the contains(Object) method returns a boolean

  list.contains("apple");

Accessing and Modifying Elements

• Access elements using the get(int index) method returns the element at the specified index

  String element = list.get(0);

• Modify an element at a specific index using the set(int index, Object element) method

  list.set(1, "grape");

  • Replaces the element at the specified index with the new element
• Find the index of the first occurrence of an element using the indexOf(Object) method returns -1 if not found

  int index = list.indexOf("banana");

• Find the index of the last occurrence of an element using the lastIndexOf(Object) method

  int lastIndex = list.lastIndexOf("apple");

• Get the number of elements in an ArrayList using the size() method

  int size = list.size();

• Check if an ArrayList is empty using the isEmpty() method returns a boolean

  boolean empty = list.isEmpty();

ArrayList Methods You Need to Know

• add(Object element): Appends the specified element to the end of the ArrayList
• add(int index, Object element): Inserts the specified element at the specified index
• remove(Object element): Removes the first occurrence of the specified element
• remove(int index): Removes the element at the specified index
• get(int index): Returns the element at the specified index
• set(int index, Object element): Replaces the element at the specified index with the specified element
• indexOf(Object element): Returns the index of the first occurrence of the specified element or -1 if not found
• lastIndexOf(Object element): Returns the index of the last occurrence of the specified element or -1 if not found
• size(): Returns the number of elements in the ArrayList
• isEmpty(): Returns true if the ArrayList is empty, false otherwise
• contains(Object element): Returns true if the ArrayList contains the specified element, false otherwise
• clear(): Removes all elements from the ArrayList
• toArray(): Returns an array containing all elements in the ArrayList

Iterating Through ArrayLists

• Use a for loop to iterate through an ArrayList by index

  for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }

• Use an enhanced for loop (for-each loop) to iterate through an ArrayList

  for (String element : list) { System.out.println(element); }

• Use an iterator to iterate through an ArrayList allows removing elements during iteration

  Iterator<String> iterator = list.iterator();
  while (iterator.hasNext()) {
      String element = iterator.next();
      System.out.println(element);
      if (element.equals("apple")) {
          iterator.remove();
      }
  }
  

• Use the forEach() method with a lambda expression for concise iteration

  list.forEach(element -> System.out.println(element));

• Use the listIterator() method for bidirectional traversal and element modification

ArrayLists vs. Arrays: Pros and Cons

• ArrayLists are dynamic in size can grow or shrink as needed, while arrays have a fixed size determined at creation
• ArrayLists provide methods for adding, removing, and modifying elements, while arrays require manual manipulation
• ArrayLists can only store objects, while arrays can store both primitive types and objects
• Arrays have faster access and traversal times due to their fixed size and contiguous memory allocation
• ArrayLists consume more memory than arrays due to the overhead of the ArrayList object and its resizing mechanism
• Arrays are more efficient for storing and accessing large amounts of data when the size is known in advance
• ArrayLists are more flexible and convenient for most use cases where the size may change dynamically

Common ArrayList Pitfalls and How to Avoid Them

• Forgetting to initialize an ArrayList before using it leads to a NullPointerException
  • Always initialize an ArrayList before adding elements or accessing methods
• Accessing an index that is out of bounds throws an IndexOutOfBoundsException
  • Make sure to check the size of the ArrayList and use valid indices within the range [0, size-1]
• Modifying an ArrayList while iterating over it using a for loop can lead to a ConcurrentModificationException
  • Use an iterator or a listIterator to remove elements during iteration
• Adding or removing elements while iterating over an ArrayList using an enhanced for loop can lead to undefined behavior
  • Use a traditional for loop or an iterator if modification is needed during iteration
• Accidentally modifying the wrong element due to incorrect index calculation
  • Double-check index calculations and use clear variable names to avoid confusion
• Inefficient performance when adding or removing elements from the beginning or middle of a large ArrayList
  • Consider using a LinkedList instead for frequent insertions or deletions in the middle of the list
• Forgetting to update variables or references after modifying an ArrayList can lead to inconsistent state
  • Make sure to update any variables or references that depend on the ArrayList after making changes