¿Cómo iterar sobre un Set/HashSet sin un iterador?

¿Cómo puedo iterar sobre un Set/HashSet sin lo siguiente?

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

Puedes usar un mejorado para bucle:

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

//populate set

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

O con Java 8:

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

Hay al menos seis formas adicionales de iterar sobre un conjunto. Me son conocidas las siguientes:

Método 1

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

Método 2

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

Método 3

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

Método 4

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

Método 5

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

Método 6

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

Este es el HashSet que utilicé para mis ejemplos:

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

Convirtiendo tu conjunto en una matriz
también puede ayudarlo a iterar sobre los elementos:

Object[] array = set.toArray();

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

Para demostrarlo, considere el siguiente conjunto, que contiene diferentes objetos 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));

Clase de modelo de persona

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 declaración for tiene un formulario diseñado para la iteración a través de colecciones y arreglos. Este formulario a veces se denomina declaración for mejorada y se puede usar para hacer que sus bucles sean más compactos y fáciles de leer.

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

2. Java 8 – java.lang.Iterable.forEach(Consumidor)

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

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

Throws: NullPointerException - if the specified action is null

Since: 1.8

Puede usar la operación funcional para un código más ordenado

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

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

Aquí hay algunos consejos sobre cómo iterar un conjunto junto con sus actuaciones:

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);
    }
}

El código se explica por sí mismo.

El resultado de las duraciones son:

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

podemos ver el Lambda lleva más tiempo Iterator es el más rápido

Enumeración(?):

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

Otra forma (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));

o

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