Wie iteriere ich über ein Set / HashSet ohne Iterator?

Wie kann ich über ein Set/ HashSetohne Folgendes iterieren ?

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

Sie können eine erweiterte for-Schleife verwenden :

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

//populate set

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

Oder mit Java 8:

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

Es gibt mindestens sechs zusätzliche Möglichkeiten, einen Satz zu durchlaufen. Folgendes ist mir bekannt:

Methode 1

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

Methode 2

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

Methode 3

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

Methode 4

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

Methode 5

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

Methode 6

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

Dies ist das, HashSetwas ich für meine Beispiele verwendet habe:

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

Das Konvertieren Ihres Sets in ein Array kann Ihnen auch beim Durchlaufen der Elemente helfen:

Object[] array = set.toArray();

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

Betrachten Sie zur Demonstration den folgenden Satz, der verschiedene Personenobjekte enthält:

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

Personenmodellklasse

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. Die for-Anweisung verfügt über ein Formular, das für die Iteration durch Sammlungen und Arrays entwickelt wurde. Dieses Formular wird manchmal als erweiterte for-Anweisung bezeichnet und kann verwendet werden, um Ihre Schleifen kompakter und leichter lesbar zu machen.

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

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

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

Sie können die Funktionsoperation für einen übersichtlicheren Code verwenden

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

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

Hier sind einige Tipps, wie Sie ein Set zusammen mit ihren Leistungen wiederholen können:

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

Der Code ist selbsterklärend.

Das Ergebnis der Dauer sind:

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

Wir können sehen, dass es am Lambdalängsten dauert, während Iteratores am schnellsten ist.

Aufzählung(?):

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

Ein anderer Weg (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));

oder

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

Hierfür gibt es jedoch bereits sehr gute Antworten. Hier ist meine Antwort:

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

Wenn es sich bei diesem Satz um einen benutzerdefinierten Klassentyp handelt, z. B.: Kunde.

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

// Kundenklasse:

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.}