MISE À JOUR 2017/11/04 - Android Studio 3.0 a maintenant un support natif pour Java 8. gradle-retrolambda n'est plus nécessaire. Voir https://developer.android.com/studio/write/java8-support.html

Le lien ci-dessus inclut é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 n'a toujours pas invokedynamic, seulement la nouvelle syntaxe sugar.

Si vous vous voulez utiliser lambdas, l'une des principales fonctionnalités de Java 8 dans Android, vous pouvez utiliser gradle-retrolamba. C'est une dépendance gradle build qui intègre retrolambda, un outil qui convertit le bytecode Java 8 en Java 6/7. Fondamentalement, si vous définissez le compilateur dans Android Studio pour compiler le bytecode Java 8, autorisant ainsi les lambdas, il le convertira en bytecode Java 6/7 qui sera ensuite converti en bytecode dalvik. C'est un hack pour si vous voulez essayer quelques fonctionnalités JDK 8 dans Android en lieu et place d'un soutien officiel.

Vous pouvez en effet utiliser gradle-retrolamba gradle build dependency pour utiliser Java 8 pour le développement Android.

Voici 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 seront démontrés, visant spécifiquement à Eclipse ID . Toutefois, des mesures ce qui sera décrit tout au long de ce guide pourrait également être adapté au nouveau développement uprising de Google environnement, Android Studio. Il est basé sur l'édition communautaire de idée IntelliJ populaire Idea par JetBrains et il a récemment été mise à niveau vers sa version "bêta" par Google début juillet 2014, légèrement avant que ce guide ne soit écrit. Eclipse restera comme le proéminent environnement de développement, au moins pendant un certain temps, et compte tenu de la fait que la plupart des projets Android ont été développé en utilisant Eclipse, un méthode pour apporter 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 Projet Apache Harmony qui a pris fin en 2011. La plupart des la syntaxe Java 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, Java 8 dispose de fonctionnalités telles que lambda expression ne peut pas être utilisé directement dans le développement d'applications Android sans appliquer quelques ajustements dans les outils de développement. Heureusement, ces les constructions sont essentiellement des améliorations de "sucre syntaxique" qui donnez aux développeurs les lacunes de choses comme les "classes anonymes" et ils peuvent être traduits en classes Java 6 ou Java 7.

Une approche récente pour traduire un code source Java 8 en Java inférieur les versions sont appelées RetroLambda . Cette bibliothèque fait les développeurs exécutent Code Java 8 avec des expressions lambda sur Java 7 ou même inférieur. Malheureusement, les fonctionnalités Java 8 autres que les expressions lambda ne le sont pas soutenu 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 de cette bibliothèque peuvent être trouvés sur sa page GitHub:

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

Aussi, un plugin Gradle pour RetroLambda créé par un autre développeur permet d'implémenter des builds basés sur Gradle en Java ou Android Projet. Cependant, le développeur ne mentionne que l'intégration de cela plugin dans l'environnement Android Studio. Les détails peuvent être trouvés sur son GitHub page:

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

Utilisation de ces infrastructures dans un développement basé sur Eclipse l'environnement ne peut pas être abordé directement mais c'est faisable et sera démontré 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 il est basé sur la version 22.6.2 d'ADT car la version 23.0.2 récente d'ADT semble avoir des problèmes comme la création de dossiers de mise en page. Les détails sur ce problème peuvent être trouvés sous ce qui suit lien:

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

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

• Accédez à la page d'aperçu 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 page de la 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
• Ajouter JDK 8 dossier d'accueil et dossier JDK 8 bin à votre variable %PATH%
• Créer une nouvelle variable d'environnement JAVA_HOME avec la valeur du chemin du dossier d'accueil JDK 8
• Créer une nouvelle variable d'environnement JAVA8_HOME à nouveau avec la valeur du chemin du dossier d'accueil JDK 8
• Créer une nouvelle variable d'environnement JAVA7_HOME avec la valeur du chemin du dossier d'accueil JDK 7
• Ouvrez une fenêtre de terminal et exécutez la commande java -version et vérifiez que Java 8 est opérationnel
• Exécuter javac -version commande 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 {[12] } avec la valeur du chemin d'accès de votre dossier d'installation ADT, par exemple D:\adt\sdk
• Ajouter votre Andoid SDK Platform Tools et Andoid SDK Tools dossiers, par exemple D:\adt\sdk\tools et D:\adt\sdk\platform-tools, à votre %PATH% variable
• Créez un raccourci vers Eclipse ID si vous le souhaitez. Il se trouve sous votre dossier d'installation ADT, par exemple D:\adt\eclipse
• Exécutez Eclipse ID et créez un espace de travail, par exemple D:\adt\workspace
• Cliquez sur le bouton Android SDK Manager qui se trouve sur la barre d'outils
• Sélectionnez Android SDK Build tools Rev. 19.1 et Android Support Library uniquement. Décochez tout le reste et installez ces deux paquets.

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

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

• Eclipse Kepler Java 8 Support: Il permet à Eclipse de reconnaître les nouvelles extensions de syntaxe Java 8 et vous permet de vous débarrasser des red dots ennuyeux dans votre éditeur de code Java. Il peut être installé via Help -> Install New Software dans Eclipse. Entrez http://download.eclipse.org/eclipse/updates/4.3-P-builds / dans le champ Work with et continuer à l'installer.

• Nodeclipse / Enide Gradle: Il est principalement utilisé pour mettre en évidence les mots clés Groovy langue. 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 Client par Install New Software outil dans Eclipse. Entrez http//: download.eclipse.org/ mpc / kepler / dans le champ Work with et continuez à l'installer. Après avoir installé Eclipse Marketplace Client, vous peut-recherche de Nodeclipse/Enide Gradle dans le Eclipse Marketplace Client et l'installer.

• Genymotion Virtual Device: C'est un excellent remplacement de la valeur par défaut Android Virtual Device qui vient avec ADT. AVD est agaçant et il continue de s'écraser sans raison. Genymotion vous fait préparer des VD Android en utilisant CyanogenModimages qui sont exécutées par Oracle VirtualBox. Sa licence utilisateur unique est gratuite et peut être téléchargée à partir de http://www.genymotion.com. Seul un login est nécessaire et il peut également être intégré dans Eclipse. Les détails peuvent être trouvés sous:

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

Ci-dessous est une capture d'écran d'un périphérique virtuel CyanogenMod basé sur Android 4.3,

Il pourrait être considéré comme un appareil Android entièrement naissant fonctionnant sur un ordinateur personnel x86 ou x64. Afin d'utiliser les services Google comme Google PlayStore sur ce périphérique virtuel, une image gapps pour le La version Android qu'il utilise doit être flashée sur l'appareil. Une image appropriée pour 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 Android SDK 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:

• Aller sur le site de Gradle: http://www.gradle.org/

• Cliquez sur Downloads

• Sous Previous Releases choisissez la version 1.10 et téléchargez 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_HOME avec la valeur du chemin de votre dossier d'installation Gradle, par exemple D:\adt\gradle
• Ajoutez votre dossier Gradle binaries, par exemple D:\adt\gradle\bin , à votre variable %PATH%
• Ouvrir un fenêtre du terminal et exécutez la commande gradle -v et vérifiez qu'elle est opérationnelle Si vous êtes arrivé à ce point avec succès, cela signifie que vous êtes prêt à créer votre première application Android en utilisant les fonctionnalités 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 Android Developer Outils:

• Exécutez Eclipse ID et créez une nouvelle application Android en sélectionnant File -> New -> Other -> Android -> Android Application Project
• Remplissez le formulaire ci-dessous:

• Cliquez simplement sur le bouton Next sur les formulaires suivants et cliquez sur le bouton Finish sur le dernier. Attendez qu'ADT termine le chargement du projet
• cliquez-Droit sur le projet et sélectionnez New -> Folder et nommez - builders
• Faites un clic droit sur le dossier gen (Generated Java Files) et supprimez-le. Gradle générera bientôt les mêmes fichiers pour nous et nous les ajouterons dans le projet s build path. Thele dossier gen ' 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 batch suivants dans le dossier builders:

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

• Remplissez ces fichiers batch comme voici ce qui suit:

Gradle_build.cmd:

Gradle_post_build.cmd:

Gradle_clean.cmd:

• Désélectionner Project -> Build Automatically option de menu
• Faites un clic droit sur le projet et sélectionnez Properties -> Builders et désélectionnez tous les constructeurs par défaut fournis par ADT
• Cliquez sur le bouton New dans la même fenêtre et sélectionnez Program et cliquez sur OK
• Une nouvelle fenêtre de configuration du constructeur apparaît. Remplissez ses onglets comme suit:

Main Onglet de la nouvelle configuration du générateur

Refresh Onglet de la nouvelle configuration du générateur

Environment Onglet de la nouvelle configuration du générateur

Build Options Onglet du nouveau constructeur Configuration

• Créez le deuxième générateur appelé Gradle_Post_Build qui utilise gradle_post_build.cmd comme programme. Tous les autres paramètres de ce générateur doivent être exactement les mêmes avec le générateur précédemment créé. Ce générateur sera responsable de la copie des artefacts créés par le processus de construction dans le dossier bin.
• Créez le troisième constructeur appelé Gradle_Cleaner qui utilise gradle_clean.cmd comme programme. Seulement Run the builder paramètre dans l'onglet final doit être défini comme During a Clean. Tout les autres paramètres de ce générateur doivent être exactement les mêmes avec le 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 Bâtisseurs de la HelloLambda Projet

• Faites un clic droit sur le projet et sélectionnez Export
• Sélectionnez Android -> Generate Gradle Build Files et cliquez sur Next
• Sélectionnez le projet dans la fenêtre suivante et cliquez sur Finish
• Allez à votre dossier racine du projet et de supprimer les fichiers gradlew et gradlew.bat. Supprimer également gradle dossier
• Revenez à Eclipse et sélectionnez l'option de menu Project -> Clean. Remplissez le formulaire qui apparaît comme suit:

Clean Project Fenêtre

• Cliquez sur OK et attendez la fin du processus de nettoyage
• Ajoutez l'extrait de code Java donné ci-dessous juste après l'appel à la fonction setContentView dans votre MainActivity classe:

• Changez le début du fichier build.gradle jusqu'à la section sourceCompatibility comme suit:

• Faites un clic droit sur le projet et sélectionnez l'option Properties -> Java Compiler 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.
• Sur No dans la fenêtre de notification
• Faites un clic droit sur le projet et sélectionnez Build project. Eclipse va commencer la construction du projet.

Processus De Construction

• Faites un clic droit sur le projet et accédez à Properties -> Java Build Path. Ajoutez les dossiers suivants au chemin de construction (également montré dans l'image ci-dessous):

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

Eclipse sera désormais capable de reconnaître les fichiers R.java et buildConfig.java et il n'affichera aucun {[24] } qui dénote des erreurs liées aux fichiers de ressources du projet.

• Créez un nouveau Run Configuration pour votre plate-forme cible Android en cliquant avec le bouton droit sur le projet, puis en sélectionnant Run As -> Run Configurations. Par exemple, cette application de démonstration ressemble à ce qui suit sur le VD Genymotion:

La demande de HelloLambda

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

Source: À L'Aide 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

Vieille Réponse

Comme de Android N aperçu communiqué de soutien Android limité fonctions de Java 8 voir Java 8 Fonctionnalités de Langage

Pour commencer à utiliser ces fonctionnalités, vous devez télécharger et configurer Android Studio 2.1 {[2] } et le SDK Android N Preview, qui comprend requis Jack chaîne d'outils et mis à jour Plugin Android pour Gradle. Si vous vous n'avez pas encore installé le SDK Android N Preview, voir Configurer 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 ciblage de l'aperçu Android N:

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

Lambda expressions (également disponible au niveau API 23 et inférieur)

Annotations reproductibles

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

Il existe des fonctionnalités Java 8 supplémentaires qui prennent en charge Android, vous pouvez voir les détails complets de Java 8 Language Features

Mise à Jour

Remarque: L'Android N base son implémentation des expressions lambda sur anonyme classes. Cette approche leur permet à l'arrière compatible et exécutable sur les versions antérieures d'Android. Tester expressions lambda sur les versions antérieures, n'oubliez pas d'aller à votre construire.fichier gradle, et définissez compileSdkVersion et targetSdkVersion sur 23 ou moins.

Mise à Jour 2

Maintenant Android studio 3.0 support de la version stableBibliothèques Java 8 et fonctionnalités du langage Java 8 (sans le compilateur Jack).

Android utilise un Java qui se branche sur Java 6.

À partir de la version Android SDK 19, vous pouvez utiliser les fonctionnalités Java 7 en faisant ceci. Pas de prise en charge complète de Java 8 (encore).

Oui, Android Prend en Charge Java 8 maintenant (24.1.17)

Maintenant c'est possible

Mais vous devrez faire fonctionner la ROM de votre appareil 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

Ajouter 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 elle ne peut toujours pas accepter le syntaxe de java 8 après avoir vérifié, et vous ne pouvez pas choisir un compilateur d'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 prend officiellement en charge 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 de langage Java 8 à Android. Avec le compilateur Jack d'Android, vous pouvez utilisez maintenant de nombreuses fonctionnalités populaires du langage Java 8, y compris les lambdas et plus, sur les versions Android aussi loin que Gingerbread. Nouveauté aide à réduire le code standard. Pour exemple, lambdas peut remplacer classes internes anonymes lors de la fourniture d'auditeurs d'événements. Certains Java 8 fonctionnalités de langue - comme les méthodes par défaut et statiques, les flux et les interfaces fonctionnelles -- sont également disponibles sur N et au-dessus. Avec Jack, nous sommes impatients de suivre le langage Java de plus près tout en maintenant la compatibilité ascendante.

Java natif 8 arrive sur Android! Enfin!

Supprimez le plugin Retrolambda et le bloc retrolambda de chaque module construire.fichier gradle:

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

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

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

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

Également à partir du niveau d'API min 24, les API Java 8 suivantes sont disponible:

• java.util.flux
• java.util.fonction
• java.lang.FunctionalInterface
• java.lang.annotation.Reproductible
• java.lang.refléter.AnnotatedElement.getAnnotationsByType(Classe)
• java.lang.refléter.Méthode.isDefault()

Ajoutez ces lignes à la construction de votre module d'application.gradle 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 ce qui suit à votre gradle.propriétés fichier:

android.enableDesugar=false

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

Nous Pouvons Utiliser Java 8 en utilisant:

1. Dans la construction.gradle (Projet: MyProject) ajouter suivant

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

2. Dans la construction.gradle (Module: myModule) ajouter ce qui suit

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

Android Studio 3.0 a commencé à fournir un support intégré pour certaines des fonctionnalités du langage Java 8, qui sont:

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

Également à partir du niveau d'API 24, les API Java 8 suivantes sont disponible:

• 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 support try-with-resources a été étendu à tous les niveaux d'API Android.

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

Pour commencer à utiliser les fonctionnalités de langage Java 8 prises en charge, mettez à jour Android plugin à 3.0.0-alpha1 (ou supérieur) et ajouter ce qui suit à votre construction du module.gradle fichier:

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

Quand j'ai posé cette question il y a presque 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 retrolamba semble toujours être une bonne voie à suivre, il y a une autre option pour ceux prêt à descendre un itinéraire quelque peu "non officiel" peut prendre, à 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 trouvé 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. La version stable de studio 2.1 a également été publiée.

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

Ajoutez cette construction de configuration.gradle et de synchronisation 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éprécier la chaîne d'outils Jack. Avec cette nouvelle direction, les outils et plugins existants dépendant 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 construction Android. Nous visons à lancer cela dans le cadre d'Android Studio dans les semaines à venir, et nous voulions partager cette décision tôt avec vous.

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

Oui. Nous utiliserons Java 8 bientôt!

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éprécier la chaîne d'outils Jack. Avec cette nouvelle direction, les outils et plugins existants dépendant 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 construction Android. Nous visons à lancer cela dans le cadre d'Android Studio dans les prochaines semaines, et nous je voulais partager cette décision tôt avec vous.

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

, j'ai écrit un similaires réponse pour un question similaire sur Stack Overflow, mais voici la première partie de cette réponse.

Android Studio 2.1:

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

... La version Android Studio 2.1 inclut la prise en charge du nouveau Jack compiler et la prise en charge de Java 8.

...

À utiliser Fonctionnalités du langage Java 8 lors du développement avec l'aperçu du développeur N, 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 les lambdas.

Cette réponse donne plus de détails sur la compatibilité d'Android Studio ; it états:

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

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

J'ai pensé que je posterais une réponse mise à jour pour ceux qui cherchent 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 est pris en charge uniquement sur Android Studio 2.1 et supérieur. Donc, si vous souhaitez utiliser les fonctionnalités du langage Java 8, vous devez utilisez Android Studio 2.1 pour créer votre application.

Si Android Studio est déjà installé, assurez-vous de mettre à jour la dernière version en cliquant sur Aide > Rechercher la mise à jour (sur Mac, Android Studio > Rechercher les mises à jour). Si l'EDI 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 caractéristiques suivantes sont disponibles lors du développement d'applications ciblant Android 7.0 (niveau API 24):

• Méthodes d'interface par défaut et statiques Expressions Lambda (également disponibles au niveau API 23 et inférieur)
• Annotations reproductibles
• Références de méthode (également disponibles au niveau API 23 et inférieur)
• Annotations de type (également disponibles au niveau API 23 et inférieur)

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

Api de réflexion et de langage:

• java.lang.FunctionalInterface
• java.lang.annotation.Reproductible
• java.lang.refléter.Méthode.isDefault () et les API Reflection associées à des annotations reproductibles, telles que AnnotatedElement.getAnnotationsByType (Classe)

Api utilitaires:

• java.util.fonction
• java.util.flux

Pour utiliser les nouvelles fonctionnalités du langage Java 8, vous devez utilisez également 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 le sien .jack library format, et fournit la plupart des fonctionnalités de 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 construire 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, à partir de quelque temps en arrière, 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 suis pas sûr de la stratégie de débordement de pile)

Je voulais juste ajouter une autre réponse pour ceux qui recherchent encore ce sujet. À partir du 17/5/2017 Google a également annoncé que Kotlin est aussi un 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 Google I/O où il a été annoncé. Voici un lien vers un blog post de 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):

Construire.gradle (Projet)

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

Construire.gradle (Module: app)

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 maintenant pris en charge sur Android Studio. Effectuez simplement les ajustements de compatibilité Source et Cible à partir de la fenêtre ci-dessous:

Fichier > > Structure du projet

Plus d'informations sont données dans le lien ci-dessous.

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

Moyen le plus 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 + Maj + Alt + S

  • Ou File > Project Structure

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

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