¿Dónde está Java's Array indexOf?

Debo estar perdiendo algo muy obvio, pero he buscado por todas partes y no puedo encontrar este método.

Hay un par de formas de lograr esto usando la Arraysclase de utilidad.

Si la matriz no está ordenada y no es una matriz de primitivas:

java.util.Arrays.asList(theArray).indexOf(o)

Si la matriz es primitiva y no está ordenada, se debe usar una solución ofrecida por una de las otras respuestas, como la de Kerem Baydogan , Andrew McKinlay o Mishax . El código anterior se compilará incluso si theArrayes primitivo (posiblemente emitiendo una advertencia) pero de todos modos obtendrá resultados totalmente incorrectos.

Si la matriz está ordenada, puede hacer uso de una búsqueda binaria de rendimiento:

java.util.Arrays.binarySearch(theArray, o)

La matriz no tiene indexOf()método.

Tal vez este ArrayUtilsmétodo Lang de Apache Commons es lo que estás buscando

import org.apache.commons.lang3.ArrayUtils;

String[] colours = { "Red", "Orange", "Yellow", "Green" };

int indexOfYellow = ArrayUtils.indexOf(colours, "Yellow");

Para las primitivas, si desea evitar el boxeo, Guava tiene ayudantes para matrices primitivas, por ejemplo, Ints.indexOf (int [] array, int target)

No hay ninguno. Utilice un java.util.List* o puede escribir el suyo propio indexOf():

public static <T> int indexOf(T needle, T[] haystack)
{
    for (int i=0; i<haystack.length; i++)
    {
        if (haystack[i] != null && haystack[i].equals(needle)
            || needle == null && haystack[i] == null) return i;
    }

    return -1;
}

_{* puedes hacer uno de tu matriz usando Arrays#asList()}

A diferencia de C # donde tiene el método Array.IndexOf , y JavaScript donde tiene el método indexOf , la API de Java (la ArrayyArrays clases en particular) no tienen dicho método.

Este método indexOf (junto con su complemento lastIndexOf) se define en la interfaz java.util.List . Tenga en cuenta que indexOf y lastIndexOf no están sobrecargados y solo toman un objeto como parámetro.

Si su matriz está ordenada , tiene suerte porque la clase Arrays define una serie de sobrecargas del método binarySearch que encontrará el índice del elemento que está buscando con el mejor rendimiento posible (O (log n) en lugar de O (n ), este último es lo que puede esperar de una búsqueda secuencial realizada por indexOf). Hay cuatro consideraciones:

1. La matriz se debe ordenar en orden natural o en el orden de un comparador que proporcione como argumento, o al menos todos los elementos que son "menores que" la clave debe aparecer antes de ese elemento en la matriz y todos los elementos que son "mayores que" la clave debe venir después de ese elemento en la matriz;

2. La prueba que normalmente realiza con indexOf para determinar si una clave está en la matriz (verificar si el valor de retorno no es -1) no se cumple con binarySearch. Debe verificar que el valor de retorno no sea menor que cero, ya que el valor devuelto indicará que la clave no está presente, pero el índice en el que se esperaría si existiera;

3. Si su matriz contiene múltiples elementos que son iguales a la clave, lo que obtiene de binarySearch no está definido; Esto es diferente de indexOf que devolverá la primera aparición y lastIndexOf que devolverá la última aparición.

4. Una matriz de booleanos puede parecer ordenada si primero contiene todos los falsos y luego todas las verdades, pero esto no cuenta. No hay anulación del método binarySearch que acepta una matriz de booleanos y tendrá que hacer algo inteligente allí si desea un rendimiento O (log n) al detectar dónde aparece la primera verdad en una matriz, por ejemplo, utilizando una matriz de Booleanos y las constantes Boolean.FALSE y Boolean.TRUE.

Si su matriz no está ordenada y no es de tipo primitivo , puede usar los métodos indexOf y lastIndexOf de List invocando asList método de java.util.Arrays. Este método devolverá un contenedor de interfaz AbstractList alrededor de su matriz. Implica una sobrecarga mínima ya que no crea una copia de la matriz. Como se mencionó, este método no está sobrecargado, por lo que solo funcionará en matrices de tipos de referencia.

Si su matriz no está ordenada y el tipo de matriz es primitiva , no tiene suerte con la API de Java. Escriba su propio bucle for, o su propio método de utilidad estática, que sin duda tendrá ventajas de rendimiento sobre el enfoque asList que implica cierta sobrecarga de una instanciación de objeto. En caso de que le preocupe que escribir una fuerza bruta para el bucle que itera sobre todos los elementos de la matriz no sea una solución elegante, acepte que eso es exactamente lo que hace la API de Java cuando llama a indexOf. Puedes hacer algo como esto:

public static int indexOfIntArray(int[] array, int key) {
    int returnvalue = -1;
    for (int i = 0; i < array.length; ++i) {
        if (key == array[i]) {
            returnvalue = i;
            break;
        }
    }
    return returnvalue;
}

Si desea evitar escribir su propio método aquí, considere usar uno de un marco de desarrollo como Guava. Allí puede encontrar una implementación de indexOf y lastIndexOf .

Java ArrayListtiene un indexOfmétodo. Las matrices Java no tienen tal método.

No recuerdo un "indexOf" en matrices que no sea codificarlo usted mismo ... aunque probablemente podría usar uno de los muchos java.util.Arrays#binarySearch(...)métodos (consulte el javadoc de matrices ) si su matriz contiene tipos primitivos

La interfaz de Lista tiene un método indexOf (), y puede obtener una Lista de su matriz con el método asList () de Array. Aparte de eso, Array en sí no tiene tal método. Tiene un método binarySearch () para matrices ordenadas.

Las matrices mismas no tienen ese método. Una lista, sin embargo, sí: indexOf

Probablemente esté pensando en java.util.ArrayList , no en la matriz.

No hay una función indexOf directa en las matrices java.

La respuesta de Jeffrey Hantin es buena, pero tiene algunas limitaciones, si es esto lo que hace o no a eso ...

Puede escribir su propio método de extensión y siempre funciona de la manera que desee.

Lists.indexOf(array, x -> item == x); // compare in the way you want

Y aquí está tu extensión

public final class Lists {
    private Lists() {
    }

    public static <T> int indexOf(T[] array, Predicate<T> predicate) {
        for (int i = 0; i < array.length; i++) {
            if (predicate.test(array[i])) return i;
        }
        return -1;
    }

    public static <T> int indexOf(List<T> list, Predicate<T> predicate) {
        for (int i = 0; i < list.size(); i++) {
            if (predicate.test(list.get(i))) return i;
        }
        return -1;
    }

    public interface Predicate<T> {
        boolean test(T t);
    }
}

int findIndex(int myElement, int[] someArray){
 int index = 0;
 for(int n: someArray){
   if(myElement == n) return index;
   else index++;
 }
}

Nota: puede usar este método para matrices de tipo int, también puede usar este algoritmo para otros tipos con cambios menores