Java ArrayLists: Definition, Accessing Elements

Arrays and ArrayLists

• Storing similar data or objects is common in programming
• Declaring variables for each data point is cumbersome
• Java offers several approaches for managing collections: ArrayLists, Arrays, Sets, Maps, etc.

ArrayLists

• ArrayLists must be imported from the java.util.ArrayList package
• An ArrayList is a linear collection or list of objects
• Primitive data types must be wrapped in their corresponding classes for storage in an ArrayList
• int x = 5 cannot be stored directly as an int in an ArrayList, instead Integer y = new Integer(5) should be used
• ArrayLists can dynamically grow or shrink in size as needed
• You can add or remove objects from an Arraylist at any time

Accessing Elements of an ArrayList

• Objects in an ArrayList are referred to as elements
• An Element's position in the list is its index
• The first element is at index 0
• The last element's index is positioned at .size() - 1
• Elements in an ArrayList can be accessed using the .get() method
• A valid integer index between zero and the size of the array must be used to pull elements
• An IndexOutOfBounds exception will be caused if the index is outside of these bounds

ArrayList Methods

• add(): Appends an element to the end of the list or inserts an element at a specified index
• clear(): Removes all elements from the list
• contains(): Determines if the list contains a specified element
• get(): Returns the element at a specified index
• isEmpty(): Checks if the list has no elements
• indexOf(): Returns the index of the first occurrence of a specified element, or -1 if not found
• remove(): Removes the element at a specified position or the first element matching a given object
• set(): Replaces an element with another element, returning the previous one
• size(): Returns the number of elements in the list

Arrays

• Arrays share similarities with ArrayLists
• Arrays are fixed in size once declared
• When declaring an array, the data type and the number of elements must be specified
• Arrays can store any type, but must only store elements of that type
• Arrays can store primitives, without needing wrappers

Accessing Elements in Arrays

• Elements are accessed using indexes, also called positions or subscripts
• Indexes are numbered starting from 0, similiar to ArrayList
• Square brackets are used instead of .get() to access elements
• A sample call is: String person = people[2]
• The .length field is used to determine array length
• An example call is: int numPeople = people.length

Array properties

• Arrays can be initialized with values upon creation or filled later
• Care must be taken when accessing array elements that have not been assigned values
• Memory for an array is allocated upon declaration
• This is because the program knows the length and size of elements
• With int[] myArray = new int[4] the elements have space saved in memory as myArray[0] myArray[1] myArray[2] myArray[3]
• The array variable stores the address of these locations

Array Memory

• Assigning one array to another (e.g., otherArray = myArray) means both variables now point to the same memory locations
• Modifying one array will affect the other, as they share the same reference
• To create separate copies, each element must be copied individually using a loop
• Strings and other objects are stored by reference in the array

Enhanced For Loops

• Enhanced for loops, or for-each loops, provide a simpler syntax for iterating over arrays and ArrayLists
• They avoid having to manage indexes manually
• Enhanced for loops are more efficient when iterating over all objects in a collection
• Enhanced for loops do not work when:
  • Arrays need to be iterated backwards
  • Accessing elements of two arrays at once
  • Attempting to assign new values
  • Only partially filled arrays need to be iterated

Parallel and Partially Filled Arrays

• Parallel arrays are those where elements at the same indexes in each array are related (e.g., student names and corresponding student numbers)
• Arrays can be declared as empty and filled in later, resulting in partially filled arrays

Main Method Arguments

• The main method accepts an array of strings as input, by convention
• These are can be called arguments or args
• It is common to iterate these arguments as part of program execution

Arrays Class Utilities

• The Arrays class that can be imported from java.utils.Arrays provides useful array methods
• Static methodsort sorts elements of an array in ascending order
• Static method binarySearch finds a given element in an array and returns element-number
  • Must be sorted to use

Sort Details

• The sort method is static
• Accepts multiple types of input
• Arrays of primitives (int, char, byte, float, double), arrays of Objects that have compareTo() methods implemented
• When an array's elements are being called by different kinds of input it is referred to as being overloaded

Binary Search

• Similarly to Sort, binarySearch() is an overloaded method.
• Accepts two arguments: the array to be searched and the value to search for
• This requires an ascending sorted array
• The element index of the search is the return
• If the element can't be found, a negative integer will be returned

Array Problems

• Arrays are often tasked with
• Sum of elements
• Average/mean of elements
• Determining the greatest/smallest of its elements
• Determine index of max/min element

Arrays vs. ArrayLists

• Arrays: store objects or primitives, fixed length, length field, must specify elements specified type
• ArrayLists: store objects, variable length, size() method, store elements of any type, but not recemmended

Converting Between Arrays and ArrayLists

• To convert an ArrayList to an array, use the toArray() method
• To convert an array to an ArrayList, use a for loop or the addAll() method from java.util.Collections

Explore the use of ArrayLists in Java for storing and managing collections of objects. Learn how ArrayLists dynamically grow or shrink and how to access elements using their index positions. Understand the concept of primitive data types and how they are wrapped.