Método de biblioteca para particionar una colección por un predicado

Con las nuevas características de java 8 ( stream y lambda epresions ), podría escribir:

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

Si está utilizando Colecciones de Eclipse (anteriormente Colecciones GS), puede usar el método partition en todos 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());

La razón para usar un tipo personalizado, PartitionMutableList, en lugar de Pair es permitir tipos de retorno covariantes para getSelected() y getRejected(). Por ejemplo, particionar un MutableCollection da dos colecciones en lugar de listas.

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

Si su colección no es un RichIterable, aún puede usar la utilidad estática en Eclipse Colecciones.

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

Nota: Soy un committer para las Colecciones de Eclipse.

Colecciones de Apache Commons IterableUtils proporciona métodos para particionar objetos Iterable basados en uno o más predicados. (Busque los métodos partition(...).)

Tenga en cuenta que en caso de un conjunto limitado de claves de partición conocidas de antemano, puede ser mucho más eficiente iterar la colección una vez más para cada clave de partición omitiendo todos los elementos de clave diferente en cada iteración. Como esto no asignaría muchos objetos nuevos para el Recolector de basura.

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

Otro enfoque amigable con GC y encapsulado es el uso de flujos de envoltura de filtrado Java 8 alrededor de la colección original:

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

Ambos fragmentos imprimen esto:

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