É possível usar a API Java 8 Stream na API Android <24?

Eu li esse post aqui. Mas ainda não consigo executar o código que contém os recursos da API Java 8 Stream como o seguinte em minSdkVersion <24.

List<Car> newCars = cars.stream()
                        .filter(s -> s.getColor().equals("red"))
                        .collect(Collectors.toList());

Isso não funciona devido à mensagem de erro

A chamada requer API de nível 24 (o mínimo atual é 15): java.util.Collection # stream

Então, alguém conhece uma solução?

[resposta original]

Você não pode usar fluxos Java8 no nível de API <24.

No entanto, existem algumas bibliotecas que suportam algumas das funcionalidades de fluxo

https://github.com/aNNiMON/Lightweight-Stream-API

https://github.com/konmik/solid

https://sourceforge.net/projects/streamsupport/ (mencionado por @sartorius no comentário)

[atualizar k3b 23/05/2019]

https://github.com/retrostreams/android-retrostreams é uma derivação do streamsupport que aproveita a capacidade do conjunto de ferramentas D8 / desugar do Android Studio 3.x de usar métodos estáticos e padrão de interface através dos limites do arquivo Jar. Também há links para outro android-retroXXX, ou seja, para CompletableFuture.

[atualizar aeracode 2020-07-24]

Boas notícias , agora podemos usar a API Java 8 Stream e muito mais sem exigir um nível mínimo de API .

Desde o lançamento 8.2 do DexGuard é possível usar a API Java 8 streams também em dispositivos Android <nível API 24. A fim de fazê-lo, é preciso incluir o streamsupport biblioteca e DexGuard irá traduzir todos os 8 fluxo de chamadas de API Java para o fornecido biblioteca. Nenhuma manipulação adicional é necessária e os desenvolvedores podem simplesmente codificar usando a API de fluxos Java 8 fornecida. As dependências também são traduzidas automaticamente, portanto, é possível usar bibliotecas com recursos do Java 8 também para desenvolvimento em Android.

Esse recurso também será incluído no ProGuard em um futuro próximo, fique atento.

Editar: Proguard 6.1.0 para o qual já existe uma versão beta suporta backporting Java 8 stream e time API.

Pode ser um pouco tarde para a festa, mas acabei de ver que se usarmos java8.util.stream.StreamSupport, podemos executar a mesma abordagem de programação funcional e usá-la antes do Api 24. Ex. Retirado do web3j -

StreamSupport.stream(transactionReceipt.getLogs())
            .map(log -> extractEventParameters(event, log))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());

Sim, é verdade ! A partir do AGP 4.0.0, podemos usar a API Stream e algumas outras APIs Java 8+ (por exemplo java.time)

Mudanças mínimas necessárias no build.gradle do seu aplicativo :

android {
  compileOptions {
    // Flag to enable support for the new language APIs
    coreLibraryDesugaringEnabled true
  }
}

dependencies {
  coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.0.9'
}

Outra solução que gosto de usar é usar estaticamente as extensões de Kotlin em vez de coleções do código Java, se o projeto suportar ambos, é claro :

List<Car> newCars = CollectionsKt.filter(cars, s -> s.getColor().equals("red"));

Mesmo para .map, .reduce, .first, etc ...

Crie uma interface.

public interface Pre<T,R> {
            R get(T item);
        }

Crie um método de filtro.

public static  <T> List<T> Filter(List<T> list, Pre<T,Boolean> pre) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
        {
            return list.stream().filter(p -> pre.get(p)).collect(Collectors.toList());
        }
        else
        {
            List<T> col = new ArrayList<T>();
            for (int i = 0 ; i < list.size() ; i++)
                if (pre.get(list.get(i)))
                    col.add(list.get(i));
            return col;
        }
    }

Usando código

    public static class model {
            public String Name;
        }
List<model> models = new ArrayList<>();
            ...
            List<model> filtermodels = Filter(models,p-> p.Name.equals("filter"));