Beim Durchsuchen des Webs ist nicht klar, ob Java 8 für die Android-Entwicklung unterstützt wird oder nicht.

Bevor ich Java 8 herunterlade / einrichte, kann mich jemand auf eine "offizielle" Dokumentation verweisen, die besagt, dass Java 8 für die Android-Entwicklung unterstützt wird oder nicht.

Java 8

Android unterstützt alle Java 7-Sprachfunktionen und eine Teilmenge der Java 8-Sprachfunktionen, die je nach Plattformversion variieren.

Um zu überprüfen, welche Funktionen von Java 8 unterstützt werden

Verwenden Sie Java 8-Sprachfunktionen

Wir haben uns entschlossen, die Unterstützung für Java 8-Sprachfunktionen direkt in die aktuellen Javac- und DX-Tools aufzunehmen und die Jack-Toolchain zu verwerfen. Mit dieser neuen Richtung sollten vorhandene Tools und Plugins, die vom Dateiformat der Java-Klasse abhängen, weiterhin funktionieren. In Zukunft werden Java 8-Sprachfunktionen vom Android-Build-System nativ unterstützt. Wir beabsichtigen, dies in den kommenden Wochen als Teil von Android Studio zu starten, und wir wollten diese Entscheidung frühzeitig mit Ihnen teilen.

Zukunft der Unterstützung von Java 8-Sprachfunktionen unter Android

Eclipse-Benutzer:

Für alte Entwickler, die Eclipse bevorzugen, unterstützt Google die Unterstützung von Eclipse Android Developer Tools

Wenn Sie Java 8 JDK installiert haben, probieren Sie es aus. Wenn Probleme auftreten, versuchen Sie, den Compiler in Eclipse über das Fenstermenü → Einstellungen → Java → Compiler auf 1.6 festzulegen . Java 7 funktioniert auch:

Java 7 oder höher ist erforderlich, wenn Sie auf Android 5.0 und höher abzielen.

Installieren Sie mehrere JDK und versuchen Sie es.

UPDATE 2017/11/04 - Android Studio 3.0 bietet jetzt native Unterstützung für Java 8. gradle-retrolambda wird jetzt nicht mehr benötigt. Siehe https://developer.android.com/studio/write/java8-support.html

Der obige Link enthält auch Migrationsanweisungen, wenn Sie verwenden gradle-retrolambda. Ursprüngliche Antwort unten:

Android unterstützt Java 8 nicht. Es unterstützt nur bis zu Java 7 (wenn Sie Kitkat haben) und es hat immer noch keine aufgerufene Dynamik, nur den neuen Syntaxzucker.

Wenn Sie Lambdas verwenden möchten, eine der Hauptfunktionen von Java 8 in Android, können Sie gradle-retrolamba verwenden . Es ist eine Gradle-Build-Abhängigkeit, die Retrolambda integriert, ein Tool, das Java 8-Bytecode zurück in Java 6/7 konvertiert. Wenn Sie den Compiler in Android Studio so einstellen, dass er Java 8-Bytecode kompiliert und somit Lambdas zulässt, wird er grundsätzlich wieder in Java 6/7-Bytecode konvertiert, der dann wiederum in Dalvik-Bytecode konvertiert wird. Es ist ein Hack, wenn Sie anstelle der offiziellen Unterstützung einige JDK 8-Funktionen in Android ausprobieren möchten.

Sie können in der Tat die gradle-retrolambaGradle-Build-Abhängigkeit verwenden, um Java 8 für die Android-Entwicklung zu verwenden.

Unten finden Sie die vollständige Anleitung, die ich kürzlich befolgt habe, um Lambda-Ausdrücke für die Android-Entwicklung auszuführen. Die Originalquelle dieses Handbuchs wird am Ende erwähnt.

In diesem Handbuch wird eine Methode zum Einbringen einiger Java 8- Funktionen in die Android-Entwicklungstools vorgestellt, die speziell auf die Eclipse-IDE abzielt . Die Schritte, die in diesem Handbuch beschrieben werden, können jedoch auch an die neue Entwicklungsumgebung für Aufstände von Google, Android Studio, angepasst werden. Es basiert auf der Community-Edition der beliebten IntelliJ Idea IDE von JetBrains und wurde kürzlich von Google Anfang Juli 2014 auf die Beta-Version aktualisiert, kurz bevor dieser Leitfaden verfasst wurde. Eclipse wird zumindest für eine Weile die herausragende Entwicklungsumgebung bleiben. Angesichts der Tatsache, dass die meisten Android-Projekte mit Eclipse entwickelt wurden, scheint eine Methode zum Einbringen neuer Java 8-Funktionen wie Lambda-Ausdrücke in ADT für Entwickler recht nützlich zu sein.

Die Android-Entwicklung basiert auf einer benutzerdefinierten Java-Implementierung namens Apache Harmony Project, die bereits 2011 beendet wurde. Die in der Android-Entwicklung am häufigsten verwendete Java-Syntax ist Java 6 (v1.6), und Java 7 (v1.7) wird teilweise auch unterstützt die KitKat Edition (Android 4.4. +). Daher können Java 8-Funktionen wie Lambda-Ausdrücke nicht direkt in der Android-App-Entwicklung verwendet werden, ohne dass einige Änderungen an den Entwicklungstools vorgenommen wurden. Glücklicherweise handelt es sich bei diesen Konstrukten im Grunde genommen um einige Verbesserungen des "syntaktischen Zuckers", die Entwicklern die Mängel von Dingen wie "anonymen Klassen" vermitteln, und sie können in Java 6- oder Java 7-Klassen übersetzt werden.

Ein neuerer Ansatz zur Übersetzung eines Java 8-Quellcodes in niedrigere Java-Versionen heißt RetroLambda . Mit dieser Bibliothek können Entwickler Java 8-Code mit Lambda-Ausdrücken auf Java 7 oder niedriger ausführen. Leider werden andere Java 8-Funktionen als Lambda-Ausdrücke von RetroLambda derzeit nicht unterstützt, aber das Konzept der Lambda-Ausdrücke ist der größte Sprung auf der Java 8-Plattform und ein großartiges Tool für Android-Entwickler.

Details zu dieser Bibliothek finden Sie auf der GitHub-Seite:

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

Ein von einem anderen Entwickler erstelltes Gradle-Plugin für RetroLambda ermöglicht die Implementierung von Gradle-basierten Builds in Java- oder Android-Projekten. Der Entwickler erwähnt jedoch nur die Integration dieses Plugins in die Android Studio-Umgebung. Details finden Sie auf der GitHub-Seite:

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

Die Verwendung dieser Infrastrukturen in einer Eclipse-basierten Entwicklungsumgebung kann nicht direkt angegangen werden, ist jedoch machbar und wird in diesem Handbuch demonstriert.

Vorbereitung

In diesem Handbuch wird davon ausgegangen, dass der Leser über grundlegende Kenntnisse der Android-Entwicklung verfügt und auf ADT Version 22.6.2 basiert, da die aktuelle ADT-Version 23.0.2 Probleme mit der Erstellung von Layoutordnern zu haben scheint. Details zu diesem Problem finden Sie unter folgendem Link:

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

Die Schritte in diesem Handbuch werden für einen 64-Bit- Entwicklungscomputer von Windows 8.1 angegeben, können jedoch problemlos an andere Plattformen angepasst werden. Das neue Build-System Gradlewird für Build / Clean-Prozesse verwendet, und das Installationsverfahren wird ebenfalls bereitgestellt. Außerdem müssen beide JDK 8und JDK 7auf der Entwicklungsmaschine koexistieren. Die folgenden Schritte müssen befolgt werden, um sie zu installieren:

• Gehen Sie zur Vorschau-Seite für den frühen Zugriff auf JDK 8 http://jdk8.java.net
• Laden Sie JDK 8u20 herunter und installieren Sie es. Die Installation von JRE 8 ist nicht erforderlich und kann übersprungen werden
• Gehen Sie zur neuesten stabilen Release-Seite von JDK 7 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
• Laden Sie JDK 7u65 herunter und installieren Sie es. Die Installation von JRE 7 ist erneut nicht erforderlich und kann übersprungen werden
• Fügen Sie binIhrer %PATH%Variablen den JDK 8-Basisordner und den JDK 8- Ordner hinzu
• Erstellen Sie eine neue Umgebungsvariable JAVA_HOMEmit dem Wert des Pfads des JDK 8-Basisordners
• Erstellen Sie erneut eine neue Umgebungsvariable JAVA8_HOMEmit dem Wert des Pfads des JDK 8-Basisordners
• Erstellen Sie eine neue Umgebungsvariable JAVA7_HOMEmit dem Wert des Pfads des JDK 7-Basisordners
• Öffnen Sie ein Terminalfenster und führen Sie den java -versionBefehl aus. Überprüfen Sie, ob Java 8 aktiv ist
• Führen Sie den javac -versionBefehl im selben Fenster aus und stellen Sie sicher, dass der JDK 8-Java-Compiler ebenfalls aktiv ist

Jetzt muss ADT-22.6.2 über den folgenden Link heruntergeladen werden:

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

• Laden Sie ADT herunter und entpacken Sie den Inhalt in einen Ordner, z D:\adt
• Definieren Sie eine neue Umgebungsvariable ANDROID_HOMEmit dem Wert des Pfads Ihres ADT-Installationsordners, zD:\adt\sdk
• Fügen Sie Ihre Andoid SDK Platform Toolsund Andoid SDK ToolsOrdner, z. B. D:\adt\sdk\toolsund D:\adt\sdk\platform-tools, zu Ihrer %PATH%Variablen hinzu
• Erstellen Sie eine Verknüpfung zu Eclipse IDE, wenn Sie möchten. Es befindet sich unter Ihrem ADT-Installationsordner, zD:\adt\eclipse
• Führen Sie Eclipse IDE aus und erstellen Sie einen Arbeitsbereich, z D:\adt\workspace
• Klicken Sie auf die Android SDK ManagerSchaltfläche in der Symbolleiste
• Wählen Sie Android SDK Build tools Rev. 19.1und Android Support Librarynur. Deaktivieren Sie alles andere und installieren Sie diese beiden Pakete.

Wenn alles gut geht, ist ADT betriebsbereit.

Die Installation der folgenden Tools wird ebenfalls dringend empfohlen:

• Java 8-Unterstützung für Eclipse Kepler: Dadurch erkennt Eclipse neue Java 8-Syntaxerweiterungen und macht Ärger red dotsin Ihrem Java-Code-Editor überflüssig. Es kann über Help -> Install New Softwarein Eclipse installiert werden . Geben Sie http://download.eclipse.org/eclipse/updates/4.3-P-builds/ in das Work withFeld ein und fahren Sie mit der Installation fort.

• Nodeclipse / Enide Gradle: Wird hauptsächlich zum Hervorheben von Schlüsselwörtern in der Sprache Groovy verwendet. Groovy wird als DSL für Gradle-Build-Skripte verwendet. Dieses Plugin kann über installiert werden Eclipse Marketplace. Eclipse in ADT-22.6.2 wird jedoch nicht mitgeliefert Eclipse Marketplace Client. Daher müssen Sie zuerst installieren müssen Eclipse Marketplace Clientmittels Install New SoftwareWerkzeug in Eclipse. Geben Sie http //: download.eclipse.org/mpc/kepler/ in das Work withFeld ein und fahren Sie mit der Installation fort. Nach der Installation Eclipse Marketplace Clientkönnen Sie Nodeclipse/Enide Gradlein der suchen Eclipse Marketplace Clientund es installieren.

• Virtuelles Genymotion-Gerät: Es ist ein großartiger Ersatz für die Standardeinstellung, Android Virtual Devicedie mit ADT geliefert wird . AVD ist ärgerlich umständlich und stürzt ohne Grund weiter ab. Mit Genymotion können Sie Android-VDs mithilfe von CyanogenModBildern vorbereiten , die von Oracle VirtualBox ausgeführt werden . Die Einzelbenutzerlizenz ist kostenlos und kann von http://www.genymotion.com heruntergeladen werden . Es ist nur ein Login erforderlich und es kann auch in Eclipse integriert werden. Details finden Sie unter:

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

Unten sehen Sie einen Screenshot eines auf Android 4.3 basierenden virtuellen CyanogenMod-Geräts.

Es kann als vollwertiges Android-Gerät betrachtet werden, das auf einem x86- oder x64-basierten PC ausgeführt wird. Um Google-Dienste wie Google PlayStoreauf diesem virtuellen Gerät nutzen zu können, muss ein gappsBild für die verwendete Android-Version auf das Gerät geflasht werden. Ein geeignetes gappsImage für das Gerät kann von der CyanogenMod-Website heruntergeladen werden:

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

Die Gradle-Installation ist optional, da sie auch vom Android SDK selbst bereitgestellt wird. Eine separate Installation wird jedoch dringend empfohlen. Die Installation kann folgendermaßen erfolgen:

• Gehen Sie zur Gradle-Website: http://www.gradle.org/

• Klicken Downloads

• Unter Previous Releaseswählen Version 1.10 herunterladen entweder gradle-1.10-all.zip oder gradle-1.10-bin.zip
• Entpacken Sie den Inhalt in einen Ordner, z D:\adt\gradle
• Definieren Sie eine neue Umgebungsvariable GRADLE_HOMEmit dem Wert des Pfads Ihres Gradle-Installationsordners, zD:\adt\gradle
• Fügen Sie D:\adt\gradle\binIhrer %PATH%Variablen beispielsweise Ihren Gradle-Binärordner hinzu
• Öffnen Sie ein Terminalfenster, führen Sie den gradle -vBefehl aus und überprüfen Sie, ob er ausgeführt wird. Wenn Sie diesen Punkt erfolgreich erreicht haben, können Sie Ihre erste Android-App mit Java 8-Funktionen erstellen.

Demo App

Es wird eine einfache App erstellt, um die Verwendung der im vorherigen Abschnitt beschriebenen Tools zu demonstrieren. Sie können einfach die folgenden Schritte ausführen, um einen Einblick in die Verwendung von Lambda-Ausdrücken in den Android Developer Tools zu erhalten:

• Führen Sie Eclipse IDE aus und erstellen Sie eine neue Android-App, indem Sie auswählen File -> New -> Other -> Android -> Android Application Project
• Füllen Sie das folgende Formular aus:

• Klicken Sie einfach auf die NextSchaltfläche in den folgenden Formularen und dann auf die FinishSchaltfläche auf dem letzten. Warten Sie, bis ADT das Laden des Projekts abgeschlossen hat
• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie es aus New -> Folderund benennen Sie esbuilders
• Klicken Sie mit der rechten Maustaste auf den gen (Generated Java Files)Ordner und löschen Sie ihn. Gradle wird in Kürze die gleichen Dateien für uns generieren und wir werden sie in den s build path. Thevom Standard-Ant Builder erstellten Projekt- Gen-Ordner einfügen, der nicht mehr benötigt wird, und die Artefakte unter diesem Ordner sind veraltet

• Erstellen Sie folgende Batchdateien unter dem buildersOrdner:

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

• Füllen Sie diese Batch-Dateien wie folgt aus:

gradle_build.cmd:

gradle_post_build.cmd:

gradle_clean.cmd:

• Deaktivieren Sie die Project -> Build AutomaticallyMenüoption
• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Properties -> BuildersSie alle von ADT bereitgestellten Standard-Builder aus und deaktivieren Sie sie
• Klicken Sie auf die NewSchaltfläche im selben Fenster und wählen Sie Programund klicken SieOK
• Das neue Builder-Konfigurationsfenster wird angezeigt. Füllen Sie die Registerkarten wie folgt aus:

Main Registerkarte der neuen Builder-Konfiguration

Refresh Registerkarte der neuen Builder-Konfiguration

Environment Registerkarte der neuen Builder-Konfiguration

Build Options Registerkarte der neuen Builder-Konfiguration

• Erstellen Sie den zweiten Builder mit dem Namen Gradle_Post_Build, der gradle_post_build.cmdals Programm verwendet wird. Alle anderen Einstellungen dieses Builders müssen mit denen des zuvor erstellten Builders identisch sein. Dieser Builder ist dafür verantwortlich, die durch den Build-Prozess erstellten Artefakte in den binOrdner zu kopieren .
• Erstellen Sie den dritten Builder mit dem Namen Gradle_Cleaner, der gradle_clean.cmdals Programm verwendet wird. Nur die Run the builderEinstellung auf der letzten Registerkarte muss als festgelegt werden During a Clean. Alle anderen Einstellungen dieses Builders müssen mit denen des ersten Builders identisch sein. Dieser Builder ist für die Reinigung der durch den Build-Prozess erstellten Artefakte verantwortlich, wie der Name schon sagt.

Neue Erbauer des HelloLambdaProjekts

• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Export
• Wählen Sie Android -> Generate Gradle Build Filesund klicken SieNext
• Wählen Sie das Projekt im nächsten Fenster aus und klicken Sie auf Finish
• Gehen Sie zum Stammordner Ihres Projekts und löschen Sie die Dateien gradlewund gradlew.bat. Löschen Sie auch den gradleOrdner
• Wechseln Sie zurück zu Eclipse und wählen Sie die Project -> CleanMenüoption. Füllen Sie das folgende Formular aus:

Clean Project Fenster

• Klicken Sie OKund warten Sie, bis der Reinigungsvorgang abgeschlossen ist
• Fügen Sie das unten angegebene Java-Code-Snippet direkt nach dem Aufruf hinzu, um setContentViewin Ihrer MainActivityKlasse zu funktionieren :

• Ändern Sie den Anfang der build.gradleDatei bis sourceCompatibilityzum folgenden Abschnitt:

• Klicken Sie mit der rechten Maustaste auf das Projekt, wählen Sie die Properties -> Java CompilerOption aus und setzen Sie alle Konformitätsstufen auf Java 8. Dadurch erkennt Eclipse neue Java 8-Konstrukte wie Lambda-Ausdrücke.
• Klicken Sie Noin das Benachrichtigungsfenster
• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Build project. Eclipse beginnt mit der Erstellung des Projekts.

Erstellungsprozess

• Klicken Sie mit der rechten Maustaste auf das Projekt und gehen Sie zu Properties -> Java Build Path. Fügen Sie dem Erstellungspfad die folgenden Ordner hinzu (siehe auch Abbildung unten):

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

Eclipse kann nun Dateien erkennen R.javaund buildConfig.javaanzeigen und zeigt keine red dotsFehler an, die sich auf die Ressourcendateien des Projekts beziehen.

• Erstellen Sie eine neue Run Configurationfür Ihre Android-Zielplattform, indem Sie mit der rechten Maustaste auf das Projekt klicken und dann auswählen Run As -> Run Configurations. Diese Demo-Anwendung sieht beispielsweise wie folgt aus: Genymotion VD:

HelloLambda-Anwendung

Sie können im LogCatFenster feststellen, dass das Code-Snippet mit einem einfachen Lambda-Ausdruck ordnungsgemäß funktioniert

Quelle: Verwenden von Java 8 Lambda Expressions in Android Developer Tools

Folgen Sie diesem Link für neue Updates. Verwenden Sie Java 8-Sprachfunktionen

Alte Antwort

Ab Android N Preview Release unterstützt Android eingeschränkte Funktionen von Java 8, siehe Java 8 Sprachfunktionen

Um diese Funktionen nutzen zu können, müssen Sie Android Studio 2.1 und das Android N Preview SDK herunterladen und einrichten , das die erforderliche Jack- Toolchain und das aktualisierte Android-Plugin für Gradle enthält. Wenn Sie noch nicht die Android - N Vorschau SDK installiert ist , siehe Set Up für Android N zu entwickeln .

Unterstützte Java 8-Sprachfunktionen und APIs

Android unterstützt derzeit nicht alle Java 8-Sprachfunktionen. Die folgenden Funktionen sind jetzt jedoch verfügbar, wenn Sie Apps für die Android N-Vorschau entwickeln:

Standard- und statische Schnittstellenmethoden

Lambda-Ausdrücke (auch auf API-Ebene 23 und niedriger verfügbar)

Wiederholbare Anmerkungen

Methodenreferenzen (auch auf API-Ebene 23 und niedriger verfügbar)

Es gibt einige zusätzliche Java 8-Funktionen, die von Android unterstützt werden. Ausführliche Informationen finden Sie in den Java 8-Sprachfunktionen

Aktualisieren

Hinweis: Das Android N basiert bei der Implementierung von Lambda-Ausdrücken auf anonymen Klassen. Dieser Ansatz ermöglicht es ihnen, abwärtskompatibel und auf früheren Versionen von Android ausführbar zu sein. Denken Sie zum Testen von Lambda-Ausdrücken in früheren Versionen daran, in Ihre build.gradle-Datei zu wechseln und compileSdkVersion und targetSdkVersion auf 23 oder niedriger zu setzen.

Update 2

Jetzt unterstützt die stabile Version von Android Studio 3.0 Java 8-Bibliotheken und Java 8-Sprachfunktionen (ohne den Jack-Compiler).

Ja, Android unterstützt jetzt Java 8 (24.1.17)

Jetzt ist es möglich

Sie müssen Ihr Gerät jedoch unter Java 1.8 ausführen und "jackOptions" aktivieren, damit es ausgeführt werden kann. Jack ist der Name für den neuen Android-Compiler, auf dem Java 8 ausgeführt wird

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

Fügen Sie diese Zeilen zu build_gradle hinzu

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

Java 8 scheint die laufende Java-Engine von Android Studio 2.0 zu sein, aber es akzeptiert immer noch nicht die Syntax von Java 8, nachdem ich es überprüft habe, und Sie können jetzt keinen Compiler aus Android Studio auswählen. Sie können das Scala-Plugin jedoch verwenden, wenn Sie einen funktionalen Programmiermechanismus in Ihrem Android-Client benötigen.

Android verwendet ein Java, das von Java 6 abzweigt.

Ab Android SDK Version 19 können Sie Java - 7 - Funktionen verwenden , indem Sie diese . (Noch) keine vollständige Unterstützung für Java 8.

Native Java 8 kommt auf Android! Schließlich!

Entfernen Sie das Retrolambda-Plugin und den Retrolambda-Block aus der build.gradle-Datei jedes Moduls:

Um Jack zu deaktivieren und zur Standard-Toolchain zu wechseln, entfernen Sie einfach den jackOptions-Block aus der build.gradle-Datei Ihres Moduls

Aktualisieren Sie das Android-Plugin auf 3.0.0 (oder höher), um die unterstützten Java 8-Sprachfunktionen zu verwenden.

Ab Android Studio 3.0 werden Java 8-Sprachfunktionen jetzt von Android nativ unterstützt:

• Lambda-Ausdrücke
• Methodenreferenzen
• Typanmerkungen (derzeit sind Typanmerkungsinformationen nicht zur Laufzeit verfügbar, sondern nur zur Kompilierungszeit);
• Anmerkungen wiederholen
• Standard- und statische Schnittstellenmethoden (auf API-Ebene 24 oder höher, keine sofortige Ausführung);

Ebenfalls ab der Mindest-API-Ebene 24 sind die folgenden Java 8-APIs verfügbar:

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

Fügen Sie diese Zeilen zum build.gradle Ihres Anwendungsmoduls hinzu, um das Projekt über die Sprachstufe zu informieren:

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

Deaktivieren Sie die Unterstützung für Java 8- Sprachfunktionen, indem Sie Ihrer gradle.properties- Datei Folgendes hinzufügen :

android.enableDesugar=false

Du bist fertig! Sie können jetzt natives Java8 verwenden!

Android unterstützt offiziell 8 8 ab Android N.

Feature-Ankündigungen sind hier , die Java 8-Sprachansage lautet:

Verbesserte Java 8-Sprachunterstützung - Wir freuen uns, Java 8-Sprachfunktionen für Android verfügbar zu machen. Mit dem Jack-Compiler von Android können Sie jetzt viele beliebte Java 8-Sprachfunktionen, einschließlich Lambdas und mehr, auf Android-Versionen bereits bei Gingerbread verwenden. Die neuen Funktionen tragen zur Reduzierung des Boilerplate-Codes bei. Beispielsweise können Lambdas anonyme innere Klassen ersetzen, wenn sie Ereignis-Listener bereitstellen. Einige Java 8-Sprachfunktionen - wie Standard- und statische Methoden, Streams und Funktionsschnittstellen - sind jetzt auch für N und höher verfügbar. Mit Jack freuen wir uns darauf, die Java-Sprache genauer zu verfolgen und gleichzeitig die Abwärtskompatibilität aufrechtzuerhalten.

Wir können Java 8 verwenden mit:

1. Fügen Sie in build.gradle (Projekt: myProject) Folgendes hinzu

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

2. Fügen Sie in build.gradle (Modul: myModule) Folgendes hinzu

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

UPDATE 2020/01/17

Android Studio 4.0 bietet Unterstützung für die Verwendung einer Reihe von Java 8-Sprach-APIs mithilfe der Desugaring-Technik, ohne dass eine Mindest-API-Stufe für Ihre App erforderlich ist:
https://developer.android.com/studio/preview/features#j8-desugar

Die folgenden APIs werden in dieser Version unterstützt:

• Sequentielle Streams ( java.util.stream)
• Eine Teilmenge von java.time
• java.util.function
• Neueste Ergänzungen zu java.util.{Map,Collection,Comparator}
• Optionals ( java.util.Optional, java.util.OptionalIntund java.util.OptionalDouble) und einige andere neue Klassen, die mit den oben genannten APIs nützlich sind
• Einige Ergänzungen zu java.util.concurrent.atomic(neue Methoden auf AtomicInteger, AtomicLongund AtomicReference)
• ConcurrentHashMap (mit Fehlerkorrekturen für Android 5.0)

Um diese Sprach-APIs zu unterstützen, kompiliert D8 eine separate Bibliotheks-DEX-Datei, die eine Implementierung der fehlenden APIs enthält und diese in Ihre App einfügt. Der Desugaring-Prozess schreibt den Code Ihrer App neu, um diese Bibliothek stattdessen zur Laufzeit zu verwenden.

Fügen Sie Folgendes in die build.gradleDatei Ihres Moduls ein, um die Unterstützung für diese Sprach-APIs zu aktivieren :

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

ORIGINAL POST AB 2017

Android Studio 3.0 bietet nun integrierte Unterstützung für einige der Java 8-Sprachfunktionen:

• Lambda-Ausdrücke
• Methodenreferenzen
• Typanmerkungen (Informationen sind zur Kompilierungszeit verfügbar, jedoch nicht zur Laufzeit)
• Anmerkungen wiederholen
• Standard- und statische Schnittstellenmethoden

Ab API-Level 24 stehen auch folgende Java 8-APIs zur Verfügung:

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

Außerdem die try-with-resources Unterstützung auf alle Android-API-Ebenen erweitert.

Weitere Java 8-Funktionen werden voraussichtlich in Zukunft hinzugefügt.

Um die unterstützten Java 8-Sprachfunktionen zu verwenden, aktualisieren Sie das Android-Plugin auf 3.0.0-alpha1 (oder höher) und fügen Sie der build.gradle-Datei Ihres Moduls Folgendes hinzu:

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

Weitere Informationen finden Sie unter:
https://developer.android.com/studio/write/java8-support.html

Einfacher Weg

Sie können die Java 1.8-Unterstützung für Android-Projekte aktivieren.

• Öffnen Sie die Projektstruktur

  • Entweder durch Drücken Ctrl + Shift + Alt + S

  • Oder File > Project Structure

• Aktualisieren Sie die Quell- und Zielkompatibilität im Dialogfeld "Projektstruktur" wie gezeigt auf 1,8 (klicken Sie auf "Datei"> "Projektstruktur").

Oder Sie können Gradle verwenden

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

Projekt synchronisieren. Und das ist es!

Hinweis: Die Java 1.8-Unterstützung kann für Android Studio 3.0.0 oder höher aktiviert werden . Weitere Informationen finden Sie in der Dokumentation .

Als ich diese Frage vor fast 2 Jahren stellte, war die Antwort wirklich "offiziell" Nein, aber wie in der Antwort von ekcr1 hervorgehoben, können Sie eine der am meisten erwarteten Funktionen (Lambdas) zum Laufen bringen, wenn Sie Retrolamba verwenden. Zu der Zeit, als ich noch Eclipse verwendete, befand sich Android Studio im Vorschaumodus, sodass ich diesen Weg nie eingeschlagen habe.

Heute denke ich, dass die „offizielle“ Antwort immer noch Nein lautet, und während Retrolamba immer noch ein guter Weg zu sein scheint, gibt es eine andere Option für diejenigen, die bereit sind, einen etwas „inoffiziellen“ Weg zu gehen, nämlich Kotlin.

Heute erreichte Kotlin 1.0.0. Für diejenigen, die nicht mit Kotlin vertraut sind, finden Sie weitere Informationen auf ihrer Website hier:

https://kotlinlang.org

oder schauen Sie sich dieses Utube-Video eines Vortrags von Jake Wharton an

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

Neuesten Nachrichten:

Google gibt bekannt, dass die Plattform mit Android N und Android Studio 2.1+ Java 8 unterstützt. Außerdem wurde eine stabile Version von Studio 2.1 veröffentlicht.

Endlich können wir Lambda-Ausdrücke verwenden. Kein Listenfilter mehr in for-Schleife. Horeeey.

Fügen Sie diese Konfiguration build.gradle hinzu und synchronisieren Sie 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 hat gerade angekündigt, dass Java 8 von Android nativ unterstützt wird und dass die Jack-Toolchain veraltet sein wird:

Wir haben uns entschlossen, die Unterstützung für Java 8-Sprachfunktionen direkt in die aktuellen Javac- und DX-Tools aufzunehmen und die Jack-Toolchain zu verwerfen. Mit dieser neuen Richtung sollten vorhandene Tools und Plugins, die vom Dateiformat der Java-Klasse abhängen, weiterhin funktionieren. In Zukunft werden Java 8-Sprachfunktionen vom Android-Build-System nativ unterstützt. Wir beabsichtigen, dies in den kommenden Wochen als Teil von Android Studio zu starten, und wir wollten diese Entscheidung frühzeitig mit Ihnen teilen.

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

Ja. Wir werden bald Java 8 verwenden!

Wir haben uns entschlossen, die Unterstützung für Java 8-Sprachfunktionen direkt in die aktuellen Javac- und DX-Tools aufzunehmen und die Jack-Toolchain zu verwerfen. Mit dieser neuen Richtung sollten vorhandene Tools und Plugins, die vom Dateiformat der Java-Klasse abhängen, weiterhin funktionieren. In Zukunft werden Java 8-Sprachfunktionen vom Android-Build-System nativ unterstützt. Wir beabsichtigen, dies in den kommenden Wochen als Teil von Android Studio zu starten, und wir wollten diese Entscheidung frühzeitig mit Ihnen teilen.

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

Füge diese Zeile in das Modul lvl build gradel ein

compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

Ich habe eine ähnliche Antwort auf eine ähnliche Frage zu Stack Overflow geschrieben, aber hier ist ein Teil dieser Antwort.

Android Studio 2.1:

Die neue Version von Android Studio (2.1) unterstützt Java 8-Funktionen. Hier ist ein Auszug aus dem Blogspot-Beitrag von Android Developers :

... Android Studio 2.1 enthält Unterstützung für den neuen Jack-Compiler und Unterstützung für Java 8 .

...

Um Java 8-Sprachfunktionen beim Entwickeln mit der N Developer Preview zu verwenden, müssen Sie den Jack-Compiler verwenden. Der Assistent für neue Projekte [Datei → Neu → Projekt] generiert die richtigen Konfigurationen für Projekte, die auf das N abzielen.

Vor Android Studio 2.1:

Android unterstützt Java 1.8 noch nicht (es unterstützt nur bis zu 1.7), daher können Sie keine Java 8-Funktionen wie Lambdas verwenden.

Diese Antwort enthält weitere Informationen zur Kompatibilität von Android Studio . Es sagt aus:

Wenn Sie Lambdas verwenden möchten, eine der Hauptfunktionen von Java 8 in Android, können Sie gradle-retrolamba verwenden

Wenn Sie mehr über die Verwendung erfahren möchten gradle-retrolambda, enthält diese Antwort viele Details dazu .

Ich dachte, ich würde eine aktualisierte Antwort für diejenigen veröffentlichen, die etwas Aktuelleres suchen.

Derzeit unterstützen Android und Android Studio eine Teilmenge der Java 8-Funktionen. Laut der Android-Dokumentation auf ihrer Website sagt Google:

Für die Unterstützung von Java 8-Sprachfunktionen ist ein neuer Compiler namens Jack erforderlich. Jack wird nur unter Android Studio 2.1 und höher unterstützt. Wenn Sie also Java 8-Sprachfunktionen verwenden möchten, müssen Sie Android Studio 2.1 verwenden, um Ihre App zu erstellen.

Wenn Sie Android Studio bereits installiert haben, stellen Sie sicher, dass Sie auf die neueste Version aktualisieren, indem Sie auf Hilfe> Nach Updates suchen klicken (auf Mac, Android Studio> Nach Updates suchen). Wenn Sie die IDE noch nicht auf Ihrer Workstation installiert haben, laden Sie Android Studio hier herunter.

Unterstützte Java 8-Sprachfunktionen und APIs

Android unterstützt nicht alle Java 8-Sprachfunktionen. Bei der Entwicklung von Apps für Android 7.0 (API-Level 24) stehen jedoch die folgenden Funktionen zur Verfügung:

• Standard- und statische Schnittstellenmethoden Lambda-Ausdrücke (auch auf API-Ebene 23 und niedriger verfügbar)
• Wiederholbare Anmerkungen
• Methodenreferenzen (auch auf API-Ebene 23 und niedriger verfügbar)
• Typanmerkungen (auch auf API-Ebene 23 und niedriger verfügbar)

Darüber hinaus sind die folgenden Java 8-Sprach-APIs verfügbar:

Reflexions- und sprachbezogene APIs:

• java.lang.FunctionalInterface
• java.lang.annotation.Repeatable
• java.lang.reflect.Method.isDefault () und Reflection-APIs, die wiederholbaren Annotationen zugeordnet sind, z. B. AnnotatedElement.getAnnotationsByType (Class)

Dienstprogramm-APIs:

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

Um die neuen Java 8-Sprachfunktionen nutzen zu können, müssen Sie auch die Jack-Toolchain verwenden . Diese neue Android-Toolchain kompiliert Java-Sprachquellen in Android-lesbaren DEX-Bytecode, verfügt über ein eigenes .jack-Bibliotheksformat und bietet die meisten Toolchain-Funktionen als Teil eines einzigen Tools: Umpacken, Verkleinern, Verschleiern und Multidex.

Hier ist ein Vergleich der beiden Toolchains, die zum Erstellen von Android DEX-Dateien verwendet werden:

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

Ich habe diese Frage vor über 3 Jahren gestellt und offensichtlich haben sich die Antworten im Laufe der Jahre geändert. Wie viele oben bereits geantwortet haben, lautete die Antwort seit einiger Zeit Ja . Ich habe die akzeptierte Antwort nie aktualisiert, da sie zu diesem Zeitpunkt die richtige war. (Ich bin nicht sicher, wie die Stapelüberlaufrichtlinie lautet)

Ich wollte nur eine weitere Antwort für diejenigen hinzufügen, die noch nach diesem Thema suchen. Ab dem 17.05.2017 gab Google außerdem bekannt, dass Kotlin auch eine offizielle Sprache für die Android-Entwicklung ist.

Ich habe keine offizielle Pressemitteilung gefunden, aber ich habe mir einige der Google I / O- Videos angesehen, in denen sie angekündigt wurden. Hier ist ein Link zu einem Blog- Beitrag des Kotlin-Teams zur Ankündigung.

Das Hinzufügen des Folgenden hat das Problem für mich behoben (Android Studio 2.3.2):

build.gradle (Projekt)

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

build.gradle (Modul: 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
    ...
}

Eine Teilmenge von Java 8 wird jetzt in Android Studio unterstützt. Nehmen Sie einfach die Einstellungen für die Quell- und Zielkompatibilität im folgenden Fenster vor:

Datei -> Projektstruktur

Weitere Informationen finden Sie unter dem folgenden Link.

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

UPDATE 28.10.2019

Android Studio 4.0 löst dieses Problem .

Der D8-Compiler patcht zur Kompilierungszeit einen Backport der nativen Java 8-APIs in Ihr APK, und Ihre App verwendet diesen Code zur Laufzeit anstelle der nativen APIs. Der Prozess wird als Desugaring bezeichnet .

Alle oben genannten Lösungen scheinen 2019 mit dem neuesten Android Studio 3.4+ nicht zu funktionieren .

Ich habe eine perfekte und aktuelle Lösung gefunden, um Ihr Android-Projekt auf Java 8 zu migrieren oder zu aktualisieren .

Lösung: Klicken Sie auf Datei -> Projektstruktur -> Module -> Registerkarte Eigenschaften .

Ändern Sie die Quell- und Zielkompatibilität in 1.8 (Java 8).

Ja, Sie können Java 8-Sprachfunktionen in Android Studio verwenden, die Version muss jedoch 3.0 oder höher sein. In diesem Artikel erfahren Sie, wie Sie Java 8-Funktionen im Android Studio verwenden.

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

Einfachste Möglichkeit, Java 8-Unterstützung hinzuzufügen

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

Fügen Sie es einfach in Ihre build.gradle-Datei ein.