import java.util.Iterator; /** * I made this to show how the java ArrayList class works. * Feel free to play around with it! * I hope this helps you understand how ArrayLists actually work in Java. */ public class Program { public static void main(String[] args) { // Test the list! ArrayList list = new ArrayList<>(); list.add("banana"); list.add("orange"); list.add("apple"); list.add("pear"); list.add("watermelon"); list.add("tangerine"); list.add("mango"); list.add("strawberry"); list.add("lemon"); list.add("peach"); System.out.println(list.toString()); System.out.println("Size: " + list.size()); System.out.println("Calling: list.remove(1);"); String orange = list.remove(1); System.out.println(list.toString()); System.out.println("Size: " + list.size()); System.out.println("Calling: list.add(9, orange);"); list.add(9, orange); System.out.println(list.toString()); System.out.println("Size: " + list.size()); System.out.println("Calling: list.contains(\"mango\");"); System.out.println(list.contains("mango") + "\n"); System.out.println("Calling: list.contains(\"kiwi\");"); System.out.println(list.contains("kiwi") + "\n"); System.out.println("Calling: list.set(3, \"kiwi\");"); String watermelon = list.set(3, "kiwi"); System.out.println(list.toString()); System.out.println("Size: " + list.size() + "\n"); System.out.println("Calling: list.remove(3);"); String kiwi = list.remove(3); System.out.println(list.toString()); System.out.println("Size: " + list.size() + "\n"); System.out.println("Calling: list.get(3)"); System.out.println(list.get(3) + "\n"); System.out.println("Calling: list.add(watermelon);"); list.add(watermelon); System.out.println(list.toString()); } } class ArrayList implements Iterable { private T[] list; private int size; /** * Default constructor. */ public ArrayList() { // Initialize instance variables. list = (T[]) new Object[4]; size = 0; } /** * Construct an ArrayList and add all the elements of arr to it. * @param arr The elements to add once the ArrayList is constructed. */ public ArrayList(T[] arr) { this(); for (T e : arr) { // add all elements in arr to the list. adjustListLength(); add(e); } } /** * Add an element to the end of list. * @param element The element to add to the list. */ public void add(T element) { adjustListLength(); list[size++] = element; } /** * Add an element to the list at the given index. * @param index The index to add the element at. * @param element The element to add to the list at the given index. */ public void add(int index, T element) { adjustListLength(); // Dynamically update the length of the array. T[] temp = (T[]) new Object[size - index]; for (int i = index; i < size; i++) { temp[size - i - 1] = list[i]; // Add all elements in front of index to a temp array. } list[index] = element; // set the position index in list to the given element. size++; // increase the size of the list by one. for (int i = index + 1; i < size; i++) { list[i] = temp[size - 1 - i]; // Add from the temp array back to the list. } } /** * Get the amount of elements in the list (the size of the list). * @return The size of the list. */ public int size() { return size; } /** * Get whether or not the list is empty * @return true if this list contains no elements, otherwise returns false. */ public boolean isEmpty() { return size == 0; // yuh } /** * Get an element at the given index. * @param index The index to get the element of the list from. * @return The element at the given index. */ public T get(int index) { return list[index]; // yuh yuh } /** * Get the index of a given element. * @param element The element to get the index of. * @return the index of the element in the list. If the element is not in the list, returns -1. */ public int indexOf(T element) { for (int i = 0; i < size; i++) { // Iterate through the list. if (list[i].equals(element)) { // If the given element equals the element at index i. return i; // return the index. } } return -1; // Return '-1' if the given element is not in the list. } /** * Get whether or not the list contains a given element. * @param element The element look for in the list. * @return

true if the given element is in the list, otherwise returns false.
     */
    public boolean contains(T element) {
        return indexOf(element) != -1; // If the indexOf the given element is '-1', it isn't in the list.
    }
    
    /**
     * Set the given index to point to the given element.
     * @param index The index to set element to.
     * @param element The element to set at index.
     * @return The element that previously was at the given index.
     */
    public T set(int index, T element) {
        T old = list[index]; // Hold the element that previously occupied list[index].
        list[index] = element; // Set list[index] to the new element.
        
        return old;
    }
    
    /**
     * Remove an element from the list, given its index.
     * @param index The index of the element to be removed.
     * @return The removed element.
     */
    public T remove(int index) {
        adjustListLength(); // Dynamically adjust thge length of the list.
        T temp = list[index];
        
        list[index] = null;
        
        for (int i = index; i < size; i++) { // shift elements back one.
            list[i] = list[i + 1];
        }

        size--;
        
        return temp;
    }
    
    /**
     * Removes the first element equal to the given element from the list.
     * @param element The element to remove from the list.
     * @return true if the operation was successful, otherwise returns false.
     */
    public boolean remove(T element) {
        adjustListLength();
        
        int index = indexOf(element);
        
        if (index == -1) // If the element is not in the list.
            return false;
        
        remove(index); // Remove the element from the list.
        
        return true;
    }
    
    /**
     * Clear the list.
     */
    public void clear() {
        this.list = (T[]) new Object[4];
        size = 0;
    }
    
    
    @Override
    public Iterator iterator() {
        Iterator it = new Iterator() {
            
            // The iterator's index.
            int index = 0;
            

            @Override
            public boolean hasNext() { // Checks if there is another element next.
                return index < size - 1;
            }

            @Override
            public T next() { // Get the next element.
                return list[index++];
            }
            
        };
        
        return it;
    }
    
    @Override
    public String toString() { // Get a string representation of the ArrayList.
        String str = "[";
        for (int i = 0; i < size; i++) {
            str += list[i].toString() + ((i != size - 1)? ", " : "]");
        }
        
        return str;
    }
    
    
    // Dynamically adjust the length of the array. Returns true if the length of the array was adjusted.
    private boolean adjustListLength() {
        if ((size + 1) > list.length) { // Check if the size will be greater than the length of the array.
            T[] tempList = (T[]) new Object[list.length * 2]; // Make a new array, double the size.
            for (int i = 0; i < list.length; i++) { // And for each element in the current array.
                tempList[i] = list[i]; // Add it to the new array.
            }
            
            list = tempList; // Set 'list' to the new array.
            
            return true;
        } else if ((size + 1) < list.length / 2) { // Check if the size will less than half the length of the array.
            
            if (list.length / 2 < 4 || size / 2 < 4) { // 4 is the minimum size of the list.
                return false;
            }
            
            T[] tempList = (T[]) new Object[list.length / 2]; // Make a new array.
            for (int i = 0; i < list.length; i++) { // For each element in the list.
                tempList[i] = list[i]; // Add it to the tempList.
            }
            
            list = tempList; // Set 'list' to the new array.
            
            return true;
        }
    
        return false;
    }
}

How ArrayLists Work in Java