Bibliothek-Methode, um partition einer Sammlung, die ein Prädikat

Habe ich eine Sammlung von Objekten, möchte ich eine partition in zwei Sammlungen, von denen geht ein Prädikat, und von denen scheitert ein Prädikat. Ich hatte gehofft, es wäre ein Guave Methode, dies zu tun, aber die nächsten kommen Sie ist filter, die nicht geben Sie mir die andere Sammlung.

Ich würde das Bild die Signatur der Methode, wäre so etwas wie dieses:

public static <E> Pair<Collection<E>, Collection<E>> partition(Collection<E> source, Predicate<? super E> predicate)

Ich weiß, das ist super schnell zum code selbst, aber ich bin auf der Suche nach einer vorhandenen Bibliothek Methode, die das tut, was ich will.

Beachten Sie, dass im Falle von beschränkten Satz von im Voraus bekannt partiotion Schlüssel kann es viel effizienter GC-wise nur zum Durchlaufen der collection einmal mehr für jede partition Taste überspringen alle anderen-wichtige Elemente, die bei jeder iteration.
Anderen beiden GC-freundlich und gekapselt Ansatz ist die Nutzung von Java-8 filtern-wrapper Bächen rund um original-Sammlung: stackoverflow.com/questions/19940319/...

InformationsquelleAutor Edward Dale | 2012-05-11

26

Verwenden Guave ist Multimaps.index.

Hier ist ein Beispiel, welche Partitionen einer Liste von Wörtern in zwei Teile: diejenigen, die haben die Länge > 3 und jene, die nicht.
```
List<String> words = Arrays.asList("foo", "bar", "hello", "world");

ImmutableListMultimap<Boolean, String> partitionedMap = Multimaps.index(words, new Function<String, Boolean>(){
    @Override
    public Boolean apply(String input) {
        return input.length() > 3;
    }
});
System.out.println(partitionedMap);
```
Drucke:
```
false=[foo, bar], true=[hello, world]
```
- Danke, ich hätte nicht gedacht dort zu suchen.
- Wenn Sie bereits ein Prädikat, können Sie es in eine Funktion mit Funktionen.forPredicate.
- Update für Java 8: eine ähnliche Methode ist auch in der streaming-Paket java.util.stream.Collectors#groupingBy(java.util.function.Function<....>) geht Es wie words.stream().collect(Collectors.groupingBy(func))
- ich habe soeben eine Antwort auf Ihren Vorschlag
InformationsquelleAutor dogbane

Mit der neuen java-8-features(stream und lambda epressions), könnten Sie schreiben:

List<String> words = Arrays.asList("foo", "bar", "hello", "world");

Map<Boolean, List<String>> partitionedMap =
        words.stream().collect(
                Collectors.partitioningBy(word -> word.length() > 3));

System.out.println(partitionedMap);

InformationsquelleAutor gontard

Wenn Sie Eclipse-Sammlungen (ehemals GS-Sammlungen), die Sie verwenden können, die partition Methode auf alle RichIterables.

MutableList<Integer> integers = FastList.newListWith(-3, -2, -1, 0, 1, 2, 3);
PartitionMutableList<Integer> result = integers.partition(IntegerPredicates.isEven());
Assert.assertEquals(FastList.newListWith(-2, 0, 2), result.getSelected());
Assert.assertEquals(FastList.newListWith(-3, -1, 1, 3), result.getRejected());

Den Grund für die Verwendung eines benutzerdefinierten Typs PartitionMutableList statt Pair ist es, kovariante Rückgabetypen für getSelected() und getRejected(). Zum Beispiel Partitionierung einer MutableCollection gibt zwei Sammlungen statt der Listen.

MutableCollection<Integer> integers = ...;
PartitionMutableCollection<Integer> result = integers.partition(IntegerPredicates.isEven());
MutableCollection<Integer> selected = result.getSelected();

Wenn Sie Ihre Sammlung nicht RichIterable, können Sie immer noch die statische utility in Eclipse Sammlungen.

PartitionIterable<Integer> partitionIterable = Iterate.partition(integers, IntegerPredicates.isEven());
PartitionMutableList<Integer> partitionList = ListIterate.partition(integers, IntegerPredicates.isEven());

Hinweis: ich bin committer für Eclipse Sammlungen.

InformationsquelleAutor Craig P. Motlin

0

Apache Commons Collections IterableUtils bietet Methoden für die Partitionierung Iterable Objekte basierend auf einem oder mehreren Prädikaten. (Schauen Sie für die partition(...) Methoden.)

InformationsquelleAutor Christoph Leuzinger

Beachten Sie, dass im Falle von beschränkten Satz von im Voraus bekannt partiotion Schlüssel kann es viel effizienter, einfach zum Durchlaufen der collection einmal mehr für jede partition Taste überspringen alle anderen-wichtige Elemente, die bei jeder iteration. Als wäre dies nicht zuordnen, viele neue Objekte für den Garbage Collector.

LocalDate start = LocalDate.now().with(TemporalAdjusters.firstDayOfYear());
LocalDate endExclusive = LocalDate.now().plusYears(1);
List<LocalDate> daysCollection = Stream.iterate(start, date -> date.plusDays(1))
        .limit(ChronoUnit.DAYS.between(start, endExclusive))
        .collect(Collectors.toList());
List<DayOfWeek> keys = Arrays.asList(DayOfWeek.values());

for (DayOfWeek key : keys) {
    int count = 0;
    for (LocalDate day : daysCollection) {
        if (key == day.getDayOfWeek()) {
            ++count;
        }
    }
    System.out.println(String.format("%s: %d days in this year", key, count));
}

Anderen beiden GC-freundlich und gekapselt Ansatz ist die Nutzung von Java 8 filtern von wrapper-streams rund um die original-Sammlung:

List<AbstractMap.SimpleEntry<DayOfWeek, Stream<LocalDate>>> partitions = keys.stream().map(
        key -> new AbstractMap.SimpleEntry<>(
                key, daysCollection.stream().filter(
                    day -> key == day.getDayOfWeek())))
        .collect(Collectors.toList());
//partitions could be passed somewhere before being used
partitions.forEach(pair -> System.out.println(
        String.format("%s: %d days in this year", pair.getKey(), pair.getValue().count())));

Beide snippets drucken:

MONDAY: 57 days in this year
TUESDAY: 57 days in this year
WEDNESDAY: 57 days in this year
THURSDAY: 57 days in this year
FRIDAY: 56 days in this year
SATURDAY: 56 days in this year
SUNDAY: 56 days in this year

InformationsquelleAutor Vadzim

scheint ein guter job für die neue Java-12 Collectors::teeing

var dividedStrings = Stream.of("foo", "hello", "bar", "world")
            .collect(Collectors.teeing(
                    Collectors.filtering(s -> s.length() <= 3, Collectors.toList()),
                    Collectors.filtering(s -> s.length() > 3, Collectors.toList()),
                    List::of
            ));
System.out.println(dividedStrings.get(0)); //[foo, bar]
System.out.println(dividedStrings.get(1)); //[hello, world]

InformationsquelleAutor Adrian

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.