Erste Teilliste aus einer Java-Liste mit N-TEN Elemente, die die Bedingung erfüllt mit streams

Ich habe einen sehr einfachen Anwendungsfall

Gegeben eine Liste von Buchstaben, die mit A und Bs, ich möchte, um die Unterliste enthält die ersten N-Bs Beispiel:

f(3, [A A A B A B A B A A B]) = [A A A B A B A B]
f(2, [A A A B A B A B A A B]) = [A A A B A B]
f(1, [A A B A B A B]) = [A A B]
f(0, [A A B A B]) = []

Durch folgenden Imperativ Ansatz, das ist relativ einfach, zählen Sie bis finden wir N Bs, und dann bekommen die Teilliste, bis diese position.

Allerdings, ich konnte nicht finden eine funktionale Lösung mit Lambda-Ausdrücke, die seit der operation an jedem node zu sein scheint unabhängig von den anderen (was ich denke, Sinn für Parallelisierung).

Was meinst du mit funktionale Lösung mit lambdas? Sprechen Sie über streams? Können Sie uns einige pseudo-code, lassen Sie uns wissen, was Sie nach sind?
Ich möchte nur code mit Bächen, dass der folgende Imperativ-Funktion:

private List<String> getSubList(int maxAmount, List<String> inputList) 	{ 		ArrayList<String> result = new ArrayList<String>(); 		 		int itemsFound = 0; 		for (String item : inputList) 		{ 			result.add(item); 			if (item.equals("B")) itemsFound++; 			if (itemsFound == maxAmount); 				break; 		} 		 		return result; 	}

Warten Sie, bis Java 9 und Stream#takeWhile. Aber Ihre Logik verlangt eine stateful-Prädikat, das wird immer ein Stolperstein sein.

InformationsquelleAutor user3483969 | 2015-08-31

Wenn Sie Ihre Eingabe ist ein List mit schnellen wahlfreien Zugriff können Sie lösen Ihr problem mit dem stream von Indizes:

public static List<String> f(int n, List<String> input) {
    int fence = IntStream.range(0, input.size())
                         .filter(idx -> input.get(idx).equals("B")) //leave only B's
                         .skip(n-1)
                         .findFirst() //an index of n-th B
                         .getAsInt(); //with throw NoSuchElementException if not enough B's
    return input.subList(0, fence+1);
}

Beispiel:

System.out.println(f(3, Arrays.asList("A", "A", "A", "B", "A", "B", "A", "B", "A", "A")));
System.out.println(f(2, Arrays.asList("A", "A", "A", "B", "A", "B", "A", "B", "A", "A")));
System.out.println(f(1, Arrays.asList("A", "A", "A", "B", "A", "B", "A", "B", "A", "A")));

Jedoch trotz ich Liebe Stream-API würde ich dieses problem lösen Imperativ.

Dank Tagir, das ist genau das, was ich suchte. In jedem Fall habe ich mit Ihnen überein, in diesem Fall der imperative Ansatz scheint zu sein, viel mehr Begründung, so werde ich es lassen, wie jetzt in den code.
Aber Ihre Hilfe ist sehr wertvoll, um tiefer in das funktionelle Verständnis der Sprache.

InformationsquelleAutor Tagir Valeev

0

Diesem code-snippet, das den job tun.
```
public static void main(String[] args) {
    final String input = "A A A B A B A B A A";
    final String[] array = input.split(" ");
    final List<String> list = Arrays.asList(array);
    final List<String> result = getSubList(list, 3);
    System.out.println("Result=" + result);
}

public static List<String> getSubList(final List<String> list, final int limit) {
    final AtomicInteger counter = new AtomicInteger();
    return list.stream()
            .filter(ch -> {
                if (ch.equals("B") && counter.incrementAndGet() == limit) return true;
                return counter.get() < limit;
            })
            .collect(Collectors.toList());
}
```
Beachten Sie, dass Ihre Lösung gegen Vertrag von filter Methode: die mitgelieferten Prädikat muss staatenlos wäre.
Nicht "muss" sondern "sollte". Diese Lösung nicht brach jede Einschränkung. Verwendet Operationen auf AtomicInteger synchronisiert werden (und atomaren). Trotzdem gibt es in diesem Fall keine option zu verwenden parallelStream aber einfache Strom - die Verwendung eines Threads. Nicht so orthodox - Java 8 das ist nicht real, funktionale Programmiersprache.
Vielen Dank für Ihre alternative. Auch wenn es nicht sicher ist, wenn es gegen den Vertrag von filter oder nicht, ich fühle es trägt ein wenig mehr Komplexität (D. H. einen AtomicInteger sollte verwendet werden, anstelle von einer normalen). Im Ende denke ich, dass der imperative Ansatz ist klarer in diesem Fall
Ich Stimme mit Ihnen, aber IMO Java-Stream-API ist schlecht, wenn Sie vergleichen Sie es mit ähnlichen Scala-API. Außerdem TagirValeev Ansatz ist auch nicht "so zwingend", weil es Lesen/vergleichen Elemente von veränderlichen collection :/ In der Tat ist sogar noch schlimmer, da der get-Methode, die auf der Liste sind nicht atomar, ich Verteidige meine super Lösung 😛 Vote bis Mann 😉 youtube.com/watch?v=REUukm_WQJI
Yep, obwohl ich gerne die Möglichkeit, mehr zu schreiben "funktionalen" Stil-code, der die API ist nicht so flexibel wie Scala.

InformationsquelleAutor Karol Król

Hier ist der code von AbacusUtil

List<String> input = N.asList("A", "A", "A", "B", "A", "B", "A", "B", "A", "A");
List<String> list = Stream.of(input).takeWhile(MutableInt.of(3), (e, cnt) -> cnt.getAndAdd(e.equals("B") ? -1 : 0) > 0).toList();
N.println(list);

Erklärung： ich bin der Entwickler des AbacusUtil.

InformationsquelleAutor user_3380739

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.