Comment itérer sur un Set / HashSet sans itérateur?

Comment puis-je parcourir un Set/ HashSetsans les éléments suivants?

Iterator iter = set.iterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}

Vous pouvez utiliser une boucle for améliorée :

Set<String> set = new HashSet<String>();

//populate set

for (String s : set) {
    System.out.println(s);
}

Ou avec Java 8:

set.forEach(System.out::println);

Il existe au moins six façons supplémentaires d'itérer sur un ensemble. Je connais les éléments suivants:

Méthode 1

// Obsolete Collection
Enumeration e = new Vector(movies).elements();
while (e.hasMoreElements()) {
  System.out.println(e.nextElement());
}

Méthode 2

for (String movie : movies) {
  System.out.println(movie);
}

Méthode 3

String[] movieArray = movies.toArray(new String[movies.size()]);
for (int i = 0; i < movieArray.length; i++) {
  System.out.println(movieArray[i]);
}

Méthode 4

// Supported in Java 8 and above
movies.stream().forEach((movie) -> {
  System.out.println(movie);
});

Méthode 5

// Supported in Java 8 and above
movies.stream().forEach(movie -> System.out.println(movie));

Méthode 6

// Supported in Java 8 and above
movies.stream().forEach(System.out::println);

C'est ce HashSetque j'ai utilisé pour mes exemples:

Set<String> movies = new HashSet<>();
movies.add("Avatar");
movies.add("The Lord of the Rings");
movies.add("Titanic");

La conversion de votre ensemble en tableau peut également vous aider à parcourir les éléments:

Object[] array = set.toArray();

for(int i=0; i<array.length; i++)
   Object o = array[i];

Pour démontrer, considérons l'ensemble suivant, qui contient différents objets Person:

Set<Person> people = new HashSet<Person>();
people.add(new Person("Tharindu", 10));
people.add(new Person("Martin", 20));
people.add(new Person("Fowler", 30));

Classe de modèle de personne

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //TODO - getters,setters ,overridden toString & compareTo methods

}

1. L'instruction for a un formulaire conçu pour l'itération à travers les collections et les tableaux. Ce formulaire est parfois appelé l'instruction for améliorée, et peut être utilisé pour rendre vos boucles plus compactes et plus faciles à lire.

for(Person p:people){
  System.out.println(p.getName());
}

2. Java 8 - java.lang.Iterable.forEach (consommateur)

people.forEach(p -> System.out.println(p.getName()));

default void forEach(Consumer<? super T> action)

Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception. Unless otherwise specified by the implementing class, actions are performed in the order of iteration (if an iteration order is specified). Exceptions thrown by the action are relayed to the caller. Implementation Requirements:

The default implementation behaves as if: 

for (T t : this)
     action.accept(t);

Parameters: action - The action to be performed for each element

Throws: NullPointerException - if the specified action is null

Since: 1.8

Vous pouvez utiliser une opération fonctionnelle pour un code plus soigné

Set<String> set = new HashSet<String>();

set.forEach((s) -> {
     System.out.println(s);
});

Voici quelques conseils sur la façon d'itérer un ensemble ainsi que ses performances:

public class IterateSet {

    public static void main(String[] args) {

        //example Set
        Set<String> set = new HashSet<>();

        set.add("Jack");
        set.add("John");
        set.add("Joe");
        set.add("Josh");

        long startTime = System.nanoTime();
        long endTime = System.nanoTime();

        //using iterator
        System.out.println("Using Iterator");
        startTime = System.nanoTime();
        Iterator<String> setIterator = set.iterator();
        while(setIterator.hasNext()){
            System.out.println(setIterator.next());
        }
        endTime = System.nanoTime();
        long durationIterator = (endTime - startTime);


        //using lambda
        System.out.println("Using Lambda");
        startTime = System.nanoTime();
        set.forEach((s) -> System.out.println(s));
        endTime = System.nanoTime();
        long durationLambda = (endTime - startTime);


        //using Stream API
        System.out.println("Using Stream API");
        startTime = System.nanoTime();
        set.stream().forEach((s) -> System.out.println(s));
        endTime = System.nanoTime();
        long durationStreamAPI = (endTime - startTime);


        //using Split Iterator (not recommended)
        System.out.println("Using Split Iterator");
        startTime = System.nanoTime();
        Spliterator<String> splitIterator = set.spliterator();
        splitIterator.forEachRemaining((s) -> System.out.println(s));
        endTime = System.nanoTime();
        long durationSplitIterator = (endTime - startTime);


        //time calculations
        System.out.println("Iterator Duration:" + durationIterator);
        System.out.println("Lamda Duration:" + durationLambda);
        System.out.println("Stream API:" + durationStreamAPI);
        System.out.println("Split Iterator:"+ durationSplitIterator);
    }
}

Le code est explicite.

Les résultats des durées sont:

Iterator Duration: 495287
Lambda Duration: 50207470
Stream Api:       2427392
Split Iterator:    567294

Nous pouvons voir que la Lambdaprise est la plus longue et Iteratorla plus rapide.

Énumération(?):

Enumeration e = new Vector(set).elements();
while (e.hasMoreElements())
    {
        System.out.println(e.nextElement());
    }

Une autre façon (java.util.Collections.enumeration ()):

for (Enumeration e1 = Collections.enumeration(set); e1.hasMoreElements();)
    {
        System.out.println(e1.nextElement());
    }

Java 8:

set.forEach(element -> System.out.println(element));

ou

set.stream().forEach((elem) -> {
    System.out.println(elem);
});

Cependant, de très bonnes réponses sont déjà disponibles pour cela. Voici ma réponse:

1. set.stream().forEach(System.out::println); // It simply uses stream to display set values
2. set.forEach(System.out::println); // It uses Enhanced forEach to display set values

De plus, si cet ensemble est de type Classe personnalisée, par exemple: Client.

Set<Customer> setCust = new HashSet<>();
    Customer c1 = new Customer(1, "Hena", 20);
    Customer c2 = new Customer(2, "Meena", 24);
    Customer c3 = new Customer(3, "Rahul", 30);

setCust.add(c1);
setCust.add(c2);
setCust.add(c3);
    setCust.forEach((k) -> System.out.println(k.getId()+" "+k.getName()+" "+k.getAge()));

// Classe de client:

class Customer{
private int id;
private String name;
private int age;

public Customer(int id,String name,int age){
this.id=id;
this.name=name;
this.age=age;
} // Getter, Setter methods are present.}