È possibile utilizzare l'API Java 8 Stream su API Android <24?

Ho letto questo post qui. Ma ancora non riesco a eseguire codice contenente le funzionalità API Java 8 Stream come le seguenti su minSdkVersion <24.

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

Non viene eseguito a causa del messaggio di errore

La chiamata richiede il livello API 24 (il valore minimo corrente è 15): java.util.Collection # stream

Quindi qualcuno conosce una soluzione?

[risposta originale]

Non è possibile utilizzare flussi Java8 a livello API <24.

Tuttavia, ci sono alcune librerie che eseguono il backport di alcune delle funzionalità del flusso

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

https://github.com/konmik/solid

https://sourceforge.net/projects/streamsupport/ (menzionato da @sartorius nel commento)

[aggiornamento k3b 23/05/2019]

https://github.com/retrostreams/android-retrostreams è uno spinoff di streamsupport che sfrutta la capacità della toolchain di Android Studio 3.x D8 / desugar di utilizzare metodi statici e predefiniti dell'interfaccia oltre i limiti del file Jar. Ci sono anche collegamenti ad altri android-retroXXX cioè per CompletableFuture.

[aggiornamento aeracode 2020-07-24]

Buone notizie , ora possiamo utilizzare Java 8 Stream API e altro senza richiedere un livello API minimo .

Dalla versione 8.2 di DexGuard è possibile utilizzare l'API Java 8 stream anche su dispositivi Android <livello API 24. Per fare ciò, è necessario includere la libreria di supporto stream e DexGuard tradurrà tutte le chiamate API Java 8 stream nel biblioteca. Non è necessaria alcuna gestione aggiuntiva e gli sviluppatori possono semplicemente codificare utilizzando l'API Java 8 stream fornita. Anche le dipendenze vengono tradotte automaticamente, quindi è possibile utilizzare librerie con funzionalità Java 8 anche per lo sviluppo Android.

Questa funzionalità sarà inclusa anche in ProGuard nel prossimo futuro, rimanete sintonizzati.

Modifica: Proguard 6.1.0 per il quale esiste già una versione beta supporta il backporting del flusso Java 8 e dell'API temporale.

Potrebbe essere un po 'tardi per la festa, ma ho appena visto che se lo usiamo java8.util.stream.StreamSupportpossiamo eseguire lo stesso approccio di programmazione funzionale e usarlo prima di Api 24. Ad esempio, tratto da web3j -

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

Sì, lo è ! A partire da AGP 4.0.0 possiamo utilizzare Stream API e alcune altre API Java 8+ (ad esempio java.time)

Modifiche minime richieste al build.gradle della tua app :

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

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

Un'altra soluzione che mi piace usare è usare staticamente le estensioni di Kotlin su Collezioni dal codice Java, se il progetto ovviamente supporta entrambe :

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

Lo stesso vale per .map, .reduce, .first, ecc ...

Crea un'interfaccia.

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

Crea un metodo di 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;
        }
    }

Utilizzo del codice

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