¿Cómo encontrar el índice de un elemento en una matriz int?

¿Cómo puedo encontrar un índice de cierto valor en una matriz de tipo Java int?

Intenté usar Arrays.binarySearch en mi matriz sin clasificar, solo a veces da la respuesta correcta.

Integer[] array = {1,2,3,4,5,6};

Arrays.asList(array).indexOf(4);

Tenga en cuenta que esta solución es segura para subprocesos porque crea un nuevo objeto de tipo Lista.

Además, no desea invocar esto en un bucle o algo así, ya que estaría creando un nuevo objeto cada vez

Otra opción si está utilizando Guava Collections es Ints.indexOf

// Perfect storm:
final int needle = 42;
final int[] haystack = [1, 2, 3, 42];

// Spoiler alert: index == 3
final int index = Ints.indexOf(haystack, needle);

Esta es una gran opción cuando el espacio, el tiempo y la reutilización de código son un bien escaso. También es muy escueto.

Una mirada a la API y dice que primero debes ordenar la matriz

Entonces:

Arrays.sort(array);
Arrays.binarySearch(array, value);

Si no desea ordenar la matriz:

public int find(double[] array, double value) {
    for(int i=0; i<array.length; i++) 
         if(array[i] == value)
             return i;
}

Copia este método en tu clase

 public int getArrayIndex(int[] arr,int value) {

        int k=0;
        for(int i=0;i<arr.length;i++){

            if(arr[i]==value){
                k=i;
                break;
            }
        }
    return k;
}

Llame a este método con pasar dos parámetros Array y value y almacene su valor de retorno en una variable entera.

int indexNum = getArrayIndex(array,value);

Gracias

ArrayUtils.indexOf(array, value);
Ints.indexOf(array, value);
Arrays.asList(array).indexOf(value);

Puede usar Java moderno para resolver este problema. Utilice el siguiente código:

static int findIndexOf(int V, int[] arr) {
        return IntStream.range(1, arr.length).filter(i->arr[i]==V).findFirst().getAsInt();
    }

Puede convertirlo en una lista y luego usar el método indexOf:

Array.asList(array).indexOf(1); 

http://download.oracle.com/javase/1.5.0/docs/api/java/util/Arrays.html#asList(T ...) http://download.oracle.com/javase/1.5.0 /docs/api/java/util/List.html#indexOf(java.lang.Object )

Debe ordenar los valores antes de utilizar la búsqueda binaria. De lo contrario, la forma manual es probar todas las entradas en su pestaña.

public int getIndexOf( int toSearch, int[] tab )
{
  for( int i=0; i< tab.length ; i ++ )
    if( tab[ i ] == toSearch)
     return i;

  return -1;
}//met

Un método alternativo podría ser mapear todos los índices para cada valor en un mapa.

tab[ index ] = value;
if( map.get( value) == null || map.get( value) > index )
    map.put( value, index );

y luego map.get (valor) para obtener el índice.

Saludos, Stéphane

@pst, gracias por tus comentarios. ¿Puedes publicar otro método alternativo?

Simple:

public int getArrayIndex(int[] arr,int value) {
    for(int i=0;i<arr.length;i++)
        if(arr[i]==value) return i;
    return -1;
}

    Integer[] arr = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };
    List<Integer> arrlst = Arrays.asList(arr);
    System.out.println(arrlst.lastIndexOf(1));

En caso de que alguien todavía esté buscando la respuesta-

1. Puede utilizar ArrayUtils.indexOf () de la [Apache Commons Library] [1].

2. Si está utilizando Java 8, también puede utilizar la API de Strean:

   public static int indexOf(int[] array, int valueToFind) {
       if (array == null) {
           return -1;
       }
       return IntStream.range(0, array.length)
               .filter(i -> valueToFind == array[i])
               .findFirst()
               .orElse(-1);
   }
   

   [1]: https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/ArrayUtils.html#indexOf(int[],%20int)

La forma más sencilla es iterar. Por ejemplo, queremos encontrar el valor mínimo de la matriz y su índice:

public static Pair<Integer, Integer> getMinimumAndIndex(int[] array) {
        int min = array[0];
        int index = 0;
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
                index = i;
            }

            return new Pair<min, index>;

De esta manera, prueba todos los valores de la matriz y, si algunos de ellos son mínimos, también conoce el índice de mínimos. Puede funcionar igual con la búsqueda de algún valor:

public static int indexOfNumber(int[] array) {
        int index = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == 77) {        // here you pass some value for example 77
                index = i;
            }
        }
        return index;
    }

Puede recorrer la matriz hasta encontrar el índice que está buscando o usar un List. Tenga en cuenta que puede transformar la matriz en una lista con asList().

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

Puedes hacerlo así:

 public class Test {

public static int Tab[]  = {33,44,55,66,7,88,44,11,23,45,32,12,95};
public static int search = 23;

public static void main(String[] args) {
    long stop = 0;
    long time = 0;
    long start = 0;
    start = System.nanoTime();
    int index = getIndexOf(search,Tab);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("equal to took in nano seconds ="+time);
    System.out.println("Index  of searched value is: "+index);
    System.out.println("De value of Tab with searched index is: "+Tab[index]);
    System.out.println("==========================================================");
    start = System.nanoTime();
    int Bindex = bitSearch(search,Tab);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("Binary search took nano seconds ="+time);
    System.out.println("Index  of searched value is: "+Bindex);
    System.out.println("De value of Tab with searched index is: "+Tab[Bindex]);
}



public static int getIndexOf( int toSearch, int[] tab ){
     int i = 0;
     while(!(tab[i] == toSearch) )
     {  i++; }
       return i; // or return tab[i];
   }
public static int bitSearch(int toSearch, int[] tab){
    int i = 0;
    for(;(toSearch^tab[i])!=0;i++){
    }
    return i;

}

}

Se agregó un XOR :)

En el método principal que usa bucles for: -el tercer bucle for en mi ejemplo es la respuesta a esta pregunta. -en mi ejemplo hice una matriz de 20 enteros aleatorios, asigné a una variable el número más pequeño y detuve el ciclo cuando la ubicación de la matriz alcanzó el valor más pequeño mientras contaba el número de ciclos.

import java.util.Random;
public class scratch {
    public static void main(String[] args){
        Random rnd = new Random();
        int randomIntegers[] = new int[20];
        double smallest = randomIntegers[0];
        int location = 0;

        for(int i = 0; i < randomIntegers.length; i++){             // fills array with random integers
            randomIntegers[i] = rnd.nextInt(99) + 1;
            System.out.println(" --" + i + "-- " + randomIntegers[i]);
        }

        for (int i = 0; i < randomIntegers.length; i++){            // get the location of smallest number in the array 
            if(randomIntegers[i] < smallest){
                smallest = randomIntegers[i];                 
            }
        }

        for (int i = 0; i < randomIntegers.length; i++){                
            if(randomIntegers[i] == smallest){                      //break the loop when array location value == <smallest>
                break;
            }
            location ++;
        }
        System.out.println("location: " + location + "\nsmallest: " + smallest);
    }
}

El código genera todos los números y sus ubicaciones, y la ubicación del número más pequeño seguido del número más pequeño.

static int[] getIndex(int[] data, int number) {
    int[] positions = new int[data.length];
    if (data.length > 0) {
        int counter = 0;
        for(int i =0; i < data.length; i++) {
            if(data[i] == number){
                positions[counter] = i;
                counter++;
            }
        }
    }
    return positions;
}

Búsqueda binaria: la búsqueda binaria también se puede utilizar para encontrar el índice del elemento de la matriz en una matriz. Pero la búsqueda binaria solo se puede usar si la matriz está ordenada. Java nos proporciona una función incorporada que se puede encontrar en la biblioteca Arrays de Java que devolverá el índice si el elemento está presente, de lo contrario, devuelve -1. La complejidad será O (log n). A continuación se muestra la implementación de la búsqueda binaria.

public static int findIndex(int arr[], int t) { 
   int index = Arrays.binarySearch(arr, t); 
   return (index < 0) ? -1 : index; 
} 

Integer[] array = {1, 2, 3, 4, 5, 6};

for (int i = 0; i < array.length; i++) {
    if (array[i] == 4) {
        system.out.println(i);
        break;
    }
}