Caso de uso:
Lista de processos de string via método que retornaImmutableTable do tipo{R,C,V}. Por exemploImmutableTable of {Integer,String,Boolean} process(String item){...}

Coletar o resultado, mesclar todos os resultados e retornarImmutableTable. Existe uma maneira de conseguir isso?

Implementação atual (como sugerido por Bohemian):

Que tal usar fluxo paralelo? Há algum problema de simultaneidade no código abaixo? Com o fluxo paralelo, obtendo "NullPointerException no índice 1800" em tableBuilder.build (), mas funciona bem com o fluxo.

ImmutableTable<Integer, String, Boolean> buildData() {   

  // list of 4 AwsS3KeyName   
listToProcess.parallelStream() 

  //Create new instance via Guice dependency injection 
.map(s3KeyName -> ProcessorInstanceProvider.get()    
.fetchAndBuild(s3KeyName)) 
.forEach(tableBuilder::putAll); 

 return tableBuilder.build(); }

Enquanto o código abaixo funciona muito bem com fluxo, bem como fluxo paralelo. Mas ImmutableBuild está falhando devido à entrada duplicada para linha e col. Qual poderia ser a melhor maneira de evitar duplicatas ao mesclar tabelas?

public static <R, C, V> Collector<ImmutableTable<R, C, V>,     
ImmutableTable.Builder<R, C, V>, ImmutableTable<R, C, V>>   
toImmutableTable() 
{ 
return Collector.of(ImmutableTable.Builder::new, 
ImmutableTable.Builder::putAll, (builder1, builder2) -> 
builder1.putAll(builder2.build()), ImmutableTable.Builder::build); }

Editar: se houver alguma entrada duplicada no ImmutableTable.Builder ao mesclar tabelas diferentes, ela falhará,

Tentando evitar o erro, colocando ImmutableTables em HashBasedTable

  ImmutableTable.copyOf(itemListToProcess.parallelStream()
            .map(itemString ->
           ProcessorInstanceProvider.get()
                    .buildImmutableTable(itemString))
                    .collect(
                            Collector.of(
                                    HashBasedTable::create,
                                    HashBasedTable::putAll,
                                    (a, b) -> {
                                        a.putAll(b);
                                        return a;
                                    }));
  )

Mas estou recebendo a exceção de tempo de execução "Causada por: java.lang.IllegalAccessError: tentou acessar a classe com.google.common.collect.AbstractTable".

Como podemos usar o HashBasedTable como Accumulator para coletar ImmutablesTables, pois o HashBasedTable substitui a entrada existente pela mais recente e não falha se tentarmos colocar uma entrada duplicada e retornar a tabela Imutável agregada.