En recherchant sur le Web, il n'est pas clair si Java 8 est pris en charge pour le développement Android ou non.

Avant de télécharger / configurer Java 8, quelqu'un peut-il m'indiquer toute documentation "officielle" qui dit que Java 8 est ou n'est pas pris en charge pour le développement Android.

java 8

Android prend en charge toutes les fonctionnalités du langage Java 7 et un sous-ensemble des fonctionnalités du langage Java 8 qui varient selon la version de la plateforme.

Pour vérifier quelles fonctionnalités de java 8 sont prises en charge

Utiliser les fonctionnalités du langage Java 8

Nous avons décidé d'ajouter la prise en charge des fonctionnalités du langage Java 8 directement dans l'ensemble d'outils javac et dx actuel, et de déconseiller la chaîne d'outils Jack. Avec cette nouvelle orientation, les outils et plugins existants qui dépendent du format de fichier de classe Java devraient continuer à fonctionner. À l'avenir, les fonctionnalités du langage Java 8 seront prises en charge nativement par le système de génération Android. Nous avons l'intention de le lancer dans le cadre d'Android Studio dans les semaines à venir, et nous voulions partager cette décision dès que possible avec vous.

L'avenir de la prise en charge des fonctionnalités du langage Java 8 sur Android

Utilisateurs Eclipse:

Pour les anciens développeurs qui préfèrent Eclipse, Google arrête la prise en charge des outils de développement Android Eclipse

si vous avez installé Java 8 JDK, essayez-le, en cas de problème, essayez de définir le compilateur sur 1.6 dans Eclipse à partir du menu de la fenêtre → Préférences → Java → Compilateur . Java 7 fonctionnera aussi:

Java 7 ou supérieur est requis si vous ciblez Android 5.0 et supérieur.

installez plusieurs JDK et essayez.

MISE À JOUR 2017/11/04 - Android Studio 3.0 prend désormais en charge nativement Java 8. gradle-retrolambda n'est plus nécessaire. Voir https://developer.android.com/studio/write/java8-support.html

Le lien ci-dessus comprend également des instructions de migration si vous utilisez gradle-retrolambda. Réponse originale ci-dessous:

Android ne prend pas en charge Java 8. Il ne prend en charge que Java 7 (si vous avez kitkat) et il n'a toujours pas invoquéynamic, uniquement le nouveau sucre de syntaxe.

Si vous souhaitez utiliser lambdas, l'une des principales fonctionnalités de Java 8 dans Android, vous pouvez utiliser gradle-retrolamba . C'est une dépendance de construction gradle qui intègre retrolambda, un outil qui reconvertit le bytecode Java 8 en Java 6/7. Fondamentalement, si vous définissez le compilateur dans Android Studio pour compiler le bytecode Java 8, permettant ainsi aux lambdas, il le reconvertira en Java 6/7 bytecode qui sera ensuite à son tour converti en dalvik bytecode. C'est un hack pour si vous voulez essayer certaines fonctionnalités JDK 8 dans Android au lieu du support officiel.

Vous pouvez en effet utiliser la gradle-retrolambadépendance de construction gradle pour utiliser Java 8 pour le développement Android.

Vous trouverez ci-dessous le guide complet que j'ai récemment suivi pour exécuter des expressions lambda pour le développement Android. La source originale de ce guide est mentionnée à la fin.

Dans ce guide, une méthode pour intégrer certaines fonctionnalités de Java 8 dans les outils de développement Android sera présentée, visant spécifiquement Eclipse IDE. Cependant, les étapes qui seront décrites tout au long de ce guide pourraient également être adaptées au nouvel environnement de développement de Google, Android Studio. Il est basé sur l'édition communautaire du populaire IntelliJ Idea IDE de JetBrains et il a récemment été mis à niveau vers sa version `` bêta '' par Google début juillet 2014, un peu avant la rédaction de ce guide. Eclipse restera le principal environnement de développement, au moins pendant un certain temps, et compte tenu du fait que la plupart des projets Android ont été développés à l'aide d'Eclipse, une méthode pour intégrer de nouvelles fonctionnalités Java 8 comme des expressions lambda dans ADT semble être très utile pour les développeurs.

Le développement Android est basé sur une implémentation Java personnalisée appelée Apache Harmony Project qui a pris fin en 2011. La syntaxe Java la plus couramment utilisée dans le développement Android est Java 6 (v1.6) et Java 7 (v1.7) est également partiellement pris en charge sur l'édition KitKat (Android 4.4. +). Par conséquent, les fonctionnalités Java 8 telles que les expressions lambda ne peuvent pas être utilisées directement dans le développement d'applications Android sans appliquer quelques ajustements aux outils de développement. Heureusement, ces constructions sont essentiellement des améliorations de «sucre syntaxique» qui donnent aux développeurs les lacunes de choses comme les «classes anonymes» et elles peuvent être traduites en classes Java 6 ou Java 7.

Une approche récente pour traduire un code source Java 8 en versions Java inférieures est appelée RetroLambda . Cette bibliothèque permet aux développeurs d'exécuter du code Java 8 avec des expressions lambda sur Java 7 ou même moins. Malheureusement, les fonctionnalités Java 8 autres que les expressions lambda ne sont pas prises en charge par RetroLambda pour l'instant, mais le concept d'expressions lambda est le plus grand saut sur la plate-forme Java 8 et c'est un excellent outil pour les développeurs Android de toute façon.

Les détails sur cette bibliothèque peuvent être trouvés sur sa page GitHub:

https://github.com/orfjackal/retrolambda#getting-started

De plus, un plugin Gradle pour RetroLambda créé par un autre développeur permet aux versions basées sur Gradle d'être implémentées dans des projets Java ou Android. Cependant, le développeur ne mentionne que l'intégration de ce plugin dans l'environnement Android Studio. Les détails peuvent être trouvés sur sa page GitHub:

https://github.com/evant/gradle-retrolambda

L'utilisation de ces infrastructures dans un environnement de développement basé sur Eclipse ne peut pas être abordée directement, mais elle est réalisable et sera démontrée tout au long de ce guide.

Préparation

Ce guide suppose que le lecteur a une compréhension de base du développement Android et qu'il est basé sur la version 22.6.2 d'ADT car la version récente 23.0.2 d'ADT semble avoir des problèmes comme la création de dossier de disposition. Des détails sur ce problème peuvent être trouvés sous le lien suivant:

http://code.google.com/p/android/issues/detail?id=72591

Les étapes de ce guide seront données pour une machine de développement Windows 8.1, 64 bits , mais elles peuvent facilement être adaptées à d'autres plates-formes. Le nouveau système de construction Gradlesera utilisé pour les processus de construction / nettoyage et sa procédure d'installation sera également fournie. En outre, à la fois JDK 8et JDK 7doivent coexister sur la machine de développement. Les étapes ci-dessous doivent être suivies pour les installer:

• Accédez à la page de prévisualisation de l'accès anticipé JDK 8 http://jdk8.java.net
• Téléchargez JDK 8u20 et installez-le. L'installation de JRE 8 n'est pas nécessaire et peut être ignorée
• Accédez à la dernière version stable de JDK 7 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
• Téléchargez JDK 7u65 et installez-le. L'installation de JRE 7 n'est à nouveau pas nécessaire et peut être ignorée
• Ajoutez le dossier de base JDK 8 et le dossier JDK 8 binà votre %PATH%variable
• Créez une nouvelle variable d'environnement JAVA_HOMEavec la valeur du chemin du dossier de départ JDK 8
• Créez à nouveau une nouvelle variable d'environnement JAVA8_HOMEavec la valeur du chemin du dossier de base JDK 8
• Créez une nouvelle variable d'environnement JAVA7_HOMEavec la valeur du chemin du dossier de départ JDK 7
• Ouvrez une fenêtre de terminal et exécutez la java -versioncommande et vérifiez que Java 8 est opérationnel
• Exécutez la javac -versioncommande dans la même fenêtre et vérifiez que le compilateur Java JDK 8 est également opérationnel

Maintenant, ADT-22.6.2 doit être téléchargé à partir du lien suivant:

http://dl.google.com/android/adt/22.6.2/adt-bundle-windows-x86_64-20140321.zip

• Téléchargez ADT et décompressez son contenu dans un dossier, par exemple D:\adt
• Définissez une nouvelle variable d'environnement appelée ANDROID_HOMEavec la valeur du chemin de votre dossier d'installation ADT, par exempleD:\adt\sdk
• Ajoutez vos dossiers Andoid SDK Platform Toolset Andoid SDK Tools, par exemple D:\adt\sdk\toolset D:\adt\sdk\platform-tools, à votre %PATH%variable
• Créez un raccourci vers Eclipse IDE si vous le souhaitez. Il se trouve sous votre dossier d'installation ADT, par exempleD:\adt\eclipse
• Exécutez Eclipse IDE et créez un espace de travail, par exemple D:\adt\workspace
• Cliquez sur le Android SDK Managerbouton qui se trouve sur la barre d'outils
• Sélectionnez Android SDK Build tools Rev. 19.1et Android Support Libraryuniquement. Désélectionnez tout le reste et installez ces deux packages.

Si tout se passe bien, ADT sera opérationnel.

L'installation des outils suivants est également fortement recommandée:

• Prise en charge Eclipse Kepler Java 8: Cela permet à Eclipse de reconnaître les nouvelles extensions de syntaxe Java 8 et vous évite les ennuis red dotsdans votre éditeur de code Java. Il peut être installé via Help -> Install New SoftwareEclipse. Entrez http://download.eclipse.org/eclipse/updates/4.3-P-builds/ dans le Work withchamp et continuez à l'installer.

• Nodeclipse / Enide Gradle: Il est principalement utilisé pour mettre en évidence les mots clés du langage Groovy. Groovy est utilisé comme DSL pour les scripts de construction Gradle. Ce plugin peut être installé via Eclipse Marketplace. Cependant, Eclipse dans ADT-22.6.2 ne vient pas avec Eclipse Marketplace Client. Par conséquent, vous devrez d'abord installer Eclipse Marketplace Clientau moyen de l' Install New Softwareoutil dans Eclipse. Entrez http //: download.eclipse.org/mpc/kepler/ dans le Work withchamp et continuez à l'installer. Après l'installation Eclipse Marketplace Client, vous pouvez rechercher Nodeclipse/Enide Gradledans Eclipse Marketplace Clientet l'installer.

• Périphérique virtuel Genymotion: c'est un excellent remplacement de la valeur par défaut Android Virtual Devicefournie avec ADT. AVD est ennuyeusement encombrant et continue de se bloquer sans raison. Genymotion vous fait préparer des VD Android à l'aide d' CyanogenModimages exécutées par Oracle VirtualBox . Sa licence mono-utilisateur est gratuite et peut être téléchargée sur http://www.genymotion.com . Seule une connexion est requise et elle peut également être intégrée à Eclipse. Les détails peuvent être trouvés sous:

https://cloud.genymotion.com/page/doc/#collapse8

Ci-dessous, une capture d'écran d'un appareil virtuel CyanogenMod basé sur Android 4.3,

Il peut être considéré comme un appareil Android à part entière fonctionnant sur un ordinateur personnel x86 ou x64. Afin d'utiliser les services Google comme Google PlayStoresur cet appareil virtuel, une gappsimage de la version Android qu'il utilise doit être flashée sur l'appareil. Une gappsimage appropriée de l'appareil peut être téléchargée à partir du site Web de CyanogenMod:

http://wiki.cyanogenmod.org/w/Google_Apps

L'installation de Gradle est facultative car elle est également fournie par le SDK Android lui-même, mais son installation séparée est fortement recommandée. L'installation de celui-ci peut être effectuée en suivant ces étapes:

• Accédez au site Web de Gradle: http://www.gradle.org/

• Cliquez sur Downloads

• Sous Previous Releaseschoisissez la version 1.10 et téléchargez soit gradle-1.10-all.zip ou gradle-1.10-bin.zip
• Décompressez son contenu dans un dossier, par exemple D:\adt\gradle
• Définissez une nouvelle variable d'environnement appelée GRADLE_HOMEavec la valeur du chemin de votre dossier d'installation Gradle, par exempleD:\adt\gradle
• Ajoutez votre dossier binaires Gradle, par exemple D:\adt\gradle\bin, à votre %PATH%variable
• Ouvrez une fenêtre de terminal et exécutez la gradle -vcommande et vérifiez qu'elle est opérationnelle Si vous avez réussi à ce stade, cela signifie que vous êtes prêt à créer votre première application Android à l'aide des fonctionnalités de Java 8.

Application de démonstration

Une application simple sera créée pour démontrer l'utilisation des outils décrits dans la section précédente. Vous pouvez simplement suivre les étapes ci-dessous pour obtenir un aperçu de l'utilisation des expressions lambda dans les outils de développement Android:

• Exécutez Eclipse IDE et créez une nouvelle application Android en sélectionnant File -> New -> Other -> Android -> Android Application Project
• Remplissez le formulaire qui apparaît comme indiqué ci-dessous:

• Cliquez simplement sur le Nextbouton des formulaires suivants et cliquez sur le Finishbouton du dernier. Attendez que ADT termine le chargement du projet
• Faites un clic droit sur le projet et sélectionnez-le New -> Folderet nommez-lebuilders
• Faites un clic droit sur le gen (Generated Java Files)dossier et supprimez-le. Gradle va bientôt générer les mêmes fichiers pour nous et nous les ajouterons dans le s build path. Thedossier gen du projet créé par le constructeur Ant par défaut n'est plus nécessaire et les artefacts sous ce dossier seront obsolètes

• Créez les fichiers de commandes suivants sous le buildersdossier:

  • gradle_build.cmd
  • gradle_post_build.cmd
  • gradle_clean.cmd

• Remplissez ces fichiers batch comme suit:

gradle_build.cmd:

gradle_post_build.cmd:

gradle_clean.cmd:

• Désélectionner l' Project -> Build Automaticallyoption de menu
• Cliquez avec le bouton droit sur le projet et sélectionnez Properties -> Builderset désélectionnez tous les générateurs par défaut fournis par ADT
• Cliquez sur le Newbouton dans la même fenêtre et sélectionnez Programet cliquez surOK
• Une nouvelle fenêtre de configuration du générateur apparaîtra. Remplissez ses onglets comme suit:

Main Onglet de la nouvelle configuration Builder

Refresh Onglet de la nouvelle configuration Builder

Environment Onglet de la nouvelle configuration Builder

Build Options Onglet de la nouvelle configuration Builder

• Créez le deuxième générateur appelé Gradle_Post_Buildqui utilise gradle_post_build.cmdcomme programme. Tous les autres paramètres de ce générateur doivent être exactement les mêmes que ceux du générateur créé précédemment. Ce générateur sera chargé de copier les artefacts créés par le processus de génération dans le bindossier.
• Créez le troisième générateur appelé Gradle_Cleanerqui utilise gradle_clean.cmdcomme programme. Seul le Run the builderparamètre dans l'onglet final doit être défini comme During a Clean. Tous les autres paramètres de ce générateur doivent être exactement les mêmes que ceux du premier générateur. Ce constructeur sera responsable du nettoyage des artefacts créés par le processus de construction comme son nom l'indique.

Nouveaux constructeurs du HelloLambdaprojet

• Faites un clic droit sur le projet et sélectionnez Export
• Sélectionnez Android -> Generate Gradle Build Fileset cliquezNext
• Sélectionnez le projet dans la fenêtre suivante et cliquez sur Finish
• Accédez au dossier racine de votre projet et supprimez les fichiers gradlewet gradlew.bat. Supprimer également le gradledossier
• Revenez à Eclipse et sélectionnez l' Project -> Cleanoption de menu. Remplissez le formulaire qui apparaît comme suit:

Clean Project Fenêtre

• Cliquez OKet attendez la fin du processus de nettoyage
• Ajoutez l'extrait de code Java ci-dessous juste après l'appel à setContentViewfonctionner dans votre MainActivityclasse:

• Modifiez le début du build.gradlefichier jusqu'à la sourceCompatibilitysection comme suit:

• Cliquez avec le bouton droit sur le projet et sélectionnez l' Properties -> Java Compileroption et définissez tous les niveaux de conformité sur Java 8. Cela permettra à Eclipse de reconnaître les nouvelles constructions Java 8 comme les expressions lambda.
• Cliquez Nodans la fenêtre de notification
• Faites un clic droit sur le projet et sélectionnez Build project. Eclipse commencera à construire le projet.

Processus de construction

• Faites un clic droit sur le projet et allez à Properties -> Java Build Path. Ajoutez les dossiers suivants au chemin de génération (également illustré dans l'image ci-dessous):

  • build\source\buildConfig\debug
  • build\source\r\debug

Eclipse sera désormais en mesure de reconnaître R.javaet de buildConfig.javafichiers et il n'affichera aucun red dotsqui dénote des erreurs liées aux fichiers de ressources du projet.

• Créez un nouveau Run Configurationpour votre plate-forme cible Android en cliquant avec le bouton droit sur le projet, puis en le sélectionnant Run As -> Run Configurations. Par exemple, cette application de démonstration ressemble à celle illustrée ci-dessous sur le Genymotion VD:

Application HelloLambda

Vous pouvez observer dans la LogCatfenêtre que l'extrait de code avec une simple expression lambda fonctionne correctement

Source: Utilisation de Java 8 Lambda Expressions dans les outils de développement Android

Suivez ce lien pour les nouvelles mises à jour. Utiliser les fonctionnalités du langage Java 8

Ancienne réponse

Depuis la version d' aperçu d' Android N, Android prend en charge les fonctionnalités limitées de Java 8, voir Fonctionnalités du langage Java 8

Pour commencer à utiliser ces fonctionnalités, vous devez télécharger et configurer Android Studio 2.1 et le SDK Android N Preview, qui comprend la chaîne d'outils Jack requise et le plug-in Android mis à jour pour Gradle. Si vous ne l' avez pas encore installé le N Android SDK Preview, voir Set pour développer pour Android N .

Fonctionnalités et API du langage Java 8 prises en charge

Android ne prend actuellement pas en charge toutes les fonctionnalités du langage Java 8. Cependant, les fonctionnalités suivantes sont désormais disponibles lors du développement d'applications ciblant Android N Preview:

Méthodes d'interface par défaut et statique

Expressions lambda (également disponibles sur les API niveau 23 et inférieurs)

Annotations répétables

Références de méthode (également disponible au niveau API 23 et inférieur)

Il y a quelques fonctionnalités Java 8 supplémentaires prises en charge par Android, vous pouvez voir tous les détails dans Java 8 Language Features

Mise à jour

Remarque: Android N base son implémentation d'expressions lambda sur des classes anonymes. Cette approche leur permet d'être rétrocompatibles et exécutables sur les versions antérieures d'Android. Pour tester les expressions lambda sur les versions antérieures, n'oubliez pas d'aller dans votre fichier build.gradle et définissez compileSdkVersion et targetSdkVersion sur 23 ou moins.

Update 2

Désormais, la version stable d'Android studio 3.0 prend en charge les bibliothèques Java 8 et les fonctionnalités du langage Java 8 (sans le compilateur Jack).

Oui, Android prend en charge Java 8 maintenant (24.1.17)

Maintenant c'est possible

Mais vous devrez faire fonctionner votre appareil rom sur java 1.8 et activer "jackOptions" pour l'exécuter. Jack est le nom du nouveau compilateur Android qui exécute Java 8

https://developer.android.com/guide/platform/j8-jack.html

ajoutez ces lignes à build_gradle

    android {
  ...
  defaultConfig {
    ...
    jackOptions {
      enabled true
    }
  }
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

Java 8 semble être le moteur java en cours d'exécution d'Android studio 2.0, mais il n'accepte toujours pas la syntaxe de java 8 après vérification, et vous ne pouvez pas choisir un compilateur depuis Android studio maintenant. Cependant, vous pouvez utiliser le plugin scala si vous avez besoin d'un mécanisme de programmation fonctionnel dans votre client Android.

Android utilise un Java qui dérive de Java 6.

À partir de la version 19 du SDK Android, vous pouvez utiliser les fonctionnalités de Java 7 en procédant ainsi . Pas encore de support complet pour Java 8.

Java 8 natif arrive sur Android! Finalement!

supprimez le plugin Retrolambda et le bloc retrolambda du fichier build.gradle de chaque module:

Pour désactiver Jack et passer à la chaîne d'outils par défaut, supprimez simplement le bloc jackOptions du fichier build.gradle de votre module

Pour commencer à utiliser les fonctionnalités du langage Java 8 prises en charge, mettez à jour le plug-in Android vers 3.0.0 (ou supérieur)

À partir d'Android Studio 3.0, les fonctionnalités du langage Java 8 sont désormais prises en charge nativement par Android:

• Expressions lambda
• Références de méthode
• Type d'annotations (actuellement, les informations d'annotation de type ne sont pas disponibles au moment de l'exécution mais uniquement au moment de la compilation);
• Répéter les annotations
• Méthodes d'interface par défaut et statiques (au niveau de l'API 24 ou supérieur, pas de support d'exécution instantané);

Également à partir du niveau minimal de l'API 24, les API Java 8 suivantes sont disponibles:

• java.util.stream
• java.util.function
• java.lang.FunctionalInterface
• java.lang.annotation.Repeatable
• java.lang.reflect.AnnotatedElement.getAnnotationsByType (Class)
• java.lang.reflect.Method.isDefault ()

Ajoutez ces lignes au build.gradle de votre module d'application pour informer le projet du niveau de langue:

 android {
   compileOptions {
       sourceCompatibility JavaVersion.VERSION_1_8
       targetCompatibility JavaVersion.VERSION_1_8
   }

Désactivez la prise en charge des fonctionnalités du langage Java 8 en ajoutant les éléments suivants à votre fichier gradle.properties :

android.enableDesugar=false

Vous avez terminé! Vous pouvez maintenant utiliser Java8 natif!

Android prend en charge OFFICIELLEMENT Java 8 à partir d'Android N.

Les annonces de fonctionnalités sont ici , l'annonce du langage Java 8 est:

Prise en charge améliorée du langage Java 8 - Nous sommes ravis d'apporter des fonctionnalités du langage Java 8 à Android. Avec le compilateur Jack d'Android, vous pouvez désormais utiliser de nombreuses fonctionnalités populaires du langage Java 8, y compris les lambdas et plus, sur les versions d'Android depuis Gingerbread. Les nouvelles fonctionnalités aident à réduire le code passe-partout. Par exemple, lambdas peut remplacer des classes internes anonymes lors de la fourniture d'écouteurs d'événements. Certaines fonctionnalités du langage Java 8, telles que les méthodes par défaut et statiques, les flux et les interfaces fonctionnelles, sont désormais disponibles sur N et au-dessus. Avec Jack, nous sommes impatients de suivre le langage Java de plus près tout en conservant la compatibilité descendante.

Nous pouvons utiliser Java 8 en utilisant:

1. Dans build.gradle (Project: myProject), ajoutez ce qui suit

   classpath 'me.tatarka:gradle-retrolambda:x.x.x' //x.x.x is recent version

2. Dans build.gradle (Module: myModule), ajoutez ce qui suit

   apply plugin: 'me.tatarka.retrolambda'
   
   compileOptions {
       sourceCompatibility JavaVersion.VERSION_1_8
       targetCompatibility JavaVersion.VERSION_1_8
   }

MISE À JOUR 2020/01/17

Android Studio 4.0 prend en charge l'utilisation d'un certain nombre d'API en langage Java 8, en utilisant une technique appelée désuchage, sans exiger un niveau d'API minimum pour votre application:
https://developer.android.com/studio/preview/features#j8-desugar

L'ensemble d'API suivant est pris en charge dans cette version:

• Flux séquentiels ( java.util.stream)
• Un sous-ensemble de java.time
• java.util.function
• Ajouts récents à java.util.{Map,Collection,Comparator}
• Optionnels ( java.util.Optional, java.util.OptionalIntet java.util.OptionalDouble) et quelques autres nouvelles classes utiles avec les API ci-dessus
• Quelques ajouts à java.util.concurrent.atomic(nouvelles méthodes sur AtomicInteger, AtomicLonget AtomicReference)
• ConcurrentHashMap (avec des corrections de bugs pour Android 5.0)

Pour prendre en charge ces API de langage, D8 compile un fichier DEX de bibliothèque distinct qui contient une implémentation des API manquantes et l'inclut dans votre application. Le processus de désucréfaction réécrit le code de votre application pour utiliser à la place cette bibliothèque au moment de l'exécution.

Pour activer la prise en charge de ces API de langue, incluez les éléments suivants dans le build.gradlefichier de votre module :

android {
  defaultConfig {
    // Required when setting minSdkVersion to 20 or lower
    multiDexEnabled true
  }

  compileOptions {
    // Flag to enable support for the new language APIs
    coreLibraryDesugaringEnabled true
    // Sets Java compatibility to Java 8
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

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

POSTE ORIGINAL DE 2017

Android Studio 3.0 a commencé à fournir une prise en charge intégrée de certaines fonctionnalités du langage Java 8, à savoir:

• Expressions lambda
• Références de méthode
• Type d'annotations (les informations sont disponibles au moment de la compilation, mais pas au moment de l'exécution)
• Répéter les annotations
• Méthodes d'interface par défaut et statique

À partir du niveau 24 de l'API, les API Java 8 suivantes sont également disponibles:

• java.util.stream
• java.util.function
• java.lang.FunctionalInterface
• java.lang.annotation.Repeatable
• java.lang.reflect.AnnotatedElement.getAnnotationsByType(Class)
• java.lang.reflect.Method.isDefault()

En plus de cela, le try-with-resourcessupport a été étendu à tous les niveaux d'API Android.

D'autres fonctionnalités de Java 8 devraient être ajoutées à l'avenir.

Pour commencer à utiliser les fonctionnalités du langage Java 8 prises en charge, mettez à jour le plug-in Android vers 3.0.0-alpha1 (ou supérieur) et ajoutez ce qui suit au fichier build.gradle de votre module:

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

Pour plus de détails, visitez:
https://developer.android.com/studio/write/java8-support.html

Moyen facile

Vous pouvez activer la prise en charge de Java 1.8 pour le projet Android.

• Ouvrir la structure du projet

  • Soit en appuyant sur Ctrl + Shift + Alt + S

  • Ou File > Project Structure

• Mettez à jour la compatibilité source et la compatibilité cible vers 1.8 dans la boîte de dialogue Structure du projet, comme indiqué (cliquez sur Fichier> Structure du projet).

Ou vous pouvez utiliser gradle

 android {
   compileOptions {
       sourceCompatibility JavaVersion.VERSION_1_8
       targetCompatibility JavaVersion.VERSION_1_8
   }

Projet de synchronisation. Et c'est tout!

Remarque: la prise en charge de Java 1.8 peut être activée pour Android Studio 3.0.0 ou supérieur. Voir la documentation pour plus de lecture.

Lorsque j'ai posé cette question il y a près de 2 ans, la réponse était vraiment «officiellement» non, mais comme le souligne la réponse d'ekcr1, vous pouvez obtenir l'une des fonctionnalités les plus attendues (lambdas) si vous utilisez retrolamba. À l'époque, j'utilisais encore eclipse, car Android Studio était en mode «aperçu», donc je n'ai jamais poursuivi cette voie.

Aujourd'hui, je pense que la réponse «officielle» est toujours non, et bien que la retrolamba semble toujours être une bonne voie à suivre, il existe une autre option pour ceux qui souhaitent emprunter une voie quelque peu «non officielle», à savoir Kotlin.

Aujourd'hui, Kotlin a atteint 1.0.0. Pour ceux qui ne connaissent pas Kotlin, plus d'informations peuvent être trouvées sur leur site Web ici:

https://kotlinlang.org

ou regardez cette vidéo utube d'une conférence donnée par Jake Wharton

https://www.youtube.com/watch?v=A2LukgT2mKc

Dernières nouvelles:

Google annonce qu'avec Android N et Android Studio 2.1+, la plate-forme prendra en charge Java 8. Une version stable de studio 2.1 a également été publiée.

Enfin, nous pouvons utiliser des expressions lambda. Plus de filtre de liste dans la boucle. Horeeey.

Ajoutez cette config build.gradle et synchronisez gradle:

android {
    ...
    defaultConfig {
        ...
        jackOptions {
            enabled true
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
        // or
        //sourceCompatibility 1.8
        //targetCompatibility 1.8
    }
}

Google vient d'annoncer que Java 8 sera pris en charge nativement par Android et que la chaîne d'outils Jack sera obsolète:

Nous avons décidé d'ajouter la prise en charge des fonctionnalités du langage Java 8 directement dans l'ensemble d'outils javac et dx actuel, et de déconseiller la chaîne d'outils Jack. Avec cette nouvelle orientation, les outils et plugins existants qui dépendent du format de fichier de classe Java devraient continuer à fonctionner. À l'avenir, les fonctionnalités du langage Java 8 seront prises en charge nativement par le système de génération Android. Nous avons l'intention de le lancer dans le cadre d'Android Studio dans les semaines à venir, et nous voulions partager cette décision dès que possible avec vous.

Plus d'informations ici: https://android-developers.googleblog.com/2017/03/future-of-java-8-language-feature.html

Oui. Nous utiliserons bientôt Java 8!

Nous avons décidé d'ajouter la prise en charge des fonctionnalités du langage Java 8 directement dans l'ensemble d'outils javac et dx actuel, et de déconseiller la chaîne d'outils Jack. Avec cette nouvelle orientation, les outils et plugins existants qui dépendent du format de fichier de classe Java devraient continuer à fonctionner. À l'avenir, les fonctionnalités du langage Java 8 seront prises en charge nativement par le système de génération Android. Nous avons l'intention de le lancer dans le cadre d'Android Studio dans les semaines à venir, et nous voulions partager cette décision dès que possible avec vous.

https://android-developers.googleblog.com/2017/03/future-of-java-8-language-feature.html

ajouter cette ligne dans le module lvl build gradel

compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

J'ai écrit une réponse similaire à une question similaire sur Stack Overflow, mais voici une partie de cette réponse.

Android Studio 2.1:

La nouvelle version d'Android Studio (2.1) prend en charge les fonctionnalités Java 8. Voici un extrait du billet blogspot des développeurs Android :

... La version Android Studio 2.1 inclut la prise en charge de la nouvelle compilateur Jack et la prise en charge de Java 8 .

...

Pour utiliser les fonctionnalités du langage Java 8 lors du développement avec N Developer Preview, vous devez utiliser le compilateur Jack. L'assistant Nouveau projet [Fichier → Nouveau → Projet] génère les configurations correctes pour les projets ciblant le N.

Avant Android Studio 2.1:

Android ne prend pas encore en charge Java 1.8 (il ne prend en charge que jusqu'à 1.7), vous ne pouvez donc pas utiliser les fonctionnalités Java 8 comme lambdas.

Cette réponse donne plus de détails sur la compatibilité d'Android Studio ; il est dit:

Si vous souhaitez utiliser lambdas, l'une des principales fonctionnalités de Java 8 dans Android, vous pouvez utiliser gradle-retrolamba

Si vous voulez en savoir plus sur l'utilisation gradle-retrolambda, cette réponse donne beaucoup de détails à ce sujet .

J'ai pensé que je publierais une réponse mise à jour pour ceux qui recherchent quelque chose d'un peu plus actuel.

Actuellement, Android et Android Studio prennent en charge un sous-ensemble de fonctionnalités Java 8. Selon la documentation Android située sur leur site Web , Google dit:

La prise en charge des fonctionnalités du langage Java 8 nécessite un nouveau compilateur appelé Jack. Jack n'est pris en charge que sur Android Studio 2.1 et supérieur. Donc, si vous souhaitez utiliser les fonctionnalités du langage Java 8, vous devez utiliser Android Studio 2.1 pour créer votre application.

Si vous avez déjà installé Android Studio, assurez-vous de mettre à jour vers la dernière version en cliquant sur Aide> Rechercher les mises à jour (sur Mac, Android Studio> Rechercher les mises à jour). Si l'IDE n'est pas déjà installé sur votre poste de travail, téléchargez Android Studio ici.

Fonctionnalités et API du langage Java 8 prises en charge

Android ne prend pas en charge toutes les fonctionnalités du langage Java 8. Cependant, les fonctionnalités suivantes sont disponibles lors du développement d'applications ciblant Android 7.0 (API niveau 24):

• Méthodes d'interface par défaut et statiques Expressions Lambda (également disponibles sur les API niveau 23 et inférieurs)
• Annotations répétables
• Références de méthode (également disponible au niveau API 23 et inférieur)
• Annotations de type (également disponibles au niveau API 23 et inférieur)

De plus, les API de langage Java 8 suivantes sont également disponibles:

API de réflexion et de langage:

• java.lang.FunctionalInterface
• java.lang.annotation.Repeatable
• java.lang.reflect.Method.isDefault () et les API de réflexion associées aux annotations répétables, telles que AnnotatedElement.getAnnotationsByType (Class)

API utilitaires:

• java.util.function
• java.util.stream

Pour utiliser les nouvelles fonctionnalités du langage Java 8, vous devez également utiliser la chaîne d'outils Jack . Cette nouvelle chaîne d'outils Android compile les sources du langage Java en bytecode DEX lisible par Android, a son propre format de bibliothèque .jack et fournit la plupart des fonctionnalités de la chaîne d'outils dans le cadre d'un seul outil: reconditionnement, rétrécissement, obscurcissement et multidex.

Voici une comparaison des deux chaînes d'outils utilisées pour créer des fichiers Android DEX:

Legacy javac toolchain:
    javac (.java → .class) → dx (.class → .dex)
    New Jack toolchain:
    Jack (.java → .jack → .dex)

J'ai posé cette question il y a plus de 3 ans et, évidemment, les réponses ont changé au fil des ans. Comme beaucoup ci-dessus ont déjà répondu, il y a quelque temps, la réponse est devenue Oui . Je n'ai jamais mis à jour la réponse acceptée car c'était la bonne réponse à l'époque. (Je ne sais pas quelle est la politique de débordement de pile à ce sujet)

Je voulais juste ajouter une autre réponse pour ceux qui recherchent toujours ce sujet. Au 17/05/2017, Google a également annoncé que Kotlin est également une langue officielle pour le développement Android.

Je n'ai pas trouvé de communiqué de presse officiel, mais j'ai regardé certaines des vidéos d' E / S Google là où elles ont été annoncées. Voici un lien vers un blog post par l'équipe Kotlin sur l'annonce.

L'ajout de ce qui suit a résolu le problème pour moi (Android studio 2.3.2):

build.gradle (Projet)

buildscript {
repositories {
    ...
    jcenter()
}
dependencies {
    ...
    classpath 'me.tatarka:gradle-retrolambda:3.4.0' // DEPENDENCY
    ...
   }
}

build.gradle (Module: application)

apply plugin: 'com.android.application'
apply plugin: 'me.tatarka.retrolambda' //PLUGIN

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    } // SET JAVA VERSION
    ...
}

Un sous-ensemble de Java 8 est désormais pris en charge sur Android Studio. Effectuez simplement les réglages de compatibilité source et cible dans la fenêtre ci-dessous:

Fichier -> Structure du projet

Plus d'informations sont fournies dans le lien ci-dessous.

https://developer.android.com/studio/write/java8-support.html

MISE À JOUR 2019/10/28

Android Studio 4.0 résout ce problème .

Le compilateur D8 corrige un backport des API natives Java 8 dans votre APK au moment de la compilation et votre application utilisera ce code, au lieu des API natives, lors de l'exécution. Le processus est appelé désucré .

Toutes les solutions ci-dessus ne semblent pas fonctionner en 2019 avec la dernière version d' Android Studio 3.4+ .

J'ai trouvé une solution parfaite et à jour pour migrer ou mettre à niveau votre projet Android vers Java 8 .

Solution: Cliquez sur Fichier -> Structure du projet -> Modules -> onglet Propriétés .

Changez la compatibilité source et la compatibilité cible en 1.8 (Java 8)

Oui, vous pouvez utiliser les fonctionnalités du langage Java 8 dans Android Studio, mais la version doit être 3.0 ou supérieure. Lisez cet article pour savoir comment utiliser les fonctionnalités de java 8 dans le studio Android.

https://bijay-budhathoki.blogspot.com/2020/01/use-java-8-language-features-in-android-studio.html

Moyen le plus simple d'ajouter la prise en charge de Java 8

 compileOptions {
    targetCompatibility = '1.8'
    sourceCompatibility = '1.8'
 }

Ajoutez-le simplement dans votre fichier build.gradle.