Comment Itérer sur un Jeu/HashSet sans un Itérateur?

Il y a au moins six des moyens supplémentaires pour effectuer une itération sur un ensemble. Les éléments suivants sont connus pour moi:

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 le HashSet que j'ai utilisé pour mes exemples:

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

À démontrer, considérons le jeu suivant, qui contient différents objets de la Personne:

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

Personne De La Classe Du Modèle

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. La déclaration a un formulaire conçu à l'itération à travers les Collections et les tableaux .Cette forme est parfois appelé le renforcement de l'énoncé, et peut être utilisé pour faire des boucles plus compact et plus facile à lire.

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

1. Java 8 - java.lang.Itératif.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

Voici quelques conseils sur la façon de réitérer un Ensemble avec leurs interprétations ou exécutions:

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 auto-explicatif.

Le résultat de l'durées sont les suivantes:

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

Nous pouvons voir la Lambda est la plus longue tout en Iterator est le plus rapide.