Java ArrayList indexOf() method
Syntax and Examples

Introduction

The indexOf() method in Java's ArrayList is a handy tool for finding the first occurrence of an object within your list. Think of it like searching through a shopping list to see if you already have milk—the method helps you pinpoint its position (or tells you it’s not there).

Syntax

public int indexOf(Object o)

Parameters

Parameter	Description
o	The object to search for within the ArrayList. Can be null.

Return Value

The method returns the index of the first occurrence of the specified element in this list. If the element is not found, it returns -1.

Examples

Example 1: Finding an Existing Element

This example demonstrates how to use indexOf() to find the index of a string that exists in the ArrayList.

import java.util.ArrayList;

public class IndexOfExample1 {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("Bob"); // Adding 'Bob' again to demonstrate first occurrence.

        int index = names.indexOf("Bob");
        System.out.println("Index of Bob: " + index);
    }
}

Index of Bob: 1

Explanation: The code creates an ArrayList named 'names' containing several strings. The indexOf("Bob") call searches for the first occurrence of "Bob" in the list. Since "Bob" is found at index 1, that value is returned and printed to the console.

Example 2: Finding a Non-Existent Element

This example shows what happens when you search for an element that isn't present in the ArrayList.

import java.util.ArrayList;

public class IndexOfExample2 {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        int index = numbers.indexOf(40); // Searching for 40, which is not in the list.
        System.out.println("Index of 40: " + index);
    }
}

Index of 40: -1

Explanation: In this case, the ArrayList 'numbers' doesn't contain the value 40. Therefore, indexOf(40) returns -1, indicating that the element was not found.

Example 3: Searching for Null

This example illustrates how to use indexOf() to search for a null value in an ArrayList.

import java.util.ArrayList;

public class IndexOfExample3 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("Hello");
        strings.add(null);
        strings.add("World");

        int index = strings.indexOf(null);  // Searching for null value.
        System.out.println("Index of null: " + index);
    }
}

Index of null: 1

Explanation: This code adds a null value to the ArrayList 'strings'. The call indexOf(null) correctly identifies the index where the null is located, which is at position 1.

Example 4: Using indexOf with Objects and Equality

This example shows how object equality affects the results of `indexOf()`. The method uses the equals() method to determine if two objects are equal.

import java.util.ArrayList;

class MyObject {
    private String name;

    public MyObject(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;  // Same object reference
        if (obj == null || getClass() != obj.getClass()) return false; // Different types
        MyObject other = (MyObject) obj;
        return name.equals(other.name);  // Compare based on 'name'
    }

    @Override
    public int hashCode() {
        return name.hashCode(); // Important for consistent hashing and equals
    }
}

public class IndexOfExample4 {
    public static void main(String[] args) {
        ArrayList<MyObject> objects = new ArrayList<>();
        objects.add(new MyObject("Apple"));
        objects.add(new MyObject("Banana"));
        objects.add(new MyObject("Apple")); // Another object with the same name as the first.

        MyObject apple = new MyObject("Apple");
        int index = objects.indexOf(apple);  // Searching for 'apple' using equals()
        System.out.println("Index of Apple: " + index);
    }
}

Index of Apple: 0

Explanation: This example defines a custom class MyObject and overrides the equals() method to compare objects based on their 'name' attribute. When we call indexOf(apple), it doesn't compare object references directly; instead, it uses the overridden equals() method. The first object with the name "Apple" is found at index 0.