Ist es möglich, die Java 8 Stream API auf der Android API <24 zu verwenden?

Ich habe diesen Beitrag hier gelesen . Trotzdem kann ich auf minSdkVersion <24 keinen Code ausführen, der Java 8 Stream-API-Funktionen wie die folgenden enthält.

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

Dies wird aufgrund der Fehlermeldung nicht ausgeführt

Für den Aufruf ist API-Level 24 erforderlich (aktuell mindestens 15): java.util.Collection # stream

Kennt jemand eine Lösung?

[ursprüngliche Antwort]

Sie können keine Java8-Streams auf API-Ebene <24 verwenden.

Es gibt jedoch einige Bibliotheken, die einige der Stream-Funktionen zurückportieren

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

https://github.com/konmik/solid

https://sourceforge.net/projects/streamsupport/ (von @sartorius im Kommentar erwähnt)

[Update k3b 2019-05-23]

https://github.com/retrostreams/android-retrostreams ist ein Spin-off von Streamsupport, das die Fähigkeit der Android Studio 3.x D8 / Desugar-Toolchain nutzt, Standard- und statische Schnittstellenmethoden über Jar-Dateigrenzen hinweg zu verwenden. Es gibt auch Links zu anderen Android-RetroXXX, dh für CompletableFuture.

[Aeracode 2020-07-24 aktualisieren]

Gute Nachrichten , jetzt können wir Java 8 Stream API und mehr verwenden, ohne dass eine Mindest-API-Ebene erforderlich ist .

Seit Release 8.2 von DexGuard ist es möglich, die Java 8-Streams-API auch auf Android-Geräten <API-Ebene 24 zu verwenden. Dazu muss die Streamsupport- Bibliothek enthalten sein, und DexGuard übersetzt alle Java 8-Stream-API-Aufrufe in die bereitgestellten Bibliothek. Es ist keine zusätzliche Behandlung erforderlich, und Entwickler können einfach mithilfe der bereitgestellten Java 8-Streams-API codieren. Abhängigkeiten werden ebenfalls automatisch übersetzt, sodass Bibliotheken mit Java 8-Funktionen auch für die Android-Entwicklung verwendet werden können.

Diese Funktion wird in naher Zukunft auch in ProGuard enthalten sein. Bleiben Sie dran.

Bearbeiten: Proguard 6.1.0, für das es bereits eine Beta-Version gibt, unterstützt das Backportieren von Java 8-Streams und der Zeit-API.

Könnte etwas spät zur Party kommen, aber ich habe gerade gesehen, dass wir, wenn wir verwenden, java8.util.stream.StreamSupportdenselben funktionalen Programmieransatz ausführen und ihn vor Api 24 verwenden können. ZB aus web3j -

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

Ja, das ist es ! Ausgehend von AGP 4.0.0 wir Stream - API verwenden können , und einige andere Java 8+ APIs (zB java.time)

Minimal erforderliche Änderungen am build.gradle Ihrer 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'
}

Eine andere Lösung, die ich gerne verwende, ist die statische Verwendung von Kotlins Erweiterungen über Sammlungen aus Java-Code, wenn das Projekt natürlich beide unterstützt :

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

Das Gleiche gilt für .map, .reduce, .first, ... usw.

Erstellen Sie eine Schnittstelle.

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

Erstellen Sie eine Filtermethode.

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;
        }
    }

Verwenden von Code

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