¿Cómo encontrar el índice de elementos en LinkedHashSet en Java?

LinkedHashSet se utiliza para almacenar elementos distintos y obtener los elementos en el orden en que se insertaron en Java. LinkedHashSet no almacena valores basados ​​en el índice. Pero hay algunos métodos para encontrar el índice del elemento en LinkedHashSet en Java.

Método 1: (Al convertir LinkedHashSet a ArrayList)

 Para encontrar el índice del elemento en LinkedHashSet en Java convirtiendo LinkedHashSet en ArrayList , el proceso se dividió en dos partes:

1. Convierta LinkedHashSet en ArrayList usando el constructor.

// Convert LinkedHashSet to ArrayList using constructor
ArrayList<Integer> elements = new ArrayList<>(set);

2. Y obtén el índice del elemento usando el método indexOf() en Java.

Sintaxis:

public int indexOf(Object o)

Parámetros: Esta función tiene un único parámetro, es decir, el elemento a buscar en la lista.

Devoluciones: este método devuelve el índice de la primera aparición del elemento dado en la lista y devuelve «-1» si el elemento no está en la lista.

Ejemplo:

// Java program to find the element
// index in LinkedHashSet
import java.util.*;
  
public class GFG {
    public static void main(String[] args)
    {
  
        // New empty HashSet
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
  
        // Add elements to set
        set.add(10);
        set.add(20);
        set.add(10);
        set.add(50);
        set.add(30);
        set.add(20);
        set.add(50);
  
        // Convert LinkedHashSet to ArrayList
        ArrayList<Integer> elements = new ArrayList<>(set);
  
        // Print the LinkedHashSet
        System.out.println("LinkedHashSet: " + set);
  
        // Print index of all the elements
        for (Integer x : elements) {
            System.out.println("Index of " + x + ": "
                               + elements.indexOf(x));
        }
  
        // It returns -1 becouce 60 not present in
        // LinkedHashSet
        System.out.println("Index of " + 60 + ": "
                           + elements.indexOf(60));
    }
}

LinkedHashSet: [10, 20, 50, 30]
Index of 10: 0
Index of 20: 1
Index of 50: 2
Index of 30: 3
Index of 60: -1

Método 2: (Usando Iterator o Enhanced for loop )

Para encontrar el índice del elemento en Java, podemos crear una nueva función definida por el usuario (indexOf) que devuelva el índice del elemento dado. Nuestra función itera LinkedHashSet y devuelve el índice del elemento dado.

Nota: si el elemento no está presente en LinkedHashSet, devuelve -1.

Ejemplo:

// Java program to find the 
// element index in LinkedHashSet
import java.util.*;
  
public class GFG {
    public static void main(String[] args)
    {
  
        // New empty HashSet
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
  
        // Add elements to set
        set.add(10);
        set.add(20);
        set.add(10);
        set.add(50);
        set.add(30);
        set.add(20);
        set.add(50);
  
        // Print the LinkedHashSet
        System.out.println("LinkedHashSet: " + set);
  
        // Print index of elements
        for (Integer x : set) {
            System.out.println("Index of " + x + ": "
                               + indexOf(set, x));
        }
  
        // It returns -1 becouce it is not present in
        // LinkedHashSet
        System.out.println("Index of " + 60 + ": "
                           + indexOf(set, 60));
    }
  
    public static int indexOf(LinkedHashSet<Integer> set,
                              int element)
    {
  
        // If element not present in the LinkedHashSet it
        // returns -1
        int index = -1;
  
        // get an iterator
        Iterator<Integer> iterator = set.iterator();
  
        int currentIndex = 0;
        while (iterator.hasNext()) {
  
            // If element present in the LinkedHashSet
            if (iterator.next().equals(element)) {
                index = currentIndex;
                break;
            }
  
            currentIndex++;
        }
  
        // Return index of the element
        return index;
    }
}

LinkedHashSet: [10, 20, 50, 30]
Index of 10: 0
Index of 20: 1
Index of 50: 2
Index of 30: 3
Index of 60: -1

Método 3: (Usando una array) Para encontrar el índice del elemento en LinkedHashSet en Java usando una array, el proceso se dividió en dos partes:

1. Convierta LinkedHashSet en un Array usando el método toArray() .

// New Array

Integer[] array = new Integer[set.size()];

// Convert set to Array using toArray
        
array = set.toArray(array);

2. Encuentra el elemento usando un índice.

Sintaxis:

Object[] arr = LinkedHashSet.toArray()

Parámetros: El método no toma ningún parámetro.

Valor devuelto: el método devuelve una array que contiene elementos similares a LinkedHashSet.

Ejemplo:

// Java program to find the 
// element index in LinkedHashSet
import java.util.*;
  
public class GFG {
    public static void main(String[] args)
    {
  
        // New empty HashSet
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
  
        // Add elements to set
        set.add(10);
        set.add(20);
        set.add(10);
        set.add(50);
        set.add(30);
        set.add(20);
        set.add(50);
  
        // Print the LinkedHashSet
        System.out.println("LinkedHashSet: " + set);
  
        // New Array
        Integer[] array = new Integer[set.size()];
  
        // Convert LinkedHashSet to Array
        array = set.toArray(array);
  
        // Print index of elements
        for (int i = 0; i < array.length; i++) {
            System.out.println("Index of " + array[i] + ":"
                               + i);
        }
  
        int element = 50;
  
        int index = -1;
  
        for (int i = 0; i < array.length; i++) {
  
            // if element is equal to array value
            // store index and come out
            if (array[i] == element) {
                index = i;
                break;
            }
        }
  
        // print index
        System.out.println("Index of " + element
                           + " is : " + index);
    }
}

LinkedHashSet: [10, 20, 50, 30]
Index of 10:0
Index of 20:1
Index of 50:2
Index of 30:3
Index of 50 is : 2