гуавы с помощью Java 8 параллельного потока

Question

Нужна помощь в фильтрации ImmutableTable гуавы с помощью параллельного потока и коллектора

Неизменное tofilterTable;

Usecase: Iterate to toFilter и удалить элементы, которые не присутствуют, или значение входа не является ложным в таблице validEntry. Традиция способ сделать это через цикл:

ImmutableTable<MarketplaceArc, String, ObjectB> filterInactive(final ImmutableTable<MarketplaceArc, String, ObjectB> toFilter) { 

    final ImmutableTable.Builder filteredResultBuilder = 
      ImmutableTable.builder(); 

    final Map<MarketplaceArc, Map<String, ObjectB>> rowMap = 
    browseMappings.rowMap(); 

    for (final Map.Entry<MarketplaceArc, Map<String, ObjectB>> 
     rowMapEntry : rowMap.entrySet()) { 

     for (final Map.Entry<String, ObjectB> entry : 
      rowMapEntry.getValue().entrySet()) { 

      if(ifActive(rowMap.getKey, entry)){ 
      filteredResultBuilder.put(
        rowMapEntry.getKey(), 
        entry.getKey(), 
        buildObjectB(entry)); 
       } 
     } 
    } 
    return filteredResultBuilder.build(); 
} 

Есть лучше и лаконичный способ сделать это с помощью Java parallelStreams?

Answer 1

Да, вы можете сделать лучше. Вы можете использовать Table.Cell, для одного. Таким образом, вы уменьшаете свои две петли в одну. Вы даже можете сделать свой метод более универсальным, используя предикаты.

Я знаю, что вы написали, что ваше приложение предназначено для Java 8, но это просто невозможно сделать с потоками Java 8 и такими классными вещами, потому что Table не очень хорошо разработан для Java 8 до сих пор (не может построить таблицу из Itera {ble, tor} Cell s, таблицы не требуют BiPredicate, но TriPredicate). Итак, давайте улучшим ваш код, простой и простой.

Обычная старая петля, оптимизированная для Table s

Так вот базовая версия. Ничего экстраординарного, но лучше работает, чем ваш путь, потому что он не полагается на промежуточные сложные структуры данных (вы продолжаете использовать карты, например, это решение не имеет).

ImmutableTable<MarketplaceArc, String, ObjectB> filterInactive(Table<MarketplaceArc, String, ObjectB> unfiltered) { 
    ImmutableTable.Builder<MarketplaceArc, String, ObjectB> filtered = ImmutableTable.builder(); 
    for (Table.Cell<MarketplaceArc, String, ObjectB> cell: unfiltered.cells()) { 
    if (isActive(cell.getRow(), cell.getValue())) { 
     filtered.put(cell); 
    } 
    } 
    return filtered.build(); 
} 

Родовое решение с предикатами

Более общим решением должны иметь общий метод фильтрации. Что будет делать ваш код более удобным для чтения, благодаря некоторой Java 8 магии:

// Generic method. 
<R,C,V> ImmutableTable<R,C,V> filterToImmutable(Table<R,C,V> unfiltered, Predicate<Table.Cell<R,C,V>> predicate) { 
    ImmutableTable.Builder<R,C,V> filtered = ImmutableTable.builder(); 

    // Actually, let's use some Java 8, just because we can! 
    unfiltered.cells().parallelStream() 
     .filter(predicate) 
     .foreach(filtered::put); 
    return filtered.build(); 
} 

// Specific predicate 
boolean isActiveCell(Table.Cell<MarketplaceArc, String, ObjectB> cell) { 
    return isActive(cell.getRow(), cell.getValue()); 
} 

// Use all you've written, with some Java 8, just because we can. Again. 
ImmutableTable<MarketplaceArc, Map<String, ObjectB> unfiltered = ... ; 
ImmutableTable<MarketplaceArc, Map<String, ObjectB> filtered = filterToImmutable(unfiltered, this::isActiveCell);