En este post veremos cómo encontrar o buscar un elemento dentro de un ArrayList de Java. Para ello veremos el método contains e indexOf, además del método equals de las clases.

Buscar elemento en ArrayList de Java

El método más fácil y que funciona en la mayoría de lenguajes es recorrer la lista en cuestión y comparar cada elemento con la búsqueda.

• Si se encuentra, se detiene el ciclo y se devuelve el resultado.
• Si no, se devuelve null o -1 dependiendo de la situación.

Pero en Java, un ArrayList provee el método contains e indexOf que podemos usar para estos propósitos. Lo único que hay que hacer es sobrescribir dos métodos de los objetos.

Y no te preocupes, si no te gusta, al final dejaré un ejemplo para poder buscar un elemento en ArrayList de Java simplemente recorriendo el ArrayList.

Buscar elemento con contains

Si queremos saber simplemente si un elemento existe dentro de un ArrayList invocamos a contains que devuelve un booleano.

/*
 Buscar elemento en ArrayList de Java
 usando contains

 https://parzibyte.me/blog
*/import java.util.ArrayList;

class Main {
 public static void main(String[] args) {
  
  ArrayList<String> canciones = new ArrayList<>();
  // Le agregamos datos
  canciones.add("Beds are burning");
  canciones.add("It's only rock 'n' Roll (But I like it)");
  canciones.add("Ashes to ashes");

  String busqueda = "Ashes to ashes";
  boolean existe = canciones.contains(busqueda);
  if (existe) {
   System.out.println("El elemento SÍ existe en la lista");
  } else {
   System.out.println("El elemento no existe");
  }
 }
}

Si el elemento existe, devuelve true, si no, false.

Usar indexOf

Este método devuelve -1 o el índice que el elemento ocupa dentro del ArrayList. Funciona para saber si el elemento existe dentro del ArrayList y para saber cuál índice tiene al mismo tiempo.

Su uso es el siguiente:

/*
 Buscar elemento en ArrayList de Java

 https://parzibyte.me/blog
*/import java.util.ArrayList;

class Main {
 public static void main(String[] args) {
  
  ArrayList<String> canciones = new ArrayList<>();
  // Le agregamos datos
  canciones.add("Beds are burning");
  canciones.add("It's only rock 'n' Roll (But I like it)");
  canciones.add("Ashes to ashes");

  String busqueda = "Ashes to ashes";
  int indice = canciones.indexOf(busqueda);
  if (indice != -1) {
   System.out.println("La búsqueda está en el índice " + indice);
  } else {
   System.out.println("El elemento no existe");
  }
 }
}

En este caso funciona porque String ya es una clase definida y ya tiene su método equals, así que no hay problema al llamar a indexOf pasándole la otra cadena.

Búsqueda con clases que no sean String

Ahora vamos a ver un ejemplo para buscar elemento en ArrayList de Java usando clases propias. Solo hay que sobrescribir el método equals y hashCode.

El método equals y hashCode

¿Has escuchado del método equals en Java? sirve para comparar que dos objetos son iguales, ya que por ejemplo para comparar cadenas en Java se utiliza ese método en lugar del operador ==.

Este método sirve para indicar si dos objetos son iguales, y podemos definirlo a nuestro gusto, la forma más básica es comparar cada propiedad. Veamos un ejemplo de la clase Producto:

class Producto {
    private String codigo, nombre;
    private float precio;

    public Producto() {
    }

    public Producto(String codigo, String nombre, float precio) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Producto producto = (Producto) o;
        return Float.compare(producto.precio, precio) == 0 &&
                codigo.equals(producto.codigo)
                && nombre.equals(producto.nombre);
    }

    @Override
    public int hashCode() {
        return Objects.hash(codigo, nombre, precio);
    }
}

Aunque el código puede parecer confuso, el principio es el mismo: comparar propiedad con propiedad; además de comparar la clase. La mayoría de ocasiones tu IDE puede ayudarte a generar estos métodos.

Una vez que hemos sobrescrito esos métodos, podemos usar indexOf y contains.

Buscar elemento en ArrayList de Java con clase propia usando contains

Veamos el siguiente código:

/*
 Buscar elemento en ArrayList de Java
 usando contains, además de una clase
 propia

 https://parzibyte.me/blog
*/import java.util.ArrayList;
import java.util.Objects;

class Main {
 public static void main(String[] args) {
  
  ArrayList<Producto> productos = new ArrayList<>();
  // Le agregamos datos
  productos.add(new Producto("123", "Gansito", 20f));
  productos.add(new Producto("456", "Galletas Chokis", 12f));
  productos.add(new Producto("7879876456", "Doritos", 5.5f));

  Producto busqueda = new Producto("123", "Gansito", 20f);
  boolean existe = productos.contains(busqueda);
  if (existe) {
   System.out.println("El elemento SÍ existe en la lista");
  } else {
   System.out.println("El elemento no existe");
  }
 }
}

class Producto{
    private String codigo, nombre;
    private float precio;

    public Producto() {
    }

    public Producto(String codigo, String nombre, float precio) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Producto producto = (Producto) o;
        return Float.compare(producto.precio, precio) == 0 &&
                Objects.equals(codigo, producto.codigo) &&
                Objects.equals(nombre, producto.nombre);
    }

    @Override
    public int hashCode() {
        return Objects.hash(codigo, nombre, precio);
    }
}

Además de definir la clase, creamos un ArrayList de tipo Producto. Como hemos sobrescrito correctamente ambos métodos, todo funciona bien.

El método indexOf con una clase propia

Como hemos sobrescrito ambos métodos de la clase, podemos usar normalmente el método indexOf.

Buscar elemento en ArrayList de Java manualmente

Para terminar este post vamos a ver cómo realizar una búsqueda manual, ya lo dije, recorriendo el ArrayList y comparando manualmente.

Voy a usar de nuevo la clase Producto pero ahora no me hace falta hashCode ni equals, solo algunos getters. La clase queda así:

class Producto {
    private String codigo, nombre;
    private float precio;

    public Producto() {
    }

    public Producto(String codigo, String nombre, float precio) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
    }

    public String getCodigo() {
        return codigo;
    }

}

Lo siguiente es definir el ArrayList con la búsqueda:

ArrayList<Producto> productos = new ArrayList<>();
// Le agregamos datos
productos.add(new Producto("123", "Gansito", 20f));
productos.add(new Producto("456", "Galletas Chokis", 12f));
productos.add(new Producto("7879876456", "Doritos", 5.5f));

Producto busqueda = new Producto("123", "Gansito", 20f);

Al final se hace la búsqueda recorriendo el ArrayList. En este caso voy a buscar únicamente si ya existe un producto con el mismo código, no importa que el nombre o el precio no coincidan.

// Voy a buscar únicamente comparando el código
boolean encontrado = false;
for (int x = 0; x < productos.size(); x++) {
  Producto p = productos.get(x);
  if (p.getCodigo().equals(busqueda.getCodigo())) {
    encontrado = true;
    break; // Terminar ciclo, pues ya lo encontramos
  }
}
// Al terminar el ciclo comprobamos si se movió la variable
if (encontrado) {
  System.out.println("El producto existe");
} else {
  System.out.println("El producto NO existe");
}

El código completo queda así:

/*
 Buscar elemento en ArrayList manualmente

 https://parzibyte.me/blog
*/import java.util.ArrayList;

class Main {
 public static void main(String[] args) {

  ArrayList<Producto> productos = new ArrayList<>();
  // Le agregamos datos
  productos.add(new Producto("123", "Gansito", 20f));
  productos.add(new Producto("456", "Galletas Chokis", 12f));
  productos.add(new Producto("7879876456", "Doritos", 5.5f));

  Producto busqueda = new Producto("123", "Gansito", 20f);
  // Voy a buscar únicamente comparando el código
  boolean encontrado = false;
  for (int x = 0; x < productos.size(); x++) {
   Producto p = productos.get(x);
   if (p.getCodigo().equals(busqueda.getCodigo())) {
    encontrado = true;
    break; // Terminar ciclo, pues ya lo encontramos
   }
  }
  // Al terminar el ciclo comprobamos si se movió la variable
  if (encontrado) {
   System.out.println("El producto existe");
  } else {
   System.out.println("El producto NO existe");
  }

 }
}

class Producto {
 private String codigo, nombre;
 private float precio;

 public Producto() {
 }

 public Producto(String codigo, String nombre, float precio) {
  this.codigo = codigo;
  this.nombre = nombre;
  this.precio = precio;
 }

 public String getCodigo() {
  return codigo;
 }

}

Explicación en vídeo

Si no te ha quedado claro, te dejo un vídeo explicativo:

Conclusión

Solo debo agregar una pequeña nota y es que al buscar manualmente dentro del ArrayList, la lógica puede ser movida a una función para tener un código más limpio y ordenado como vimos en la búsqueda binaria.

Te invito a leer más sobre Java.