Est-il possible d'utiliser l'API Java 8 Stream sur l'API Android <24?

J'ai lu cet article ici. Mais je ne peux toujours pas exécuter de code contenant les fonctionnalités de l'API Java 8 Stream telles que les suivantes sur minSdkVersion <24.

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

Cela ne fonctionne pas en raison du message d'erreur

L'appel nécessite le niveau d'API 24 (le minimum actuel est 15): java.util.Collection # stream

Alors, quelqu'un connaît-il une solution?

[réponse originale]

Vous ne pouvez pas utiliser les flux Java8 au niveau API <24.

Cependant, certaines bibliothèques rétroportent certaines des fonctionnalités de flux

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

https://github.com/konmik/solid

https://sourceforge.net/projects/streamsupport/ (mentionné par @sartorius dans un commentaire)

[mise à jour k3b 23/05/2019]

https://github.com/retrostreams/android-retrostreams est une retombée de streamsupport qui tire parti de la capacité d'Android Studio 3.x D8 / desugar toolchain à utiliser les méthodes d'interface par défaut et statiques à travers les limites des fichiers Jar. Il existe également des liens vers d'autres android-retroXXX ie pour CompletableFuture.

[mise à jour aeracode 2020-07-24]

Bonne nouvelle , nous pouvons désormais utiliser l'API Java 8 Stream et plus sans avoir besoin d'un niveau d'API minimum .

Depuis la version 8.2 de DexGuard, il est possible d'utiliser l'API de flux Java 8 également sur les appareils Android <niveau de l'API 24. Pour ce faire, il faut inclure la bibliothèque streamsupport et DexGuard traduira tous les appels d'API de flux Java 8 vers le fichier fourni. bibliothèque. Aucune manipulation supplémentaire n'est nécessaire et les développeurs peuvent simplement coder à l'aide de l'API Java 8 streams fournie. Les dépendances sont également traduites automatiquement, il est donc possible d'utiliser des bibliothèques avec des fonctionnalités Java 8 également pour le développement Android.

Cette fonctionnalité sera également incluse dans ProGuard dans un proche avenir, restez à l'écoute.

Edit: Proguard 6.1.0 pour lequel il existe déjà une version bêta prend en charge le backporting Java 8 stream et time API.

Peut-être un peu tard à la fête, mais je viens de voir que si nous utilisons, java8.util.stream.StreamSupportnous pouvons exécuter la même approche de programmation fonctionnelle et l'utiliser avant Api 24. Par exemple, tiré de web3j -

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

Oui, ça l'est ! À partir d'AGP 4.0.0, nous pouvons utiliser l'API Stream et d'autres API Java 8+ (par exemple java.time)

Modifications minimales requises pour build.gradle de votre application :

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

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

Une autre solution que j'aime utiliser est d'utiliser statiquement les extensions de Kotlin sur des collections à partir de code Java, si le projet prend en charge les deux bien sûr :

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

Idem pour .map, .reduce, .first, etc ...

Créez une interface.

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

Créez une méthode de filtrage.

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

Utilisation du code

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