Programa Java para encontrar el índice del elemento TreeSet

A diferencia de las clases List como ArrayList o LinkedList , la clase TreeSet no permite acceder a elementos usando el índice. No existen métodos directos para acceder a los elementos de TreeSet utilizando el índice y, por lo tanto, encontrar un índice de un elemento no es sencillo. 

Métodos: Hay principalmente tres métodos estándar de la siguiente manera:

1. Convirtiendo TreeSet en una Lista
2. Usando un iterador
3. Usando el método headSet() de la clase TreeSet

Método 1: convirtiendo TreeSet en una lista

La clase List como ArrayList o LinkedList proporciona el método indexOf() para encontrar el índice del elemento. Podemos convertir TreeSet a ArrayList y luego usar el método indexOf() . Este método devuelve el índice de la primera aparición del elemento especificado en esta lista, o -1 si esta lista no contiene el elemento.

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 index of TreeSet element
// using List by converting TreeSet to a List
 
// Importing ArrayList, List and TreeSet classes
// from java.util package
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
 
// Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating a object of the TreeSet class
        // Declaring object of Integer type
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
 
        // Adding the element to the TreeSet
        // Custom inputs
        treeSet.add(34);
        treeSet.add(23);
        treeSet.add(43);
        treeSet.add(41);
        treeSet.add(35);
        treeSet.add(33);
 
        // Printing all the elements in the TreeSet object
        System.out.println("TreeSet contains: " + treeSet);
 
        // Printing indexes of elements using indexOf()
        // method Index of element number 1
        System.out.println("Index of 23: "
                           + indexOf(treeSet, 23));
 
        // Index of element number 2
        System.out.println("Index of 43: "
                           + indexOf(treeSet, 43));
 
        // Index of element number 3
        System.out.println("Index of 35: "
                           + indexOf(treeSet, 35));
 
        // Index of element number 4
        System.out.println("Index of 55: "
                           + indexOf(treeSet, 55));
    }
 
    // Method - indexOf()
    private static int indexOf(TreeSet<Integer> set,
                               Integer element)
    {
 
        // Step 1: Convert TreeSet to ArrayList or
        // LinkedList
        List<Integer> list = new ArrayList<Integer>(set);
 
        // Step 2: Use the indexOf method of the List
        return list.indexOf(element);
    }
}

TreeSet contains: [23, 33, 34, 35, 41, 43]
Index of 23: 0
Index of 43: 5
Index of 35: 3
Index of 55: -1

Método 2: usar un iterador

Procedimiento: 

1. Iterador sobre elementos TreeSet usando el método iterador.
2. Una vez que se obtiene el iterador, itere a través de los elementos y busque el elemento especificado según los requisitos del usuario o las entradas personalizadas, como se muestra a continuación, para fines de comprensión.

Ejemplo

// Java Program to find the index of the element
// in the TreeSet using Iterator
// Using an Iterator
 
// Importing Iterator and TreeSet class from
// java.util package
import java.util.Iterator;
import java.util.TreeSet;
 
// Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of TreeSet class
        // Declaring object of Integer type
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
 
        // Adding the elements to the TreeSet
        // Custom inputs
        treeSet.add(34);
        treeSet.add(23);
        treeSet.add(43);
        treeSet.add(41);
        treeSet.add(35);
        treeSet.add(33);
 
        // Printing the element in the TreeSet
        System.out.println("TreeSet contains: " + treeSet);
 
        // Printing the indexes of elements in above TreeSet
        // object
        System.out.println("Index of 23: "
                           + indexOf(treeSet, 23));
        System.out.println("Index of 43: "
                           + indexOf(treeSet, 43));
        System.out.println("Index of 35: "
                           + indexOf(treeSet, 35));
        System.out.println("Index of 55: "
                           + indexOf(treeSet, 55));
    }
 
    // Method - indexOf()
    private static int indexOf(TreeSet<Integer> set,
                               Integer element)
    {
 
        int index = -1;
 
        // Get an iterator
        Iterator<Integer> itr = set.iterator();
 
        Integer currentElement = null;
        int currentIndex = 0;
 
        // Condition check using hasNext() method which
        // holds true till single element in List is
        // remaining
        while (itr.hasNext()) {
 
            currentElement = itr.next();
 
            // Checking if the current element equals
            // the element whose index is tried to search
            if (currentElement.equals(element)) {
 
                // Return the index of the element
                return currentIndex;
            }
 
            // Increment the index number
            currentIndex++;
        }
 
        // Return the index -1
        // if the element do not exists
        return index;
    }
}

TreeSet contains: [23, 33, 34, 35, 41, 43]
Index of 23: 0
Index of 43: 5
Index of 35: 3
Index of 55: -1

Método: 3 Usando el método headSet() de la clase TreeSet

El método headSet() de la clase TreeSet devuelve una vista de parte del TreeSet cuyos elementos son menores que el elemento especificado. Dado que los elementos del TreeSet se clasifican automáticamente en el orden natural de los elementos o mediante un comparador personalizado, el tamaño de los auriculares será igual a la cantidad de elementos que son más pequeños o más bajos que el elemento especificado. Si tuviéramos que poner los elementos TreeSet en una lista, ese número sería igual al índice del elemento.

Ilustración:

Si el TreeSet contiene [1, 2, 3, 4], los auriculares del elemento 3 contendrán los elementos [1, 2]. El tamaño de los auriculares será 2 y ese será el índice del elemento 3. Por lo tanto, si obtenemos el tamaño de los auriculares, será igual a la posición del elemento para el que tenemos que encontrar el índice.

Ejemplo 

// Java Program to find the index of element
// in TreeSet using HeadSet
// Using the headSet() method of the TreeSet class
 
// Importing TreeSet class from
// java.util package
import java.util.TreeSet;
 
// Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Making the new object of TreeSet class
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
 
        // Adding the elements to the TreeSet
        treeSet.add(34);
        treeSet.add(23);
        treeSet.add(43);
        treeSet.add(41);
        treeSet.add(35);
        treeSet.add(33);
 
        // Printing the elements of the TreeSet
        System.out.println("TreeSet contains: " + treeSet);
 
        // Printing the indexes of elements
        // in above TreeSet object
        System.out.println("Index of 23: "
                           + indexOf(treeSet, 23));
        System.out.println("Index of 43: "
                           + indexOf(treeSet, 43));
        System.out.println("Index of 35: "
                           + indexOf(treeSet, 35));
        System.out.println("Index of 55: "
                           + indexOf(treeSet, 55));
    }
 
    // Method - indexOf() method
    private static int indexOf(TreeSet<Integer> set,
                               Integer element)
    {
 
        int index = -1;
 
        // If the element exists in the TreeSet
        if (set.contains(element)) {
 
            // The element index will be equal to the
            // size of the headSet for the element
            index = set.headSet(element).size();
        }
 
        // Return the index of the element
        // Value will be -1 if the element
        // do not exist in the TreeSet
        return index;
    }
}

TreeSet contains: [23, 33, 34, 35, 41, 43]
Index of 23: 0
Index of 43: 5
Index of 35: 3
Index of 55: -1