Onde está o Array indexOf do Java?

Devo estar faltando algo muito óbvio, mas procurei por todo o lado e não consigo encontrar esse método.

Existem algumas maneiras de fazer isso usando a Arraysclasse utilitário.

Se a matriz não estiver classificada e não for uma matriz de primitivas:

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

Se o array for primitivo e não classificado, deve-se usar uma solução oferecida por uma das outras respostas, como as de Kerem Baydoğan , Andrew McKinlay ou Mishax . O código acima será compilado mesmo setheArray seja primitivo (possivelmente emitindo um aviso), mas você obterá resultados totalmente incorretos.

Se a matriz estiver classificada, você poderá fazer uso de uma pesquisa binária de desempenho:

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

A matriz não tem indexOf() método.

Talvez este ArrayUtilsmétodo Apache Commons Lang seja o que você está procurando

import org.apache.commons.lang3.ArrayUtils;

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

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

Para primitivos, se você deseja evitar o boxe, o Guava possui auxiliares para matrizes primitivas, por exemplo, Ints.indexOf (int [] array, int target)

Não há nenhum. Use um java.util.List* ou você pode escrever o seu 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;
}

_{* você pode criar um do seu array usando Arrays#asList()}

Diferente do C #, onde você tem o método Array.IndexOf , e do JavaScript, onde você tem o indexOf método , a API do Java (the ArrayeArrays em particular as classes ) não possui esse método.

Este método indexOf (junto com seu complemento lastIndexOf) é definido no java.util.List interface . Observe que indexOf e lastIndexOf não estão sobrecarregados e usam apenas um objeto como parâmetro.

Se sua matriz é classificada , você tem sorte porque a classe Arrays define uma série de sobrecargas do método binarySearch que encontrará o índice do elemento que você está procurando com o melhor desempenho possível (O (log n) em vez de O (n ), sendo o último o que você pode esperar de uma pesquisa seqüencial feita por indexOf). Há quatro considerações:

1. A matriz deve ser classificada em ordem natural ou na ordem de um comparador que você fornece como argumento ou, no mínimo, todos os elementos "inferiores a" a chave devem vir antes desse elemento na matriz e todos os elementos que são "maiores que" a chave deve vir depois desse elemento na matriz;

2. O teste que você normalmente faz com indexOf para determinar se uma chave está na matriz (verifique se o valor de retorno não é -1) não se aplica ao binarySearch. Você precisa verificar se o valor de retorno não é menor que zero, pois o valor retornado indicará que a chave não está presente, mas o índice no qual seria esperado se existisse;

3. Se sua matriz contiver vários elementos iguais à chave, o que você obtém do binarySearch é indefinido; isso é diferente de indexOf que retornará a primeira ocorrência e lastIndexOf que retornará a última ocorrência.

4. Uma matriz de booleanos pode parecer classificada se contiver primeiro todas as falsas e depois todas as verdades, mas isso não conta. Não há substituição do método binarySearch que aceita uma matriz de booleanos e você terá que fazer algo inteligente lá se desejar desempenho O (log n) ao detectar onde a primeira verdade verdadeira aparece em uma matriz, por exemplo, usando uma matriz de Booleanos e as constantes Boolean.FALSE e Boolean.TRUE.

Se sua matriz não for classificada e não for do tipo primitivo , você poderá usar os métodos indexOf e lastIndexOf da List invocando o método asList de java.util.Arrays. Este método retornará um wrapper de interface AbstractList em torno de sua matriz. Envolve uma sobrecarga mínima, pois não cria uma cópia da matriz. Como mencionado, esse método não está sobrecarregado, portanto, ele funcionará apenas em matrizes de tipos de referência.

Se sua matriz não estiver classificada e o tipo da matriz for primitivo , você não terá sorte com a API Java. Escreva seu próprio loop for ou seu próprio método de utilitário estático, que certamente terá vantagens de desempenho em relação à abordagem asList que envolve alguma sobrecarga na instanciação de um objeto. Caso você esteja preocupado com o fato de que escrever uma força bruta para loop que itere sobre todos os elementos da matriz não seja uma solução elegante, aceite que é exatamente isso que a API Java está fazendo quando você chama indexOf. Você pode fazer algo assim:

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;
}

Se você quiser evitar escrever seu próprio método aqui, considere usar um de uma estrutura de desenvolvimento como o Guava. Lá você pode encontrar uma implementação de indexOf e lastIndexOf .

Java ArrayListtem um indexOfmétodo As matrizes Java não têm esse método.

Não me lembro de um "indexOf" em matrizes além de codificá-lo para você ... embora você provavelmente possa usar um dos muitos java.util.Arrays#binarySearch(...)métodos (consulte o javadoc Arrays ) se sua matriz contiver tipos primitivos

A interface List possui um método indexOf () e você pode obter uma List da sua matriz com o método asList () da matriz. Fora isso, a própria matriz não possui esse método. Ele possui um método binarySearch () para matrizes classificadas.

As próprias matrizes não possuem esse método. Uma lista, no entanto, faz: indexOf

Você provavelmente está pensando no java.util.ArrayList , não na matriz.

Não há função indexOf direta em matrizes java.

Jeffrey HantinA resposta de é boa, mas tem algumas restrições, se é isso que faz isso ou aquilo ...

Você pode escrever seu próprio método de extensão e ele sempre funciona da maneira que você deseja.

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

E aqui está a sua extensão

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: você pode usar esse método para matrizes do tipo int, também pode usar esse algoritmo para outros tipos com pequenas alterações