Wie kann ich machen das kartesische Produkt mit Java-8-streams?

Lösen Sie dieses mit dem rekursiven flatMap Kette.

Erste, was wir brauchen, hin und her bewegen durch die map-Werte, es ist besser, kopieren Sie die ArrayList (dies ist nicht der Tiefe Kopie, in Ihrem Fall ist es ArrayList 3 Elemente, so dass der zusätzliche Speicherverbrauch ist niedrig).

Zweiten, zu erhalten ein Präfix der zuvor besuchten Elemente, erstellen wir einen Helfer unveränderlich Prefix Klasse:

private static class Prefix<T> {
    final T value;
    final Prefix<T> parent;

    Prefix(Prefix<T> parent, T value) {
        this.parent = parent;
        this.value = value;
    }

    //put the whole prefix into given collection
    <C extends Collection<T>> C addTo(C collection) {
        if (parent != null)
            parent.addTo(collection);
        collection.add(value);
        return collection;
    }
}

Dies ist sehr einfach, unveränderlich, Link-Liste, die verwendet werden können, wie diese:

List<String> list = new Prefix<>(new Prefix<>(new Prefix<>(null, "a"), "b"), "c")
                          .addTo(new ArrayList<>()); //[a, b, c];

Als Nächstes erstellen wir die interne Methode, die Ketten flatMaps:

private static <T, C extends Collection<T>> Stream<C> comb(
        List<? extends Collection<T>> values, int offset, Prefix<T> prefix,
        Supplier<C> supplier) {
    if (offset == values.size() - 1)
        return values.get(offset).stream()
                     .map(e -> new Prefix<>(prefix, e).addTo(supplier.get()));
    return values.get(offset).stream()
            .flatMap(e -> comb(values, offset + 1, new Prefix<>(prefix, e), supplier));
}

Sieht aus wie Rekursion, aber es ist noch komplexer: es nicht nennen sich selbst direkt, sondern bestanden lambda fordert die äußeren Methode. Parameter:

• Werte: die List von der ursprünglichen Werte (new ArrayList<>(map.values) in Ihrem Fall).
• - offset: das aktuelle offset innerhalb dieser Liste
• Präfix: das aktuelle Präfix der Länge versetzt (oder null wenn offset == 0). Es enthält die aktuell ausgewählten Elemente aus den Sammlungen list.get(0), list.get(1) bis zu list.get(offset-1).
• Lieferanten: factory-Methode zum erstellen der resultierenden Sammlung.

Wenn wir erreichten das Ende der Werte-Liste (offset == values.size() - 1), wir bilden die Elemente der letzten Sammlung von den Werten, die endgültige Kombination mit den Lieferanten. Ansonsten verwenden wir die flatMap für jeden intermediate element vergrößert das Präfix, und fordert die comb Methode wieder für die nächsten offset.

Schließlich hier public Methode um diese Funktion zu verwenden:

public static <T, C extends Collection<T>> Stream<C> ofCombinations(
        Collection<? extends Collection<T>> values, Supplier<C> supplier) {
    if (values.isEmpty())
        return Stream.empty();
    return comb(new ArrayList<>(values), 0, null, supplier);
}

Ein Beispiel:

Map<String, Collection<String>> map = new LinkedHashMap<>(); //to preserve the order
map.put("A", Arrays.asList("a1", "a2", "a3", "a4"));
map.put("B", Arrays.asList("b1", "b2", "b3"));
map.put("C", Arrays.asList("c1", "c2"));

ofCombinations(map.values(), LinkedHashSet::new).forEach(System.out::println);

Sammeln wir die einzelnen Kombinationen auf die LinkedHashSet wieder zum beibehalten der Reihenfolge. Sie kann auch jede andere Sammlung statt (z.B. ArrayList::new).

Kartesische Produkt in Java 8 mit forEach:

List<String> listA = new ArrayList<>();
listA.add("0");
listA.add("1");
List<String> listB = new ArrayList<>();
listB.add("a");
listB.add("b"); 

List<String> cartesianProduct = new ArrayList<>();
listA.forEach(a -> listB.forEach(b -> cartesianProduct.add(a + b)));

cartesianProduct.forEach(System.out::println);
//Output : 0a 0b 1a 1b 

Während es ist nicht eine Stream-Lösung, Guave com.google.common.sammeln.Stellt dies für Sie übernimmt

Set<List<String>> result = Sets.cartesianProduct(Set.of("a1","a2"), Set.of("b1","b2"), Set.of("c1","c2" ))

Verwenden Sie ein Verbraucher-Funktion der Klasse, einer Liste und einer foreach -

    public void tester(){

        String[] strs1 = {"2","4","9"};
        String[] strs2 = {"9","0","5"};

        //Final output is {"29", "49, 99", "20", "40", "90", "25", "45", "95"}
        List<String> result = new ArrayList<>();
        Consumer<String> consumer = (String str) -> result.addAll(Arrays.stream(strs1).map(s -> s+str).collect(Collectors.toList()));
        Arrays.stream(strs2).forEach(consumer);

        System.out.println(result);

}

Schrieb ich eine Klasse Umsetzung Iterable, und halten nur das aktuelle Element im Speicher. Die Durchsuchbar sowie die Iterator umgewandelt werden können, um eine Stream wenn gewünscht.

class CartesianProduct<T> implements Iterable<List<T>> {
    private final Iterable<? extends Iterable<T>> factors;

    public CartesianProduct(final Iterable<? extends Iterable<T>> factors) {
        this.factors = factors;
    }

    @Override
    public Iterator<List<T>> iterator() {
        return new CartesianProductIterator<>(factors);
    }
}

class CartesianProductIterator<T> implements Iterator<List<T>> {
    private final List<Iterable<T>> factors;
    private final Stack<Iterator<T>> iterators;
    private final Stack<T> current;
    private List<T> next;
    private int index = 0;

    private void computeNext() {
        while (true) {
            if (iterators.get(index).hasNext()) {
                current.add(iterators.get(index).next());
                if (index == factors.size() - 1) {
                    next = new ArrayList<>(current);
                    current.pop();
                    return;
                }
                index++;
                iterators.add(factors.get(index).iterator());
            } else {
                index--;
                if (index < 0) {
                    return;
                }
                iterators.pop();
                current.pop();
            }
        }
    }

    public CartesianProductIterator(final Iterable<? extends Iterable<T>> factors) {
        this.factors = StreamSupport.stream(factors.spliterator(), false)
                .collect(Collectors.toList());
        if (this.factors.size() == 0) {
            index = -1;
        }
        iterators = new Stack<>();
        iterators.add(this.factors.get(0).iterator());
        current = new Stack<>();
        computeNext();
    }

    @Override
    public boolean hasNext() {
        if (next == null && index >= 0) {
            computeNext();
        }
        return next != null;
    }

    @Override
    public List<T> next() {
        if (!hasNext()) {
            throw new IllegalStateException();
        }
        var result = next;
        next = null;
        return result;
    }
}