Scribd
Upload
69 views5 pages

The ArrayList Short Lecture

ArrayList is a dynamic array implementation of the List interface that allows elements to be added and removed dynamically. It provides utility methods to add, access, remove and iterate through elements. Some key methods are add() to append elements, get() to access elements by index, remove() to delete elements, size() to get count and clear() to remove all elements. ArrayLists are more flexible than arrays but can be slower and use more memory.

Uploaded by

Rohit Joshi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
69 views5 pages

The ArrayList Short Lecture

ArrayList is a dynamic array implementation of the List interface that allows elements to be added and removed dynamically. It provides utility methods to add, access, remove and iterate through elements. Some key methods are add() to append elements, get() to access elements by index, remove() to delete elements, size() to get count and clear() to remove all elements. ArrayLists are more flexible than arrays but can be slower and use more memory.

Uploaded by

Rohit Joshi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

ArrayList in Java

Introduction:

ArrayList is a part of the Java Collection Framework that provides us with dynamic arrays. It's a resizable
array implementation of the List interface. Unlike arrays, ArrayLists can dynamically grow and shrink in
size as elements are added or removed. It provides us with several utility methods to manipulate the
elements efficiently.

Declaration and Initialization:

To use an ArrayList in Java, you need to import the java.util package at the beginning of your code.
Here's how you declare and initialize an ArrayList:

import java.util.ArrayList;

// Declaration

ArrayList<String> myArrayList;

// Initialization

myArrayList = new ArrayList<String>(); // Creating an empty ArrayList

// You can also create and initialize with elements

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

Basic Operations:

1. Adding Elements:

.add(element) - Appends the specified element to the end of the ArrayList.

myArrayList.add("Apple");

myArrayList.add("Banana");

myArrayList.add("Orange");

2. Accessing Elements:

.get(index) - Returns the element at the specified index in the ArrayList.

String fruit = myArrayList.get(1); // Retrieves the element at index 1 (Banana)

3. Removing Elements:
.remove(index) - Removes the element at the specified index from the ArrayList.

.remove(object) - Removes the first occurrence of the specified element from the ArrayList.

myArrayList.remove(2); // Removes the element at index 2 (Orange)

myArrayList.remove("Apple"); // Removes the element "Apple" from the ArrayList

4. Size and Checking:

.size() - Returns the number of elements in the ArrayList.

.isEmpty() - Checks if the ArrayList is empty or not.

int size = myArrayList.size(); // Gets the size of the

ArrayList boolean isEmpty = myArrayList.isEmpty(); // Checks if the ArrayList is empty

5. Iterating through ArrayList:

Using enhanced for loop

Using Iterator

// Using enhanced for loop

for (String fruit : myArrayList)

System.out.println(fruit);

// Using Iterator

Iterator<String> iterator = myArrayList.iterator();

while (iterator.hasNext())

System.out.println(iterator.next());

}
Here are some key methods along with examples:

1. Adding Elements:

add(E element)

Adds the specified element at the end of the ArrayList.

Example:

rrayList<String> fruits = new ArrayList<>();

fruits.add("Apple");

fruits.add("Banana");

add(int index, E element)

Inserts the specified element at the specified position in the ArrayList.

Example:

fruits.add(1, "Orange"); // Adds "Orange" at index 1

2. Accessing Elements:

get(int index)

Returns the element at the specified index in the ArrayList.

Example:

String fruit = fruits.get(0); // Retrieves the element at index 0 (Apple)

3. Removing Elements:

remove(int index)

Removes the element at the specified index from the ArrayList.

Example:

fruits.remove(1); // Removes the element at index 1 (Banana)

remove(Object obj)

Removes the first occurrence of the specified element from the ArrayList.

Example:
fruits.remove("Apple"); // Removes the element "Apple" from the ArrayList

4. Checking and Retrieval:

size()

Returns the number of elements in the ArrayList.

Example:

int size = fruits.size(); // Gets the size of the ArrayList

isEmpty()

Checks if the ArrayList is empty or not.

Example:

boolean isEmpty = fruits.isEmpty(); // Checks if the ArrayList is empty

5. Iterating through ArrayList:

Using Enhanced For Loop:

Example:

for (String fruit : fruits) { System.out.println(fruit); }

Using Iterator:

Example:

Iterator<String> iterator = fruits.iterator();

while (iterator.hasNext())

{ System.out.println(iterator.next()); }

6. Conversion to Array:

toArray()

Converts the ArrayList to an array.

Example:

String[] fruitsArray = fruits.toArray(new String[0]);

7. Clearing the ArrayList:


clear()

Removes all elements from the ArrayList.

Example:

fruits.clear(); // Clears all elements from the ArrayList

These methods provide versatile functionality for handling ArrayLists in Java. Is there any specific
method or functionality you'd like to explore further?

Advantages of ArrayList:

Dynamic Size: ArrayLists can grow and shrink dynamically, unlike arrays.

Generics: Type safety is provided as ArrayLists can be parameterized with types.

Various Methods: It offers numerous methods for manipulation like adding, removing, accessing
elements, etc.

Disadvantages of ArrayList:

Slower Performance: Compared to arrays, ArrayLists can be slower due to their dynamic resizing nature.

Memory Overhead: ArrayLists consume more memory than arrays as they store additional information
for flexibility.

You might also like