Encuentra el índice de un elemento de array en Java

Dada una array de N elementos y un elemento K, busque el índice de un elemento de array en Java. 
Ejemplos: 

Input: a[] = { 5, 4, 6, 1, 3, 2, 7, 8, 9 }, K = 5
Output: 0

Input: a[] = { 5, 4, 6, 1, 3, 2, 7, 8, 9 }, K = 7
Output: 6

Se puede buscar un elemento en una array de N enteros utilizando los métodos mencionados a continuación.  

1. Búsqueda lineal : al realizar una búsqueda lineal en una array, el elemento se puede encontrar en una complejidad O (N). 
   A continuación se muestra la implementación del enfoque de búsqueda lineal:

// Java program to find index of
// an element in N elements
import java.util.*;
public class index {
  
    // Linear-search function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
  
        // if array is Null
        if (arr == null) {
            return -1;
        }
  
        // find length of array
        int len = arr.length;
        int i = 0;
  
        // traverse in the array
        while (i < len) {
  
            // if the i-th element is t
            // then return the index
            if (arr[i] == t) {
                return i;
            }
            else {
                i = i + 1;
            }
        }
        return -1;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int[] my_array = { 5, 4, 6, 1, 3, 2, 7, 8, 9 };
  
        // find the index of 5
        System.out.println("Index position of 5 is: "
                           + findIndex(my_array, 5));
  
        // find the index of 7
        System.out.println("Index position of 7 is: "
                           + findIndex(my_array, 7));
    }
}

Index position of 5 is: 0
Index position of 7 is: 6

2. Búsqueda binaria : la búsqueda binaria también se puede utilizar para encontrar el índice del elemento de array en una array. Pero la búsqueda binaria sólo se puede utilizar si la array 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, devolverá -1. La complejidad será O(log n). 
A continuación se muestra la implementación de la búsqueda binaria. 

// Java program to find index of
// an element in N elements
import java.util.Arrays;
  
public class index {
  
    // Function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
  
        int index = Arrays.binarySearch(arr, t);
        return (index < 0) ? -1 : index;
    }
    // Driver Code
    public static void main(String[] args)
    {
        int[] my_array = { 1, 2, 3, 4, 5, 6, 7 };
  
        // find the index of 5
        System.out.println("Index position of 5 is: "
                           + findIndex(my_array, 5));
  
        // find the index of 7
        System.out.println("Index position of 7 is: "
                           + findIndex(my_array, 7));
    }
}

Index position of 5 is: 4
Index position of 7 is: 6

3 . Guava: Guava es una biblioteca de código abierto basada en Java desarrollada por Google. Proporciona métodos de utilidad para colecciones, almacenamiento en caché, compatibilidad con primitivas, simultaneidad, anotaciones comunes, procesamiento de strings, E/S y validaciones. Guava proporciona varias clases de utilidades pertenecientes a ser primitivas como Ints por int, Longs por long, Doubles por double, etc. Cada clase de utilidad tiene un método indexOf() que devuelve el índice de la primera aparición del elemento en la array.
A continuación se muestra la implementación de Guayaba.
 

// Java program to find index of
// an element in N elements
import java.util.List;
import com.google.common.primitives.Ints;
public class index {
    // Function to find the index of an element using
    public static int findIndex(int arr[], int t)
    {
        return Ints.indexOf(arr, t);
    }
    // Driver Code
    public static void main(String[] args)
    {
        int[] my_array = { 5, 4, 6, 1, 3, 2, 7, 8, 9 };
        System.out.println("Index position of 5 is: "
                           + findIndex(my_array, 5));
        System.out.println("Index position of 7 is: "
                           + findIndex(my_array, 7));
    }
}

Index position of 5 is: 0
Index position of 7 is: 6

4. Stream API: Stream es una nueva capa abstracta introducida en Java 8. Al usar Stream, puede procesar datos de forma declarativa similar a las instrucciones SQL. La secuencia representa una secuencia de objetos de un origen, que admite operaciones agregadas. Para encontrar el índice de un elemento, el paquete Stream proporciona la utilidad IntStream. Usando la longitud de una array, podemos obtener un IntStream de índices de array de 0 a n-1, donde n es la longitud de una array.
A continuación se muestra la implementación del enfoque de Stream API. 

// Java program to find index of
// an element in N elements
import java.util.stream.IntStream;
public class index {
  
    // Function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
        int len = arr.length;
        return IntStream.range(0, len)
            .filter(i -> t == arr[i])
            .findFirst() // first occurrence
            .orElse(-1); // No element found
    }
    public static void main(String[] args)
    {
        int[] my_array = { 5, 4, 6, 1, 3, 2, 7, 8, 9 };
        System.out.println("Index position of 5 is: "
                           + findIndex(my_array, 5));
        System.out.println("Index position of 7 is: "
                           + findIndex(my_array, 7));
    }
}

Index position of 5 is: 0
Index position of 7 is: 6

5. Usando ArrayList

En este enfoque, convertiremos la array en ArrayList y luego usaremos el método indexOf de ArrayList para obtener el índice del elemento.

// Java program for the above approach
import java.util.ArrayList;
  
public class GFG {
  
    public static int findIndex(int arr[], int t)
    {
        // Creating ArrayList
        ArrayList<Integer> clist = new ArrayList<>();
  
        // adding elements of array
        // to ArrayList
        for (int i : arr)
            clist.add(i);
  
        // returning index of the element
        return clist.indexOf(t);
    }
    
    // Driver program
    public static void main(String[] args)
    {
        int[] my_array = { 5, 4, 6, 1, 3, 2, 7, 8, 9 };
        System.out.println("Index position of 5 is: "
                           + findIndex(my_array, 5));
        System.out.println("Index position of 7 is: "
                           + findIndex(my_array, 7));
    }
}

Producción:

Index position of 5 is: 0
Index position of 7 is: 6

6. Usando recursividad

Usaremos la recursividad para encontrar el primer índice del elemento dado.

// Java program for the above approach
public class GFG {
  
    public static int index(int arr[], int t, int start)
    {
          
        // base case when 
        // start equals the length of the 
        // array we return -1
        if(start==arr.length)
            return -1;
          
        // if element at index start equals t
        // we return start
        if(arr[start]==t)
            return start;
          
        // we find for the rest
        // position in the array
        return index(arr,t,start+1);
    }
    
    public static int findIndex(int arr[], int t)
    {
        return index(arr,t,0);
    }
    
    // Driver Code
    public static void main(String[] args)
    {
        int[] my_array = { 5, 4, 6, 1, 3, 2, 7, 8, 9 };
        System.out.println("Index position of 5 is: "
                + findIndex(my_array, 5));
        System.out.println("Index position of 7 is: "
                + findIndex(my_array, 7));
    }
}

Producción:

Index position of 5 is: 0
Index position of 7 is: 6