Java'nın Array indexOf'u nerede?

Çok açık bir şey eksik olmalı, ama her yerde aradım ve bu yöntemi bulamıyorum.

ArraysUtility sınıfını kullanarak bunu başarmanın birkaç yolu vardır .

Dizi sıralanmamışsa ve temel öğeler dizisi değilse :

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

Dizi halinde olan ilkel değil sıralanmış, bir gibi diğer cevaplar biri tarafından sunulan bir çözüm kullanmalıdır Kerem Baydoğan adlı , Andrew McKinlay en ya Mishax en . Yukarıdaki kod theArrayilkel olsa bile derlenir (muhtemelen bir uyarı verir), ancak yine de tamamen yanlış sonuçlar alırsınız.

Dizi sıralanırsa, performans için ikili aramayı kullanabilirsiniz:

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

Dizinin indexOf()yöntemi yoktur .

Belki de bu Apache Commons Lang ArrayUtilsyöntemi aradığınız şeydir

import org.apache.commons.lang3.ArrayUtils;

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

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

Boksu kaçınmak istiyorsanız ilkel için, Guava ilkel dizilerdeki örn için yardımcıları vardır Ints.indexOf (int [] dizi int hedef)

Hiç yok. Ya java.util.List* kullanın ya da kendinizinkini yazabilirsiniz 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;
}

_{* kullanarak dizinizden bir tane yapabilirsiniz Arrays#asList()}

Array.IndexOf yöntemine sahip olduğunuz C # ve indexOf yöntemine sahip olduğunuz JavaScript'in aksine , Java API'sı ( özellikle Arrayve Arrayssınıfları) böyle bir yönteme sahip değildir.

Bu yöntem indexOf (tamamlayıcısı lastIndexOf ile birlikte) java.util.List arabiriminde tanımlanır . İndexOf ve lastIndexOf'un aşırı yüklenmediğini ve yalnızca bir Object'i parametre olarak aldığını unutmayın.

Diziniz sıralanırsa , şanslısınız çünkü Arrays sınıfı, aradığınız öğenin dizinini O (n yerine mümkün olan en iyi performansla (O (log n)) bulan bir dizi aşırı yükleme tanımladı. ), ikincisi indexOf tarafından yapılan sıralı bir aramadan bekleyebileceğiniz şeydir). Dört husus vardır:

1. Dizi ya doğal sırayla ya da bağımsız değişken olarak sağladığınız bir Karşılaştırıcı sırasında ya da en azından anahtarın dizideki öğeden önce gelen tüm öğelerin ve tüm öğelerin önüne gelmesi gerekir. "büyüktür" anahtar dizideki öğeden sonra gelmelidir;

2. Dizide bir anahtar olup olmadığını belirlemek için normalde indexOf ile yaptığınız test (dönüş değerinin -1 olmadığını doğrulayın) binarySearch ile tutmaz. Döndürülen değer, anahtarın bulunmadığını, ancak varsa beklenen dizini göstereceğinden, dönüş değerinin sıfırdan küçük olmadığını doğrulamanız gerekir;

3. Diziniz anahtara eşit birden çok öğe içeriyorsa, binarySearch'ten aldığınız şey tanımsızdır; bu, ilk örneği döndürecek indexOf ve son örneği döndürecek lastIndexOf öğelerinden farklıdır.

4. Bir dizi booleans, önce tüm yanlışları ve sonra tüm trues'leri içeriyorsa sıralanmış gibi görünebilir, ancak bu sayılmaz. Bir dizi booleans dizisini kabul eden binarySearch yönteminin geçersiz kılınması yoktur ve bir dizide ilk true'nun nerede göründüğünü algılarken, örneğin bir dizi kullanarak Boolean'lar ve sabitleri Boolean.FALSE ve Boolean.TRUE.

Diziniz sıralanmamışsa ve ilkel tür değilse , java.util.Arrays öğesinin asList yöntemini çağırarak List'in indexOf ve lastIndexOf yöntemlerini kullanabilirsiniz . Bu yöntem, dizinizin çevresinde bir AbstractList arabirimi sarmalayıcısı döndürür. Dizinin bir kopyasını oluşturmadığı için minimum ek yük içerir. Belirtildiği gibi, bu yöntem aşırı yüklenmez, bu nedenle bu yalnızca referans türlerinin dizileri üzerinde çalışır.

Diziniz sıralanmamışsa ve dizinin türü ilkel ise, Java API'sında şansınız kalmamıştır . Döngü için kendinize veya bir nesne örneğinin ek yükünü içeren asList yaklaşımına göre performans avantajlarına sahip olacak kendi statik yardımcı yönteminizi yazın. Dizinin tüm öğeleri üzerinde yinelenen döngü için kaba bir kuvvet yazmanın zarif bir çözüm olmadığından endişe ediyorsanız, indexOf'u çağırdığınızda Java API'sinin tam olarak bunu yaptığını kabul edin. Bunun gibi bir şey yapabilirsiniz:

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

Burada kendi yönteminizi yazmaktan kaçınmak istiyorsanız, Guava gibi bir geliştirme çerçevesinden birini kullanmayı düşünün. Orada indexOf ve lastIndexOf'un bir uygulamasını bulabilirsiniz .

Java'nın ArrayListbir indexOfyöntemi vardır. Java dizilerinin böyle bir yöntemi yoktur.

Diziniz ilkel türler içeriyorsa , muhtemelen birçok java.util.Arrays#binarySearch(...)yöntemden birini ( Arrays javadoc bakın ) kullanabilirsiniz, ancak kendiniz için kodlama dışında dizilerde bir "indexOf" hatırlamıyorum ...

Liste arabiriminin bir indexOf () yöntemi vardır ve dizinizden Array'ın asList () yöntemiyle bir Liste alabilirsiniz. Bunun dışında, Array'ın böyle bir yöntemi yoktur. Sıralı diziler için bir binarySearch () yöntemi vardır.

Dizilerin kendilerinin bu yöntemi yoktur. Ancak bir Liste şunu yapar: indexOf

Muhtemelen diziyi değil, java.util.ArrayList öğesini düşünüyorsunuz .

Java dizilerinde doğrudan indexOf işlevi yoktur.

Jeffrey Hantin'in cevabı iyi ama bazı kısıtlamaları var, eğer bunu bu ya da başka bir şey yaparsa ...

Kendi uzatma yönteminizi yazabilirsiniz ve her zaman istediğiniz şekilde çalışır.

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

Ve işte uzantınız

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

Not: Bu yöntemi int türündeki diziler için kullanabilirsiniz, bu algoritmayı küçük değişikliklere sahip diğer türler için de kullanabilirsiniz