java-8 does - Is it possible to use Java 8 for Android development?




language features (18)

I asked this question over 3 years ago and obviously the answers have changed over the years. As many above have already answered, as of sometime back, the answer became Yes. I have never updated the accepted answer because it was the correct answer at the time. (I am not sure what the Stack Overflow policy is on that)

I just wanted to add another answer for those who still search for this topic. As of 5/17/2017 Google also announced that Kotlin is also an official language for Android development.

I have not found an official press release, but I did watch some of the Google I/O videos where it was announced. Here is a link to a blog post by the Kotlin team on the announcement.

Searching the web, it is not clear if Java 8 is supported for Android development or not.

Before I download/setup Java 8, can some one point me at any "official" documentation that says Java 8 is or is not supported for Android development.


UPDATE 2017/11/04 - Android Studio 3.0 now has native support for Java 8. gradle-retrolambda is now no longer needed. See https://developer.android.com/studio/write/java8-support.html

The above link also includes migration instructions if you are using gradle-retrolambda. Original answer below:


Android does not support Java 8. It only supports up to Java 7 (if you have kitkat) and still it doesn't have invokedynamic, only the new syntax sugar.

If you want to use lambdas, one of the major features of Java 8 in Android, you can use gradle-retrolamba. It's a gradle build dependency that integrates retrolambda, a tool that converts Java 8 bytecode back to Java 6/7. Basically, if you set the compiler in Android Studio to compile Java 8 bytecode, thus allowing lambdas, it'll convert it back to Java 6/7 bytecode which then in turn gets converted to dalvik bytecode. It's a hack for if you want to try out some JDK 8 features in Android in lieu of official support.


I wrote a similar answer to a similar question on , but here is part of that answer.

Android Studio 2.1:

The new version of Android Studio (2.1) has support for Java 8 features. Here is an extract from the Android Developers blogspot post:

... Android Studio 2.1 release includes support for the new Jack compiler and support for Java 8.

...

To use Java 8 language features when developing with the N Developer Preview, you need to use the Jack compiler. The New Project Wizard [File→ New→ Project] generates the correct configurations for projects targeting the N.


Prior to Android Studio 2.1:

Android does not support Java 1.8 yet (it only supports up to 1.7), so you cannot use Java 8 features like lambdas.

This answer gives more detail on Android Studio's compatibility; it states:

If you want to use lambdas, one of the major features of Java 8 in Android, you can use gradle-retrolamba

If you want to know more about using gradle-retrolambda, this answer gives a lot of detail on doing that.


Google just announced that Java 8 will be natively support by Android and that the Jack toolchain will deprecate:

We've decided to add support for Java 8 language features directly into the current javac and dx set of tools, and deprecate the Jack toolchain. With this new direction, existing tools and plugins dependent on the Java class file format should continue to work. Moving forward, Java 8 language features will be natively supported by the Android build system. We're aiming to launch this as part of Android Studio in the coming weeks, and we wanted to share this decision early with you.

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


We Can Use Java 8 using:

  1. In build.gradle (Project: myProject) add following

    classpath 'me.tatarka:gradle-retrolambda:x.x.x' //x.x.x is recent version
    
  2. In build.gradle (Module: myModule) add following

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

Yes. We will use Java 8 soon!

We've decided to add support for Java 8 language features directly into the current javac and dx set of tools, and deprecate the Jack toolchain. With this new direction, existing tools and plugins dependent on the Java class file format should continue to work. Moving forward, Java 8 language features will be natively supported by the Android build system. We're aiming to launch this as part of Android Studio in the coming weeks, and we wanted to share this decision early with you.

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


Android Studio 3.0 started to provide built-in support for some of Java 8 language features, which are:

  • Lambda expressions
  • Method references
  • Type Annotations (information is available at compile time, but not at runtime)
  • Repeating annotations
  • Default and static interface methods

Also starting from API level 24 the following Java 8 API are available:

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

Besides that, the try-with-resources support was extended to all Android API levels.

More Java 8 features are promised to be added in the future.

To start using supported Java 8 language features, update the Android plugin to 3.0.0-alpha1 (or higher) and add the following to your module’s build.gradle file:

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

For more details visit:
https://developer.android.com/studio/write/java8-support.html


When I asked this question almost 2 years ago the answer really was “officially” no, but as pointed out by ekcr1's answer you can get one of the most highly anticipated features (lambdas) to work if you use retrolamba. At the time I was still using eclipse, as Android Studio was in “preview” mode, so I never did pursue this path.

Today, I think the “official” answer is still no, and while retrolamba still seems like a good way to go, there is another option for those willing to go down a somewhat “unofficial” route can take, namely Kotlin.

Today Kotlin reached 1.0.0. For those not familiar with Kotlin, more info can be found at their website found here:

https://kotlinlang.org

or watch this utube video of a talk given by Jake Wharton

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


Yes, Android Supports Java 8 Now (24.1.17)

Now it is possible

But you will need to have your device rom run on java 1.8 and enable "jackOptions" to run it. Jack is the name for the new Android compiler that runs Java 8

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

add these lines to build_gradle

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

Java 8 seem to be the running java engine of Android studio 2.0, But it still does not accept the syntax of java 8 after I checked, and you cannot chose a compiler from android studio now. However, you can use the scala plugin if you need functional programming mechanism in your android client.


Follow this link for new updates. Use Java 8 language features

Old Answer

As of Android N preview release Android support limited features of Java 8 see Java 8 Language Features

To start using these features, you need to download and set up Android Studio 2.1 and the Android N Preview SDK, which includes the required Jack toolchain and updated Android Plugin for Gradle. If you haven't yet installed the Android N Preview SDK, see Set Up to Develop for Android N.

Supported Java 8 Language Features and APIs

Android does not currently support all Java 8 language features. However, the following features are now available when developing apps targeting the Android N Preview:

Default and static interface methods

Lambda expressions (also available on API level 23 and lower)

Repeatable annotations

Method References (also available on API level 23 and lower)

There are some additional Java 8 features which Android support, you can see complete detail from Java 8 Language Features

Update

Note: The Android N bases its implementation of lambda expressions on anonymous classes. This approach allows them to be backwards compatible and executable on earlier versions of Android. To test lambda expressions on earlier versions, remember to go to your build.gradle file, and set compileSdkVersion and targetSdkVersion to 23 or lower.

Update 2

Now Android studio 3.0 stable release support Java 8 libraries and Java 8 language features (without the Jack compiler).


I figured I would post an updated answer for those looking at for something a little more current.

Currently Android and Android Studio are supporting a subset of Java 8 features. According to the Android documentation located on their website, Google says:

Support for Java 8 language features requires a new compiler called Jack. Jack is supported only on Android Studio 2.1 and higher. So if you want to use Java 8 language features, you need to use Android Studio 2.1 to build your app.

If you already have Android Studio installed, make sure you update to the latest version by clicking Help > Check for Update (on Mac, Android Studio > Check for Updates). If you don't already have the IDE installed on your workstation, download Android Studio here.

Supported Java 8 Language Features and APIs

Android does not support all Java 8 language features. However, the following features are available when developing apps targeting Android 7.0 (API level 24):

  • Default and static interface methods Lambda expressions (also available on API level 23 and lower)
  • Repeatable annotations
  • Method References (also available on API level 23 and lower)
  • Type Annotations (also available on API level 23 and lower)

Additionally, the following Java 8 language APIs are also available:

Reflection and language-related APIs:

  • java.lang.FunctionalInterface
  • java.lang.annotation.Repeatable
  • java.lang.reflect.Method.isDefault() and Reflection APIs associated with repeatable annotations, such as AnnotatedElement.getAnnotationsByType(Class)

Utility APIs:

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

In order to use the new Java 8 language features, you need to also use the Jack toolchain. This new Android toolchain compiles Java language sources into Android-readable DEX bytecode, has its own .jack library format, and provides most toolchain features as part of a single tool: repackaging, shrinking, obfuscation and multidex.

Here is a comparison of the two toolchains used to build Android DEX files:

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

java 8

Android supports all Java 7 language features and a subset of Java 8 language features that vary by platform version.

To check which features of java 8 are supported

Use Java 8 language features

We've decided to add support for Java 8 language features directly into the current javac and dx set of tools, and deprecate the Jack toolchain. With this new direction, existing tools and plugins dependent on the Java class file format should continue to work. Moving forward, Java 8 language features will be natively supported by the Android build system. We're aiming to launch this as part of Android Studio in the coming weeks, and we wanted to share this decision early with you.

Future of Java 8 Language Feature Support on Android

Eclipse Users:

For old developers who prefer Eclipse, google stops support Eclipse Android Developer tools

if you installed Java 8 JDK, then give it a try, if any problems appears try to set the compiler as 1.6 in Eclipse from window menu → PreferencesJavaCompiler. Java 7 will works too:

Java 7 or higher is required if you are targeting Android 5.0 and higher.

install multiple JDK and try.


Add this config build.gradle and sync gradle:

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

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

Latest news:

Google announce that with Android N and Android Studio 2.1+, platform will support Java 8. Also stable version of studio 2.1 was released.

At last we can use lambda expressions. No more list filter in for loop. Horeeey.


You can indeed use gradle-retrolamba gradle build dependency to use Java 8 for Android Development.

Below is the complete guide that I have recently followed to run lambda expressions for Android development. The original source of this guide is mentioned at the end.

In this guide, a method for bringing some Java 8 features into Android Development Tools will be demonstrated, specifically aiming at Eclipse IDE. However, steps which will be described throughout this guide might also be adapted to Google’s new uprising development environment, Android Studio. It is based on the community edition of popular IntelliJ Idea IDE by JetBrains and it has recently been upgraded to its ‘beta’ version by Google in early July 2014, slightly before this guide was written. Eclipse will remain as the prominent development environment, at least for a while, and considering the fact that most Android projects have been developed using Eclipse, a method for bringing new Java 8 features like lambda expressions into ADT seems to be quite useful for developers.

Android Development is based on a custom Java implementation called Apache Harmony Project which was terminated back in 2011. The most commonly used Java syntax in Android Development is Java 6 (v1.6) and Java 7 (v1.7) is also partially supported on the KitKat edition (Android 4.4.+). Therefore, Java 8 features like lambda expressions cannot be used directly in the Android App Development without applying some tweaks into the development tools. Luckily, these constructs are basically some ‘syntactic sugar’ enhancements which give developers the shortcomings of things like ‘anonymous classes’ and they can be translated into Java 6 or Java 7 classes.

A recent approach for translating a Java 8 source code into lower Java versions is called RetroLambda. This library makes developers run Java 8 code with lambda expressions on Java 7 or even lower. Unfortunately, Java 8 features other than lambda expressions are not supported by RetroLambda for now but the concept of lambda expressions is the biggest leap on Java 8 platform and it’s a great tool for Android developers anyway.

Details about this library can be found on its GitHub page:

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

Also, a Gradle plugin for RetroLambda created by another developer allows Gradle-based builds to be implemented in Java or Android Projects. However, the developer only mentions about integrating this plugin into Android Studio environment. Details can be found on its GitHub page:

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

Using these infrastructures within an Eclipse-based development environment cannot be approached directly but it’s doable and will be demonstrated throughout this guide.

Preparation

This guide assumes that the reader has a basic understanding of Android Development and it is based on ADT version 22.6.2 because recent ADT version 23.0.2 seems to have problems like layout folder creation. Details about this issue can be found under the following link:

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

Steps in this guide will be given for a Windows 8.1, 64-bit development machine but they can easily be adapted to other platforms. The new build system Gradle will be used for build/clean processes and its installation procedure will also be provided. Also, both JDK 8 and JDK 7 must coexist on the development machine. Steps given below must be followed to install them:

  • Go to JDK 8 early access preview page http://jdk8.java.net
  • Download JDK 8u20 and install it. JRE 8 installation is not necessary and it can be skipped
  • Go to JDK 7 latest stable release page http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
  • Download JDK 7u65 and install it. JRE 7 installation is again not necessary and it can be skipped
  • Add JDK 8 home folder and JDK 8 bin folder to your %PATH% variable
  • Create a new environment variable JAVA_HOME with the value of the path of JDK 8 home folder
  • Create a new environment variable JAVA8_HOME again with the value of the path of JDK 8 home folder
  • Create a new environment variable JAVA7_HOME with the value of the path of JDK 7 home folder
  • Open a terminal window and run java -version command and verify that Java 8 is up and running
  • Run javac -version command in the same window and verify that JDK 8 Java compiler is also up and running

Now, ADT-22.6.2 must be downloaded from the following link:

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

  • Download ADT and unzip its contents into a folder, e.g. D:\adt
  • Define a new environment variable called ANDROID_HOME with the value of the path of your ADT installation folder, e.g. D:\adt\sdk
  • Add your Andoid SDK Platform Tools and Andoid SDK Tools folders, e.g. D:\adt\sdk\tools and D:\adt\sdk\platform-tools, to your %PATH% variable
  • Create a shortcut to Eclipse IDE if you like. It is located under your ADT installation folder, e.g. D:\adt\eclipse
  • Run Eclipse IDE and create a workspace, e.g. D:\adt\workspace
  • Click on the Android SDK Manager button which is located on the toolbar
  • Select Android SDK Build tools Rev. 19.1 and Android Support Library only. Un-select everything else and install these two packages.

If everything goes well, ADT will be up and running.

The installation of the following tools is also highly recommended:

  • Eclipse Kepler Java 8 Support: It makes Eclipse recognize new Java 8 syntax extensions and makes you get rid of annoying red dots in your Java code editor. It might be installed through Help -> Install New Software in Eclipse. Enter http://download.eclipse.org/eclipse/updates/4.3-P-builds/ into the Work with field and continue to install it.

  • Nodeclipse/Enide Gradle: It is mainly used to highlight Groovy language keywords. Groovy is used as the DSL for Gradle build scripts. This plugin can be installed through Eclipse Marketplace. However, Eclipse within ADT-22.6.2 does not come along with Eclipse Marketplace Client. Therefore, you will first need to install Eclipse Marketplace Client by means of Install New Software tool in Eclipse. Enter http//:download.eclipse.org/mpc/kepler/ into the Work with field and continue to install it. After installing Eclipse Marketplace Client, you may search for Nodeclipse/Enide Gradle in the Eclipse Marketplace Client and install it.

  • Genymotion Virtual Device: It is a great replacement of the default Android Virtual Device which comes along with ADT. AVD is annoyingly cumbersome and it keeps on crashing for no reason. Genymotion makes you prepare Android VD's using CyanogenMod images which are executed by Oracle VirtualBox. Its single user license is for free and it can be downloaded from http://www.genymotion.com. Only a login is required and it can also be integrated into Eclipse. Details can be found under:

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

Below is a screenshot of an Android 4.3 based CyanogenMod virtual device,

It might be considered as a fully-fledge Android device running on a x86 or x64 based personal computer. In order to use Google services like Google PlayStore on this virtual device, a gapps image for the Android version that it uses must be flashed onto the device. A proper gapps image for the device might be downloaded from CyanogenMod website:

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

Gradle installation is optional since it is also provided by Android SDK itself but its separate installation is highly recommended. Installation of it might be conducted by following these steps:

  • Go to Gradle web site: http://www.gradle.org/

  • Click Downloads

  • Under Previous Releases choose version 1.10 and download either gradle-1.10-all.zip or gradle-1.10-bin.zip
  • Unzip its contents into a folder, e.g. D:\adt\gradle
  • Define a new environment variable called GRADLE_HOME with the value of the path of your Gradle installation folder, e.g. D:\adt\gradle
  • Add your Gradle binaries folder, e.g. D:\adt\gradle\bin, to your %PATH% variable
  • Open a terminal window and run gradle -v command and verify that it`s up and running If you have come up to this point successfully then it means that you are ready to create your first Android App using Java 8 features.

Demo App

A simple app will be created to demonstrate the usage of the tools which were described in the previous section. You may simply follow the steps given below to get an insight on using lambda expressions in Android Developer Tools:

  • Run Eclipse IDE and create a new Android App by selecting File -> New -> Other -> Android -> Android Application Project
  • Fill in the form that comes up as shown below:

  • Simply click the Next button on the following forms and click the Finish button on the last one. Wait till ADT finishes loading up the project
  • Right-click on the project and select New -> Folder and name it builders
  • Right-click on the gen (Generated Java Files) folder and delete it. Gradle will generate the same files for us soon and we will add them into the projects build path. Thegen` folder created by the default Ant builder is no longer needed and the artifacts under that folder will be obsolete
  • Create following batch files under the builders folder:

    • gradle_build.cmd
    • gradle_post_build.cmd
    • gradle_clean.cmd
  • Fill in these batch files as follows:

gradle_build.cmd:

gradle_post_build.cmd:

gradle_clean.cmd:

  • Un-select Project -> Build Automatically menu option
  • Right-click on the project and select Properties -> Builders and un-select all default builders provided by ADT
  • Click the New button in the same window and select Program and click OK
  • New builder configuration window will appear. Fill in its tabs as follows:

Main Tab of the new Builder Configuration

Refresh Tab of the new Builder Configuration

Environment Tab of the new Builder Configuration

Build Options Tab of the new Builder Configuration

  • Create the second builder called Gradle_Post_Build that uses gradle_post_build.cmd as its program. All other settings of this builder must exactly be the same with the previously created builder. This builder will be responsible for copying the artifacts created by the build process into the bin folder.
  • Create the third builder called Gradle_Cleaner that uses gradle_clean.cmd as its program. Only Run the builder setting in the final tab must be set as During a Clean. All other settings of this builder must exactly be the same with the first builder. This builder will be responsible for cleaning the artifacts created by the build process as the name suggests.

New Builders of the HelloLambda Project

  • Right-click on the project and select Export
  • Select Android -> Generate Gradle Build Files and click Next
  • Select the project in the next window and click Finish
  • Go to your project's root folder and delete the files gradlew and gradlew.bat. Also delete gradle folder
  • Switch back to Eclipse and select Project -> Clean menu option. Fill in the form that shows up as follows:

Clean Project Window

  • Click OK and wait till the cleaning process completes
  • Add the Java code snippet given below right after the call to setContentView function in your MainActivity class:

  • Change the beginning of the build.gradle file till the sourceCompatibility section as follows:

  • Right-click on the project and select Properties -> Java Compiler option and set all compliance levels to Java 8. This will make Eclipse recognize new Java 8 constructs like lambda expressions.
  • Click No in the notification window
  • Right-click on the project and select Build project. Eclipse will start building the project.

Build Process

  • Right-click on the project and go to Properties -> Java Build Path. Add the following folders to the build path (also shown in below image):

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

Eclipse will now be able to recognize R.java and buildConfig.java files and it will not display any red dots which denote errors related to the resource files of the project.

  • Create a new Run Configuration for your Android target platform by right-clicking on the project and then selecting Run As -> Run Configurations. For instance, this demo application looks like shown below on the Genymotion VD:

HelloLambda Application

You may observe in the LogCat window that the code snippet with a simple lambda expression works properly

Source: Using Java 8 Lambda Expressions in Android Developer Tools



Android uses a Java that branches off of Java 6.

As of Android SDK version 19, you can use Java 7 features by doing this. No full support for Java 8 (yet).


I recently encountered a memory leak situation caused in a way by log4j.

Log4j has this mechanism called Nested Diagnostic Context(NDC) which is an instrument to distinguish interleaved log output from different sources. The granularity at which NDC works is threads, so it distinguishes log outputs from different threads separately.

In order to store thread specific tags, log4j's NDC class uses a Hashtable which is keyed by the Thread object itself (as opposed to say the thread id), and thus till the NDC tag stays in memory all the objects that hang off of the thread object also stay in memory. In our web application we use NDC to tag logoutputs with a request id to distinguish logs from a single request separately. The container that associates the NDC tag with a thread, also removes it while returning the response from a request. The problem occurred when during the course of processing a request, a child thread was spawned, something like the following code:

pubclic class RequestProcessor {
    private static final Logger logger = Logger.getLogger(RequestProcessor.class);
    public void doSomething()  {
        ....
        final List<String> hugeList = new ArrayList<String>(10000);
        new Thread() {
           public void run() {
               logger.info("Child thread spawned")
               for(String s:hugeList) {
                   ....
               }
           }
        }.start();
    }
}    

So an NDC context was associated with inline thread that was spawned. The thread object that was the key for this NDC context, is the inline thread which has the hugeList object hanging off of it. Hence even after the thread finished doing what it was doing, the reference to the hugeList was kept alive by the NDC context Hastable, thus causing a memory leak.





java android java-8 android-gradle