Anzeige

HC's Blog


HonniCilest

Erfahrenes Mitglied
#1
Mein erster Beitrag soll nur ein kleines Codebeispiel sein. Es ist ein CustomCollector, den ich selbst schon mehrmals angewendet habe:

Java:
package custom;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Collector;

/**
* A personal collection of custom Collector implementations.
*
* @author HonniCilest
*/
public class CustomCollectors {

    /**
     * Returns a random elements of the stream.
     *
     * @param <T> Type of the streamed element.
     * @return A random element of the stream.<br>
     * Returns null if the stream contained no element.
     */
    public static <T> Collector<T, List<T>, T> pickRandom() {
        return ofListBase((container) -> {
            return container.size() > 0
                    ? container.get(new Random().nextInt(container.size()))
                    : null;
        });
    };

    /**
     * Returns a list of random elements with the given length.
     *
     * @param <T> Type of the streamed element.
     * @param n Amount of elements to be returned.
     * @return A list of random elements of the stream with given length max.
     * @throws IllegalArgumentException If the given amount is negative.
     */
    public static <T> Collector<T, List<T>, List<T>> pickRandom(int n)
            throws IllegalArgumentException {
        if (n < 1) {
            throw new IllegalArgumentException("Argument must be positive.");
        }

        return ofListBase((container) -> {
            Collections.shuffle(container);
            return container.size() <= n
                    ? container
                    : container.subList(0, n);
        });
    };

     /**
     * Returns a randomized list of the streamed elements.
     *
     * @param <T> Type of the streamed element.
     * @return A randomized list of the streamed elements
     */
    public static <T> Collector<T, List<T>, List<T>> toShuffledList() {
        return ofListBase((container) -> {
            Collections.shuffle(container);
            return container;
        });
    };

    private static <T, R> Collector<T, List<T>, R> ofListBase(Function<List<T>, R> finisher) {
        return Collector.of(
                // Supplier
                () -> {
                    return new ArrayList<>();
                },
                // Accumulator
                (container, element) -> {
                    container.add(element);
                },
                // Combiner
                (container1, container2) -> {
                    container1.addAll(container2);
                    return container1;
                },
                // Finisher
                finisher,
                // Characteristics
                Collector.Characteristics.UNORDERED
        );
    };
}
Anwendungsbeispiele:
Java:
// Der Apfel bei Snake muss auf einem zufälligen freien Feld platziert werden nachdem er von der Schlange gefressen wurde
FieldModel freeField = fieldList.stream().filter(field -> field.isFree()).collect(CustomCollectors.pickRandom());
if(freeField != null) freeField.placeApple();

// Lehrer wählt zufällig n Schüler aus seiner Klasse aus, aber nur aus denen welche sich gemeldet haben
List<Student> volunteers = studentList.stream().filter(student -> student.hasHandRaised()).collect(CustomCollectors.pickRandom(n));
for(Student student : volunteers) sendToTrip(student);

// Bei einem Multiple-Choice Test werden die korrekten und die falschen Fragen in einer zufälligen Reihenfolge ausgegeben
List<String> allChoices = Stream.concat(answers.stream(), dummies.stream()).collect(CustomCollectors.toShuffledList());
 
Zuletzt bearbeitet:
Anzeige
Anzeige