Pesquisando na web, não está claro se o Java 8 é suportado para desenvolvimento do Android ou não.

Antes de baixar / configurar o Java 8, alguém pode me apontar para qualquer documentação "oficial" que diga que o Java 8 é ou não é suportado no desenvolvimento do Android.

java 8

O Android suporta todos os recursos da linguagem Java 7 e um subconjunto de recursos da linguagem Java 8 que variam de acordo com a versão da plataforma.

Para verificar quais recursos do java 8 são suportados

Use os recursos da linguagem Java 8

Decidimos adicionar suporte para os recursos da linguagem Java 8 diretamente ao conjunto atual de ferramentas javac e dx e descontinuar a cadeia de ferramentas Jack. Com essa nova direção, as ferramentas e plugins existentes dependentes do formato de arquivo da classe Java devem continuar funcionando. No futuro, os recursos da linguagem Java 8 serão suportados nativamente pelo sistema de compilação Android. Nosso objetivo é lançá-lo como parte do Android Studio nas próximas semanas e queremos compartilhar essa decisão com você.

Futuro do suporte a recursos da linguagem Java 8 no Android

Usuários do Eclipse:

Para desenvolvedores antigos que preferem o Eclipse, o Google Stop suporta as ferramentas de desenvolvedor do Eclipse Android

se você instalou o Java 8 JDK, tente se houver algum problema, tente configurar o compilador como 1.6 no Eclipse no menu da janela → Preferências → Java → Compilador . O Java 7 também funciona:

É necessário o Java 7 ou superior se você estiver direcionando o Android 5.0 e superior.

instale vários JDK e tente.

ATUALIZAÇÃO 4/11/11 - O Android Studio 3.0 agora tem suporte nativo para Java 8. gradle-retrolambda agora não é mais necessário. Consulte https://developer.android.com/studio/write/java8-support.html

O link acima também inclui instruções de migração se você estiver usando gradle-retrolambda. Resposta original abaixo:

O Android não suporta o Java 8. Ele suporta apenas o Java 7 (se você tiver kitkat) e ainda não possui o invokedynamic, apenas o novo açúcar de sintaxe.

Se você deseja usar lambdas, um dos principais recursos do Java 8 no Android, pode usar o gradle-retrolamba . É uma dependência de compilação gradle que integra retrolambda, uma ferramenta que converte o bytecode do Java 8 em Java 6/7. Basicamente, se você configurar o compilador no Android Studio para compilar o Java 8 bytecode, permitindo assim lambdas, ele o converterá novamente em Java 6/7 bytecode, que por sua vez será convertido em dalvik bytecode. É um truque para, se você quiser experimentar alguns recursos do JDK 8 no Android, em vez de suporte oficial.

Você pode realmente usar a gradle-retrolambadependência do gradle build para usar o Java 8 for Android Development.

Abaixo está o guia completo que segui recentemente para executar expressões lambda para o desenvolvimento do Android. A fonte original deste guia é mencionada no final.

Neste guia, será demonstrado um método para trazer alguns recursos do Java 8 para as Ferramentas de Desenvolvimento do Android, visando especificamente o Eclipse IDE. No entanto, as etapas descritas neste guia também podem ser adaptadas ao novo ambiente de desenvolvimento de revoltas do Google, o Android Studio. Ele é baseado na edição da comunidade do popular IntelliJ Idea IDE da JetBrains e foi recentemente atualizado para sua versão 'beta' pelo Google no início de julho de 2014, um pouco antes da redação deste guia. O Eclipse permanecerá como o ambiente de desenvolvimento de destaque, pelo menos por um tempo, e considerando o fato de que a maioria dos projetos Android foram desenvolvidos usando o Eclipse, um método para trazer novos recursos do Java 8, como expressões lambda para o ADT, parece ser bastante útil para os desenvolvedores.

O Android Development é baseado em uma implementação Java customizada chamada Apache Harmony Project, encerrada em 2011. A sintaxe Java mais comum no Android Development é Java 6 (v1.6) e Java 7 (v1.7) também é parcialmente suportada em a edição KitKat (Android 4.4. +). Portanto, recursos do Java 8, como expressões lambda, não podem ser usados ​​diretamente no Android App Development sem aplicar alguns ajustes nas ferramentas de desenvolvimento. Felizmente, essas construções são basicamente alguns aprimoramentos do "açúcar sintático" que dão aos desenvolvedores deficiências de coisas como "classes anônimas" e podem ser traduzidos para as classes Java 6 ou Java 7.

Uma abordagem recente para traduzir um código-fonte do Java 8 em versões mais baixas do Java é chamada RetroLambda . Essa biblioteca faz com que os desenvolvedores executem o código Java 8 com expressões lambda no Java 7 ou até inferior. Infelizmente, os recursos do Java 8 que não sejam expressões lambda não são suportados pelo RetroLambda por enquanto, mas o conceito de expressões lambda é o maior salto na plataforma Java 8 e, de qualquer maneira, é uma ótima ferramenta para desenvolvedores do Android.

Detalhes sobre esta biblioteca podem ser encontrados na página do GitHub:

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

Além disso, um plug-in Gradle para RetroLambda criado por outro desenvolvedor permite que as construções baseadas em Gradle sejam implementadas em projetos Java ou Android. No entanto, o desenvolvedor menciona apenas a integração deste plug-in no ambiente do Android Studio. Detalhes podem ser encontrados na página do GitHub:

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

O uso dessas infra-estruturas em um ambiente de desenvolvimento baseado em Eclipse não pode ser abordado diretamente, mas é factível e será demonstrado ao longo deste guia.

Preparação

Este guia pressupõe que o leitor tenha um entendimento básico do Android Development e seja baseado na versão 22.6.2 do ADT, porque a versão 23.0.2 recente do ADT parece ter problemas como a criação da pasta de layout. Detalhes sobre esse problema podem ser encontrados no seguinte link:

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

As etapas deste guia serão fornecidas para uma máquina de desenvolvimento Windows 8.1 de 64 bits , mas elas podem ser facilmente adaptadas a outras plataformas. O novo sistema de compilação Gradleserá usado para processos de compilação / limpeza e seu procedimento de instalação também será fornecido. Além disso, ambos JDK 8e JDK 7devem coexistir na máquina de desenvolvimento. As etapas abaixo devem ser seguidas para instalá-las:

• Vá para a página de visualização de acesso antecipado do JDK 8 http://jdk8.java.net
• Faça o download do JDK 8u20 e instale-o. A instalação do JRE 8 não é necessária e pode ser ignorada
• Vá para a página de versão estável mais recente do JDK 7 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
• Faça o download do JDK 7u65 e instale-o. A instalação do JRE 7 novamente não é necessária e pode ser ignorada
• Adicione a pasta inicial do JDK 8 e a pasta JDK 8 binà sua %PATH%variável
• Crie uma nova variável de ambiente JAVA_HOMEcom o valor do caminho da pasta inicial do JDK 8
• Crie uma nova variável de ambiente JAVA8_HOMEnovamente com o valor do caminho da pasta inicial do JDK 8
• Crie uma nova variável de ambiente JAVA7_HOMEcom o valor do caminho da pasta inicial do JDK 7
• Abra uma janela do terminal e execute o java -versioncomando e verifique se o Java 8 está em funcionamento
• Execute o javac -versioncomando na mesma janela e verifique se o compilador JDK 8 Java também está instalado e em execução

Agora, o ADT-22.6.2 deve ser baixado no seguinte link:

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

• Baixe o ADT e descompacte o conteúdo em uma pasta, por exemplo D:\adt
• Defina uma nova variável de ambiente chamada ANDROID_HOMEcom o valor do caminho da sua pasta de instalação do ADT, por exemploD:\adt\sdk
• Adicione suas pastas Andoid SDK Platform Toolse Andoid SDK Tools, por exemplo , D:\adt\sdk\toolse D:\adt\sdk\platform-tools, à sua %PATH%variável
• Crie um atalho para o Eclipse IDE, se desejar. Está localizado na sua pasta de instalação do ADT, por exemploD:\adt\eclipse
• Execute o Eclipse IDE e crie um espaço de trabalho, por exemplo D:\adt\workspace
• Clique no Android SDK Managerbotão localizado na barra de ferramentas
• Selecione Android SDK Build tools Rev. 19.1e Android Support Librarysomente. Desmarque todo o resto e instale esses dois pacotes.

Se tudo correr bem, o ADT estará em funcionamento.

A instalação das seguintes ferramentas também é altamente recomendada:

• Suporte ao Eclipse Kepler para Java 8: Faz o Eclipse reconhecer novas extensões de sintaxe do Java 8 e faz com que você se livre de irritações red dotsno seu editor de código Java. Pode ser instalado Help -> Install New Softwareno Eclipse. Digite http://download.eclipse.org/eclipse/updates/4.3-P-builds/ no Work withcampo e continue a instalá-lo.

• Nodeclipse / Enide Gradle: É usado principalmente para destacar palavras-chave do idioma Groovy. Groovy é usado como o DSL para scripts de compilação Gradle. Este plugin pode ser instalado através do Eclipse Marketplace. No entanto, o Eclipse no ADT-22.6.2 não vem junto Eclipse Marketplace Client. Portanto, você primeiro precisará instalar Eclipse Marketplace Clientpor meio da Install New Softwareferramenta no Eclipse. Digite http //: download.eclipse.org/mpc/kepler/ no Work withcampo e continue a instalá-lo. Após a instalação Eclipse Marketplace Client, você pode procurar Nodeclipse/Enide Gradleno Eclipse Marketplace Cliente instalá-lo.

• Dispositivo virtual Genymotion: É um ótimo substituto do padrão Android Virtual Deviceque acompanha o ADT. O AVD é irritantemente pesado e continua batendo sem motivo. O Genymotion faz com que você prepare VDs do Android usando CyanogenModimagens executadas pelo Oracle VirtualBox . Sua licença de usuário único é gratuita e pode ser baixada em http://www.genymotion.com . Apenas um login é necessário e também pode ser integrado ao Eclipse. Detalhes podem ser encontrados em:

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

Abaixo está uma captura de tela de um dispositivo virtual CyanogenMod baseado no Android 4.3,

Pode ser considerado um dispositivo Android completo, executado em um computador pessoal baseado em x86 ou x64. Para usar os serviços do Google, como Google PlayStoreneste dispositivo virtual, uma gappsimagem da versão Android usada deve ser exibida no dispositivo. Uma gappsimagem adequada para o dispositivo pode ser baixada do site da CyanogenMod:

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

A instalação do Gradle é opcional, pois também é fornecida pelo próprio SDK do Android, mas sua instalação separada é altamente recomendada. A instalação pode ser realizada seguindo estas etapas:

• Acesse o site da Gradle: http://www.gradle.org/

• Clique Downloads

• Em Previous Releasesescolha a versão 1.10 e baixe gradle-1.10-all.zip ou gradle-1.10-bin.zip
• Descompacte o conteúdo em uma pasta, por exemplo D:\adt\gradle
• Defina uma nova variável de ambiente chamada GRADLE_HOMEcom o valor do caminho da sua pasta de instalação Gradle, por exemploD:\adt\gradle
• Adicione sua pasta de binários Gradle, por exemplo D:\adt\gradle\bin, à sua %PATH%variável
• Abra uma janela do terminal e execute o gradle -vcomando e verifique se está funcionando Se você chegou a este ponto com êxito, significa que está pronto para criar seu primeiro aplicativo Android usando os recursos do Java 8.

Demo App

Um aplicativo simples será criado para demonstrar o uso das ferramentas descritas na seção anterior. Você pode simplesmente seguir as etapas fornecidas abaixo para obter uma idéia sobre o uso de expressões lambda nas Ferramentas do desenvolvedor do Android:

• Execute o Eclipse IDE e crie um novo aplicativo Android selecionando File -> New -> Other -> Android -> Android Application Project
• Preencha o formulário que aparece como mostrado abaixo:

• Simplesmente clique no Nextbotão nos seguintes formulários e clique no Finishbotão no último. Aguarde até o ADT terminar de carregar o projeto
• Clique com o botão direito do mouse no projeto e selecione New -> Foldere nomeie-obuilders
• Clique com o botão direito do mouse na gen (Generated Java Files)pasta e exclua-a. Gradle gerará os mesmos arquivos para nós em breve e os adicionaremos à s build path. Thepasta gen do projeto criada pelo construtor Ant padrão não é mais necessária e os artefatos nessa pasta ficarão obsoletos

• Crie os seguintes arquivos em lotes na builderspasta:

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

• Preencha esses arquivos em lotes da seguinte maneira:

gradle_build.cmd:

gradle_post_build.cmd:

gradle_clean.cmd:

• Desmarque a Project -> Build Automaticallyopção de menu
• Clique com o botão direito do mouse no projeto e selecione Properties -> Builderse desmarque todos os construtores padrão fornecidos pelo ADT
• Clique no Newbotão na mesma janela e selecione Programe clique emOK
• A nova janela de configuração do construtor será exibida. Preencha suas guias da seguinte maneira:

Main Guia da nova configuração do construtor

Refresh Guia da nova configuração do construtor

Environment Guia da nova configuração do construtor

Build Options Guia da nova configuração do construtor

• Crie o segundo construtor chamado Gradle_Post_Buildque usa gradle_post_build.cmdcomo seu programa. Todas as outras configurações deste construtor devem ser exatamente iguais às do construtor criado anteriormente. Esse construtor será responsável por copiar os artefatos criados pelo processo de construção na binpasta.
• Crie o terceiro construtor chamado Gradle_Cleanerque usa gradle_clean.cmdcomo seu programa. Somente a Run the builderconfiguração na guia final deve ser definida como During a Clean. Todas as outras configurações deste construtor devem ser exatamente iguais com o primeiro construtor. Esse construtor será responsável pela limpeza dos artefatos criados pelo processo de construção, conforme o nome sugere.

Novos Construtores do HelloLambdaProjeto

• Clique com o botão direito do mouse no projeto e selecione Export
• Selecione Android -> Generate Gradle Build Filese cliqueNext
• Selecione o projeto na próxima janela e clique em Finish
• Vá para a pasta raiz do seu projeto e exclua os arquivos gradlewe gradlew.bat. Excluir também gradlepasta
• Volte para o Eclipse e selecione a Project -> Cleanopção de menu. Preencha o formulário que aparece da seguinte maneira:

Clean Project Janela

• Clique OKe aguarde até que o processo de limpeza seja concluído
• Adicione o snippet de código Java fornecido abaixo logo após a chamada para setContentViewfuncionar em sua MainActivityclasse:

• Altere o início do build.gradlearquivo até a sourceCompatibilityseção da seguinte maneira:

• Clique com o botão direito do mouse no projeto, selecione a Properties -> Java Compileropção e defina todos os níveis de conformidade como Java 8. Isso fará com que o Eclipse reconheça novas construções do Java 8 como expressões lambda.
• Clique Nona janela de notificação
• Clique com o botão direito do mouse no projeto e selecione Build project. O Eclipse começará a construir o projeto.

Processo de compilação

• Clique com o botão direito do mouse no projeto e vá para Properties -> Java Build Path. Adicione as seguintes pastas ao caminho da compilação (também mostrado na imagem abaixo):

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

O Eclipse agora poderá reconhecer R.javae buildConfig.javaarquivos e não exibirá nenhum red dotsque indique erros relacionados aos arquivos de recursos do projeto.

• Crie um novo Run Configurationpara sua plataforma de destino Android clicando com o botão direito do mouse no projeto e selecionando Run As -> Run Configurations. Por exemplo, este aplicativo de demonstração se parece com o mostrado abaixo no Genymotion VD:

Aplicação HelloLambda

Você pode observar na LogCatjanela que o trecho de código com uma expressão lambda simples funciona corretamente

Fonte: Usando expressões Java 8 Lambda nas ferramentas do desenvolvedor do Android

Siga este link para novas atualizações. Use os recursos da linguagem Java 8

Resposta antiga

A partir da versão de pré-visualização do Android N, o Android suporta recursos limitados do Java 8, consulte Recursos da linguagem Java 8

Para começar a usar esses recursos, você precisa baixar e configurar o Android Studio 2.1 e o Android N Preview SDK, que inclui a cadeia de ferramentas Jack necessária e o plug-in Android atualizado para Gradle. Se você ainda não instalou o N Android SDK de visualização, consulte criada para desenvolver para Android N .

Recursos e APIs da linguagem Java 8 suportados

Atualmente, o Android não suporta todos os recursos da linguagem Java 8. No entanto, os seguintes recursos estão disponíveis no desenvolvimento de aplicativos direcionados para o Android N Preview:

Métodos de interface estáticos e padrão

Expressões Lambda (também disponíveis na API nível 23 e inferior)

Anotações repetíveis

Referências de método (também disponíveis na API nível 23 e inferior)

Existem alguns recursos adicionais do Java 8 suportados pelo Android, você pode ver detalhes completos em Recursos do idioma do Java 8

Atualizar

Nota: O Android N baseia sua implementação de expressões lambda em classes anônimas. Essa abordagem permite que eles sejam compatíveis com versões anteriores e executáveis ​​em versões anteriores do Android. Para testar expressões lambda em versões anteriores, lembre-se de acessar o arquivo build.gradle e configure compileSdkVersion e targetSdkVersion para 23 ou menos.

Atualização 2

Agora, a versão estável do Android studio 3.0 suporta bibliotecas Java 8 e recursos da linguagem Java 8 (sem o compilador Jack).

Sim, o Android suporta Java 8 Now (24.1.17)

Agora é possivel

Mas você precisará que seu dispositivo seja executado no java 1.8 e habilite "jackOptions" para executá-lo. Jack é o nome do novo compilador Android que executa o Java 8

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

adicione estas linhas ao build_gradle

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

O Java 8 parece ser o mecanismo java em execução do Android studio 2.0, mas ainda não aceita a sintaxe do java 8 após a verificação, e você não pode escolher um compilador no android studio agora. No entanto, você pode usar o plug-in scala se precisar de um mecanismo de programação funcional no seu cliente Android.

O Android usa um Java que se ramifica do Java 6.

A partir do Android SDK versão 19, você pode usar os recursos do Java 7 fazendo isso . Não há suporte completo para Java 8 (ainda).

Java nativo 8 chega no android! Finalmente!

remova o plug-in Retrolambda e o bloco retrolambda do arquivo build.gradle de cada módulo:

Para desativar Jack e mudar para a cadeia de ferramentas padrão, basta remover o bloco jackOptions do arquivo build.gradle do seu módulo

Para começar a usar os recursos de idioma Java 8 suportados, atualize o plug-in Android para 3.0.0 (ou superior)

A partir do Android Studio 3.0, os recursos da linguagem Java 8 agora são suportados nativamente pelo android:

• Expressões lambda
• Referências de método
• Anotações de tipo (atualmente, as informações de anotação de tipo não estão disponíveis em tempo de execução, mas apenas em tempo de compilação);
• Repetindo anotações
• Métodos de interface estáticos e padrão (na API nível 24 ou superior, nenhuma execução instantânea é compatível com tho);

Também a partir do nível mínimo API 24, a seguinte API Java 8 está disponível:

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

Inclua estas linhas no build.gradle do seu módulo de aplicativo para informar o projeto sobre o nível do idioma:

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

Desative o Suporte para os recursos da linguagem Java 8 adicionando o seguinte ao seu arquivo gradle.properties :

android.enableDesugar=false

Você Terminou! Agora você pode usar o java8 nativo!

O Android OFICIALMENTE suporta Java 8 a partir do Android N.

Os anúncios de recursos estão aqui , o anúncio da linguagem Java 8 é:

Suporte aprimorado à linguagem Java 8 - Estamos felizes em trazer os recursos da linguagem Java 8 para o Android. Com o compilador Jack do Android, agora você pode usar muitos recursos populares da linguagem Java 8, incluindo lambdas e mais, em versões do Android já em Gingerbread. Os novos recursos ajudam a reduzir o código padrão. Por exemplo, lambdas podem substituir classes internas anônimas ao fornecer ouvintes de eventos. Alguns recursos da linguagem Java 8 - como métodos padrão e estáticos, fluxos e interfaces funcionais - também estão disponíveis no N e acima. Com Jack, estamos ansiosos para acompanhar a linguagem Java mais de perto, mantendo a compatibilidade com versões anteriores.

Podemos usar o Java 8 usando:

1. Em build.gradle (Project: myProject), adicione o seguinte

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

2. Em build.gradle (Módulo: myModule), adicione o seguinte

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

ATUALIZAÇÃO 2020/01/17

O Android Studio 4.0 inclui suporte para o uso de várias APIs da linguagem Java 8, usando a técnica chamada desugaring, sem exigir um nível mínimo de API para o seu aplicativo:
https://developer.android.com/studio/preview/features#j8-desugar

O seguinte conjunto de APIs é suportado nesta versão:

• Fluxos seqüenciais ( java.util.stream)
• Um subconjunto de java.time
• java.util.function
• Adições recentes a java.util.{Map,Collection,Comparator}
• Opcionais ( java.util.Optional, java.util.OptionalInte java.util.OptionalDouble) e algumas outras novas classes úteis nas APIs acima
• Algumas adições ao java.util.concurrent.atomic(novos métodos sobre AtomicInteger, AtomicLonge AtomicReference)
• ConcurrentHashMap (com correções de bugs para Android 5.0)

Para oferecer suporte a essas APIs de idioma, o D8 compila um arquivo DEX de biblioteca separado que contém uma implementação das APIs ausentes e o inclui no seu aplicativo. O processo de remoção de açúcar reescreve o código do seu aplicativo para usar essa biblioteca em tempo de execução.

Para habilitar o suporte para essas APIs de idioma, inclua o seguinte no build.gradlearquivo do seu módulo :

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

POSTO ORIGINAL DE 2017

O Android Studio 3.0 começou a fornecer suporte interno para alguns dos recursos da linguagem Java 8, que são:

• Expressões lambda
• Referências de método
• Anotações de tipo (as informações estão disponíveis no tempo de compilação, mas não no tempo de execução)
• Repetindo anotações
• Métodos de interface estáticos e padrão

Também a partir do nível da API 24, a seguinte API Java 8 está disponível:

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

Além disso, o try-with-resourcessuporte foi estendido a todos os níveis da API do Android.

É prometido que mais recursos do Java 8 sejam adicionados no futuro.

Para começar a usar os recursos de linguagem Java 8 suportados, atualize o plug-in Android para 3.0.0-alpha1 (ou superior) e adicione o seguinte ao arquivo build.gradle do seu módulo:

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

Para mais detalhes, visite:
https://developer.android.com/studio/write/java8-support.html

Jeito fácil

Você pode ativar o suporte ao java 1.8 para o projeto android.

• Estrutura de projeto aberto

  • Ou pressionando Ctrl + Shift + Alt + S

  • Ou File > Project Structure

• Atualize a Compatibilidade de origem e a Compatibilidade de destino para 1,8 na caixa de diálogo Estrutura do projeto, como mostrado (clique em Arquivo> Estrutura do projeto).

Ou você pode usar gradle

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

Projeto de sincronização. E é isso!

Nota: O suporte a Java 1.8 pode ser ativado para Android Studio 3.0.0 ou superior. Consulte a documentação para obter mais leituras.

Quando eu fiz essa pergunta há quase dois anos, a resposta realmente era “oficialmente” não, mas, como apontado pela resposta do ekcr1, você pode obter um dos recursos mais esperados (lambdas) para funcionar se você usar o retrolamba. Na época, eu ainda estava usando o eclipse, já que o Android Studio estava no modo "preview", então nunca segui esse caminho.

Hoje, acho que a resposta "oficial" ainda não é, e embora o retrolamba ainda pareça um bom caminho a percorrer, há outra opção para aqueles dispostos a seguir um caminho um tanto "não oficial", o Kotlin.

Hoje o Kotlin alcançou a 1.0.0. Para aqueles que não estão familiarizados com o Kotlin, mais informações podem ser encontradas no site encontrado aqui:

https://kotlinlang.org

ou assista a este vídeo utube de uma palestra proferida por Jake Wharton

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

Últimas notícias:

O Google anuncia que, com o Android N e o Android Studio 2.1+, a plataforma suporta Java 8. Também foi lançada a versão estável do studio 2.1.

Finalmente, podemos usar expressões lambda. Não há mais filtro de lista no loop for. Horeeey.

Adicione esta configuração build.gradle e 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
    }
}

O Google acaba de anunciar que o Java 8 será nativamente suportado pelo Android e que a cadeia de ferramentas Jack será descontinuada:

Decidimos adicionar suporte para os recursos da linguagem Java 8 diretamente ao conjunto atual de ferramentas javac e dx e descontinuar a cadeia de ferramentas Jack. Com essa nova direção, as ferramentas e plugins existentes dependentes do formato de arquivo da classe Java devem continuar funcionando. No futuro, os recursos da linguagem Java 8 serão suportados nativamente pelo sistema de compilação Android. Nosso objetivo é lançá-lo como parte do Android Studio nas próximas semanas e queremos compartilhar essa decisão com você.

Mais informações aqui: https://android-developers.googleblog.com/2017/03/future-of-java-8-language-feature.html

Sim. Em breve, usaremos o Java 8!

Decidimos adicionar suporte para os recursos da linguagem Java 8 diretamente ao conjunto atual de ferramentas javac e dx e descontinuar a cadeia de ferramentas Jack. Com essa nova direção, as ferramentas e plugins existentes dependentes do formato de arquivo da classe Java devem continuar funcionando. No futuro, os recursos da linguagem Java 8 serão suportados nativamente pelo sistema de compilação Android. Nosso objetivo é lançá-lo como parte do Android Studio nas próximas semanas e queremos compartilhar essa decisão com você.

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

adicione esta linha ao módulo lvl build gradel

compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

Eu escrevi uma resposta semelhante para uma pergunta semelhante no Stack Overflow, mas aqui está parte dessa resposta.

Android Studio 2.1:

A nova versão do Android Studio (2.1) oferece suporte aos recursos do Java 8. Aqui está um extrato da postagem do blog Android Developers :

... A versão do Android Studio 2.1 inclui suporte para o novo compilador Jack e suporte para Java 8 .

...

Para usar os recursos da linguagem Java 8 ao desenvolver com o N Developer Preview, você precisa usar o compilador Jack. O Assistente para Novo Projeto [Arquivo → Novo → Projeto] gera as configurações corretas para projetos direcionados a N.

Antes do Android Studio 2.1:

O Android ainda não suporta Java 1.8 (ele suporta apenas 1.7), portanto, você não pode usar recursos do Java 8 como lambdas.

Esta resposta fornece mais detalhes sobre a compatibilidade do Android Studio ; declara:

Se você deseja usar lambdas, um dos principais recursos do Java 8 no Android, pode usar gradle-retrolamba

Se você quiser saber mais sobre o uso gradle-retrolambda, esta resposta fornece muitos detalhes sobre isso .

Pensei em postar uma resposta atualizada para quem procura algo um pouco mais atual.

Atualmente, o Android e o Android Studio suportam um subconjunto de recursos do Java 8. De acordo com a documentação do Android localizada em seu site , o Google diz:

O suporte aos recursos da linguagem Java 8 requer um novo compilador chamado Jack. Jack é suportado apenas no Android Studio 2.1 e superior. Portanto, se você quiser usar os recursos da linguagem Java 8, precisará usar o Android Studio 2.1 para criar seu aplicativo.

Se você já possui o Android Studio instalado, atualize para a versão mais recente clicando em Ajuda> Verificar atualizações (no Mac, Android Studio> Verificar atualizações). Se você ainda não possui o IDE instalado em sua estação de trabalho, faça o download do Android Studio aqui.

Recursos e APIs da linguagem Java 8 suportados

O Android não suporta todos os recursos da linguagem Java 8. No entanto, os seguintes recursos estão disponíveis ao desenvolver aplicativos direcionados ao Android 7.0 (nível 24 da API):

• Métodos de interface estáticos e padrão Expressões lambda (também disponíveis na API nível 23 e inferior)
• Anotações repetíveis
• Referências de método (também disponíveis na API nível 23 e inferior)
• Anotações de tipo (também disponíveis no nível 23 da API e inferior)

Além disso, as seguintes APIs da linguagem Java 8 também estão disponíveis:

APIs de reflexão e relacionadas ao idioma:

• java.lang.FunctionalInterface
• java.lang.annotation.Repeatable
• APIs java.lang.reflect.Method.isDefault () e Reflection associadas a anotações repetíveis, como AnnotatedElement.getAnnotationsByType (Class)

APIs de utilitário:

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

Para usar os novos recursos da linguagem Java 8, você também precisa usar a cadeia de ferramentas Jack . Essa nova cadeia de ferramentas Android compila fontes da linguagem Java no bytecode DEX legível para Android, possui seu próprio formato de biblioteca .jack e fornece a maioria dos recursos da cadeia de ferramentas como parte de uma única ferramenta: reembalagem, encolhimento, ofuscação e multidex.

Aqui está uma comparação das duas cadeias de ferramentas usadas para criar arquivos Android DEX:

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

Eu fiz essa pergunta há mais de 3 anos e, obviamente, as respostas mudaram ao longo dos anos. Como muitos acima já responderam, já há algum tempo, a resposta se tornou Sim . Eu nunca atualizei a resposta aceita porque era a resposta correta no momento. (Não tenho certeza de qual é a política de estouro de pilha)

Eu só queria adicionar outra resposta para aqueles que ainda procuram este tópico. Em 17/05/2017, o Google também anunciou que o Kotlin também é um idioma oficial para o desenvolvimento do Android.

Não encontrei um comunicado de imprensa oficial, mas assisti a alguns dos vídeos de E / S do Google onde foi anunciado. Aqui está um link para uma postagem de blog da equipe Kotlin no anúncio.

A adição do seguinte corrigiu o problema para mim (Android studio 2.3.2):

build.gradle (Projeto)

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

build.gradle (módulo: 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
    ...
}

Um subconjunto do Java 8 é suportado agora no Android Studio. Basta fazer os ajustes de compatibilidade de origem e destino na janela abaixo:

Arquivo -> Estrutura do Projeto

Mais informações são fornecidas no link abaixo.

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

ATUALIZAÇÃO 2019/10/28

O Android Studio 4.0 resolve esse problema .

O compilador D8 corrige um backport das APIs nativas do Java 8 em seu APK no momento da compilação e seu aplicativo usará esse código, em vez das APIs nativas, em tempo de execução. O processo é chamado de dessugar .

Todas as soluções acima parecem não funcionar em 2019 com o mais recente Android Studio 3.4+ .

Eu descobri uma solução perfeita e atualizada para migrar ou atualizar seu projeto Android para Java 8 .

Solução: Clique em Arquivo -> Estrutura do Projeto -> Módulos -> guia Propriedades .

Altere a compatibilidade de origem e de destino para 1,8 (Java 8)

Sim, você pode usar os recursos da linguagem Java 8 no Android Studio, mas a versão deve ser 3.0 ou superior. Leia este artigo para saber como usar os recursos do java 8 no android studio.

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

A maneira mais fácil de adicionar suporte ao Java 8

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

Basta adicioná-lo ao seu arquivo build.gradle.