Comment trouver l'indice d'un élément dans un tableau en Java?

ce n'est même pas une syntaxe valide. et vous essayez de comparer à une chaîne. Pour les tableaux, vous devez parcourir le tableau vous-même:

public class T {
  public static void main( String args[] ) {
    char[] list = {'m', 'e', 'y'};

    int index = -1;

    for (int i = 0; (i < list.length) && (index == -1); i++) {
        if (list[i] == 'e') {
            index = i;
        }
    }

    System.out.println(index);
  }
}

si vous utilisez une collection, telle que ArrayList<Character> , vous pouvez également utiliser la méthode indexOf() :

ArrayList<Character> list = new ArrayList<Character>();
list.add('m');
list.add('e');
list.add('y');

System.out.println(list.indexOf('e'));

il y a aussi la classe Arrays qui raccourcit le code ci-dessus:

List list = Arrays.asList(new Character[] { 'm', 'e', 'y' });
System.out.println(list.indexOf('e'));

alternativement, vous pouvez utiliser Commons Lang ArrayUtils class:

int[] arr = new int{3, 5, 1, 4, 2};
int indexOfTwo = ArrayUtils.indexOf(arr, 2);

il existe des variantes surchargées de la méthode indexOf() pour différents types de réseaux.

Pour des primitifs tableaux

à partir de Java 8, la solution générale pour un tableau primitif arr , et une valeur pour rechercher val , est:

public static int indexOf(char[] arr, char val) {
    return IntStream.range(0, arr.length).filter(i -> arr[i] == val).findFirst().orElse(-1);
}

ce code crée un flux au-dessus des index du tableau avec IntStream.range , filtre les index pour ne conserver que ceux où l'élément du tableau à cet index est égal à la valeur recherchée et conserve finalement la première correspondait à findFirst . findFirst renvoie un OptionalInt , comme il est possible qu'aucun index correspondant n'ait été trouvé. Nous invoquons donc orElse(-1) pour retourner la valeur trouvée ou -1 si aucune n'a été trouvée.

peuvent être ajoutées pour int[] , long[] , etc. Le corps de la méthode reste la même.

Pour Objet tableaux

pour les tableaux d'objets, comme String[] , nous pourrions utiliser la même idée et avoir l'étape de filtrage en utilisant le equals méthode, ou Objects.equals pour considérer deux null éléments égaux, au lieu de == .

mais nous pouvons le faire d'une manière plus simple avec:

public static <T> int indexOf(T[] arr, T val) {
    return Arrays.asList(arr).indexOf(val);
}

cela crée un enveloppeur de liste pour l'entrée tableau utilisant Arrays.asList et recherche l'index de l'élément avec indexOf .

Cette solution ne fonctionne pas pour les tableaux primitifs, comme montré ici : un tableau primitif comme int[] n'est pas un Object[] mais un Object ; en tant que tel, en invoquant asList sur elle crée une liste d'un seul élément, qui est le tableau donné, pas une liste des éléments du tableau.

je crois que le seulement la façon la plus saine de faire ceci est d'itérer manuellement à travers le tableau.

for (int i = 0; i < list.length; i++) {
  if (list[i] == 'e') {
    System.out.println(i);
    break;
  }
}

le problème avec votre code est que lorsque vous faites""

 list[] == "e"

vous vous demandez si l'objet array (pas le contenu) est égal à la chaîne "e", ce qui n'est clairement pas le cas.

vous voudrez itérer sur le contenu afin de faire le contrôle que vous voulez:

 for(String element : list) {
      if (element.equals("e")) {
           // do something here
      }
 }

maintenant il ne imprimer 1

class Masi {
    public static void main( String [] args ) {
         char [] list = { 'm', 'e', 'y' };

         // Prints 1
         System.out.println( indexOf( 'e', list ) );
    }

    private static int indexOf( char c , char [] arr ) {
        for( int i = 0 ; i < arr.length ; i++ ) {
            if( arr[i] == c ) { 
                return i;
            }
         }
         return -1;
     }
 }

gardez à l'esprit que

"e"

est un objet string littéral ( qui représente un objet string qui est)

alors que

'e'

est un caractère littéral (qui représente un type de données primitif)

Même quand

list[]

serait valide Java ( qui n'est pas ) comparer l'élément de caractère a avec un élément de chaîne de caractères retournerait false de toute façon.

utilisez simplement cette fonction d'indexOf string et vous pourriez trouver n'importe quel caractère dans n'importe quel alphabet ( ou tableau de caractères )

Très Fortement Édité. Je pense que soit vous voulez ceci:

class CharStorage {
    /** set offset to 1 if you want b=1, o=2, y=3 instead of b=0... */
    private final int offset=0;
    private int array[]=new int[26];

    /** Call this with up to 26 characters to initialize the array.  For 
      * instance, if you pass "boy" it will init to b=0,o=1,y=2.
      */
    void init(String s) {
        for(int i=0;i<s.length;i++)
            store(s.charAt(i)-'a' + offset,i); 
    }

    void store(char ch, int value) {
        if(ch < 'a' || ch > 'z') throw new IllegalArgumentException();
        array[ch-'a']=value;
    }

    int get(char ch) {
        if(ch < 'a' || ch > 'z') throw new IllegalArgumentException();
        return array[ch-'a'];
    }
}

(notez que vous pourriez devoir ajuster la méthode init si vous voulez utiliser 1-26 au lieu de 0-25)

ou vous voulez:

int getLetterPossitionInAlphabet(char c) {
    return c - 'a' + 1
}

le second est si vous voulez toujours a=1, z=26. Le premier vous permettra de mettre dans une chaîne de caractères comme "qwerty" et assigner q=0, w=1, e=2, r=3...

cette façon devrait fonctionner, changer "char" en "caractère":

public static void main(String[] args){
  Character[] list = {'m', 'e', 'y'};
  System.out.println(Arrays.asList(list).indexOf('e')); // print "1"
}

solution la plus simple :

convertissez le tableau en liste et vous pouvez obtenir la position d'un élément.

List<String> abcd  = Arrays.asList(yourArray);
int i = abcd.indexOf("abcd");

autre solution , vous pouvez iterator array:

int position = 0;
for (String obj : yourArray) {
    if (obj.equals("abcd") {
    return position;
    }
    position += 1;
} 

//OR
for (int i = 0; i < yourArray.length; i++) {
    if (obj.equals("abcd") {
       return i;
    }
}

voici un autre exemple, et comment indexOf .

public int indexOf(Object target) {
    for (int i = 0; i < array.length; i++) {
        if (equals(target, array[i])) {
            return i;
        }
    }
    return -1;
}

Si l'ordre des éléments n'est pas vraiment important, vous pouvez trier le tableau, puis binarySearch:

import java.util.Arrays;

class masi { 
    public static void main( String[] args ) { 
        char[] list = {'m', 'e', 'y'};
        Arrays.sort(list);

        // should print 0, as e is now sorted to the beginning
        // returns negative number if the result isn't found
        System.out.println( Arrays.binarySearch(list, 'e') );
    } 
}

je suis en fournissant la bonne méthode pour ce faire un

/**
     * Method to get the index of the given item from the list
     * @param stringArray
     * @param name
     * @return index of the item if item exists else return -1
     */
    public static int getIndexOfItemInArray(String[] stringArray, String name) {
        if (stringArray != null && stringArray.length > 0) {
            ArrayList<String> list = new ArrayList<String>(Arrays.asList(stringArray));
            int index = list.indexOf(name);
            list.clear();
            return index;
        }
        return -1;
    }

de Cette façon, vous pouvez utiliser jusqu'à 'N' lettres.

char[] a={ 'a', 'b', 'c', 'd', 'e' };
int indexOf=0;
for(int i=0;i<a.length;i++){
  if(a[i] != 'b'){
    indexOf++;
    }else{
    System.out.println("index of given: "+indexOf);
 }}