Existe uma alternativa para instanceof ao filtrar um fluxo Java por classe?

Eu tenho uma situação inesperada em um projeto no qual todos os tipos que estendem uma classe são compactados em uma coleção Java; mas apenas uma extensão específica dessa classe contém um método adicional. Vamos chamar de "also ()"; e deixe-me esclarecer que nenhuma outra extensão possui. Antes de executar uma tarefa em cada item dessa coleção, preciso chamar também () todos os itens que a implementam.

O caminho mais fácil é o seguinte:

stuff.stream().filter(item -> item instanceof SpecificItem)
            .forEach(item -> ((SpecificItem)item).also()));
stuff.stream().forEach(item -> item.method());

Funciona bem, mas não me sinto confortável com a "instânciaof" lá. Isso geralmente é um marcador de mau cheiro de código. É muito possível que eu refatore essa classe apenas para me livrar dela. Antes de fazer algo tão dramático, pensei em verificar com a comunidade e ver se alguém com mais experiência no Streams ou no Collections tinha uma solução mais simples.

Como exemplo (certamente não exclusivo), é possível obter uma visão de uma coleção que filtra entradas por classe?

Eu sugiro .mapque faça uma ligação para fazer o elenco para você. Então seu código posterior pode usar a 'coisa real'.

Antes:

stuff.stream().filter(item -> item instanceof SpecificItem)
            .forEach(item -> ((SpecificItem)item).also()));

Depois de:

stuff.stream().filter(item -> item instanceof SpecificItem)
            .map(item -> (SpecificItem)item)
            .forEach(specificItem -> specificItem.also()));

Isso não é perfeito, mas parece limpar um pouco as coisas.

Eu tenho uma situação inesperada em um projeto no qual todos os tipos que estendem uma classe são compactados em uma coleção Java; mas apenas uma extensão dessa classe implementa um método. Vamos chamá-lo de "also ()". Antes de executar uma tarefa em cada item dessa coleção, preciso chamar também () todos os itens que a implementam.

Obviamente, esse é um design defeituoso. Pelo que você escreveu, não está claro, o que significa, que uma classe não implementa o método. Se simplesmente não fizer nada , não importaria, então presumo que exista um efeito colateral indesejado.

Funciona bem, mas não me sinto confortável com a "instânciaof" lá.

Suas entranhas estão certas. Um bom design orientado a objetos funcionaria sem mais conhecimento do que exatamente um objeto, ou se é uma instância de um tipo especial.

Antes de fazer algo tão dramático, pensei em verificar com a comunidade e ver se alguém com mais experiência no Streams ou no Collections tinha uma solução mais simples.

A refatoração não é dramática. Melhora a qualidade do código.

Com sua base de código fornecida, a solução mais simples seria, para garantir, você ter duas coleções separadas, uma com a classe pai e outra com a classe filho. Mas isso não é muito limpo.

É difícil dar recomendações específicas sem saber o que SpecificIteme also()realmente são, mas:

Defina also()na superclasse de SpecificItem. Dê a ele uma implementação padrão que não faça nada (dê um corpo de método vazio). Subclasses individuais podem substituí-lo, se desejado. Dependendo do que alsorealmente é, pode ser necessário renomeá-lo para algo que faça sentido para todas as classes envolvidas.

uma alternativa:

1. faça SpecificItem implementar uma interface (diga "Filtrável")
2. faça uma nova classe que estenda o Stream
3. crie um novo método de 'filtro' que aceite objetos que implementem sua interface
4. substitua o método de fluxo original e redirecione-o para sua implementação (lançando o parâmetro predicado em sua interface)

Dessa forma, apenas objetos que implementam sua interface poderiam passar temas para o seu método ... não há necessidade de usar instanceof

public class MyStream extends Stream
{
    //...

    Stream<Filterable> filter(Predicate<? implements Filterable> predicate)
    {
         return super.filter(predicate);
    }
}

Espero não estar perdendo nada óbvio aqui (também como sugerido pelo comentário de @Tristan Burnside ), mas por que não posso SpecificItem.method()ligar also()primeiro?

public class SpecificItem extends Item {
    ...
    public void method() {
        also();
        super.method();
    }
}

Como exemplo (certamente não exclusivo), é possível obter uma visão de uma coleção que filtra entradas por classe?

Um fluxo-y maneira que eu posso pensar, à custa de talvez algum impacto no desempenho (YMMV), é a collect() via Collectors.groupingBy()na classe como a chave, em seguida, escolher o que você quer do resultado Map. Os valores são armazenados como a List; portanto, se você esperava fazer essa filtragem em um Sete espera filtrá- Setlo, precisará de uma etapa adicional para inserir ainda mais os valores em um resultado Set.

Aqui está a minha abordagem:

stuff.stream().filter(item -> SpecificItem.class.isInstance(item)).map(item  -> SpecificItem.class.cast(item)).forEach(item -> item.also());
stuff.stream().forEach(item -> item.method());

Nenhuma instância de , nenhuma conversão explícita (na verdade, é uma conversão explícita, mas mascarada por uma chamada de método). Eu acho que isso é o melhor possível.