¿Cómo encontrar el índice de un elemento en un array en Java?

Esa sintaxis ni siquiera es válida. Y estás tratando de comparar con una cadena. Para los arrays tendrías que recorrer el array tú mismo:

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 está utilizando una colección, como ArrayList<Character> también puede usar el método indexOf():

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

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

También existe la clase Arrays que acorta el código anterior:

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

Alternativamente, puede usar Commons Lang ArrayUtils clase:

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

Hay variantes sobrecargadas del método indexOf() para diferentes tipos de matriz.

Para matrices primitivas

Comenzando con Java 8, la solución de propósito general para una matriz primitiva arr, y un valor para buscar val, es:

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

Este código crea un flujo sobre los índices de la matriz con IntStream.range, filtra los índices para mantener solo aquellos donde el elemento de la matriz en ese índice es igual al valor buscado y finalmente mantiene el primero emparejado con findFirst. findFirst devuelve un OptionalInt, como es posible que no se encontraron índices coincidentes. Así que invocamos orElse(-1) para devolver el valor encontrado o -1 si no se encontró ninguno.

Se pueden agregar sobrecargas para int[], long[], etc. El cuerpo del método seguirá siendo el mismo.

Para matrices de objetos

Para los arrays de objetos, como String[], podríamos usar la misma idea y tener el paso de filtrado usando el equals método, o Objects.equals para considerar dos nullelementos iguales, en lugar de ==.

Pero podemos hacerlo de una manera más simple con:

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

Esto crea un contenedor de lista para la matriz de entrada utilizando Arrays.asList y busca el índice del elemento con indexOf.

Esta solución no funciona para arrays primitivos, como se muestra aquí : un array primitivo como int[] no es un Object[] sino un Object; como tal, invocando asList en él crea una lista de un solo elemento, que es el array dado, no una lista de los elementos de la matriz.

Creo que la única manera más sana de hacer esto es iterar manualmente a través de la matriz.

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

El problema con su código es que cuando lo hace

 list[] == "e"

Estás preguntando si el objeto array (no el contenido) es igual a la cadena "e", lo cual claramente no es el caso.

Usted querrá iterar sobre el contenido con el fin de hacer la comprobación que desea:

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

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

Tenga en cuenta que

"e"

Es un literal de objeto de cadena (que representa un objeto de cadena que es )

Mientras que

" e "

Es un carácter literal (que representa un tipo de datos primitivo de carácter)

Incluso cuando

list[]

Sería válido Java ( que no lo es ) comparar el elemento a character con un elemento string devolvería false de todos modos.

Simplemente use esa función indexOf string y podría encontrar cualquier carácter dentro de cualquier alfabeto ( o matriz de caracteres )

Muy Editado. Creo que o quieres esto:

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

(Tenga en cuenta que es posible que tenga que ajustar el método init si desea usar 1-26 en lugar de 0-25)

O quieres esto:

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

El segundo es si siempre quieres a=1, z=26. El primero te permitirá poner una cadena como "qwerty" y asignar q=0, w=1, e=2, r=3...

De esta manera debería funcionar, cambiar "char" a "Character":

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

La solución más simple :

Convierta el array a list y podrá obtener la posición de un elemento.

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

Otra solución , puede iterador 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;
    }
}

Aquí hay otro ejemplo y cómo funciona indexOf.

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

Si el orden inicial de los elementos no es realmente importante, simplemente podría ordenar el array, entonces 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') );
    } 
}

Estoy proporcionando el método adecuado para hacer esto

/**
     * 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 esta manera puedes usar upto 'N' letters.

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