// Não compila por falta de informação do tipo.

public class InferenciaDeTipo {

  public static void main(String[] args){

    int valor1 = 10;

    String valor2 = "Valor";

    naoPermitido = 42;

  }

}

Melhoras na inferência dos tipos genéricos.

// Java 7

foo(Utility.<Type>bar());

Utility.<Type>foo().bar();

// Java 8

foo(Utility.bar()); 

Utility.foo().bar();

Pode-se substituir os argumentos que necessitam da declaração de tipo para chamar o construtor de uma classe genérica com um conjunto vazio de parâmetros de tipo ( <> ). Este par de colchetes é informalmente chamado diamante.

// Considere a seguinte declaração:

Map<String, List<String>> myMap = new HashMap<String, List<String>>();

//Pode-se substituir por tipo parametrizado com o construtor diamante:

Map<String, List <String>>myMap = new HashMap<>();

Tipos de Destino:

O tipo de destino de uma expressão é o tipo de dados que o compilador Java espera, dependendo de onde a expressão aparece. 

// construtor do método

vazio processStringList (List <String> stringlist)

//Java 7

//chama o método

processStringList (Collections. <String> emptyList ());

//Java 8

// chama o método

 processStringList (Collections.emptyList ());

A inferência de tipos, introduzida no Java 7, também é aplicada às expressões lambda.

//Exemplo de uso em expressão Lambda

List<String> list = Arrays.asList(...);

Collections.sort(list, (s1, s2) -> s1.length() - 2.length());

//Os tipos dos parâmetros s1 e s2 foram omitidos, o compilador sabe que a lista contém uma coleção de Strings

Inferência de tipos também se aplica à Funções de Ordem superior.

//A implementação é elegante e bem sucinta. Note que faz uso da inferência de tipos: o parâmetro p do tipo Photo não é explicitamente definido.

List<Photo> photos = Arrays.asList(...);

List<Photo>output = photos.filter
(p ->p.getSizeInKb() < 10);

No método genérico, se você omitir a declaração do tipo, o compilador Java infere automaticamente (a partir de argumentos do método) que o parâmetrode tipo é integer.

//Com a definição do tipo

BoxDemo <Integer> addBox (Integer.valueOf (10), listOfIntegerBoxes);

//Sem a definição do tipo

BoxDemo.addBox (Integer.valueOf (20), listOfIntegerBoxes);

Em Java 8 também podemos inferir os tipos da forma antiga, como era feito no Java 7

//Inferência com a utilização da tag diamante

List<Desenho> antesDe1960 = filtro.filtra(desenhos,

    (Desenho desenho) -> {

        return desenho.getDecadaDeCriacao() < 1960;

    }

);

List<Desenho> comecamComS = filtro.filtra(desenhos,

    (Desenho desenho) -> {

        return desenho.getNome().startsWith("S");

    }

);

Podemos omitir a classe do parâmetro, por causa do mecanismo de inferência de tipos do Java 8

//Sem a declaração do tipo

List antesDe1960 = filtro.filtra(desenhos,

    desenho -> desenho.getDecadaDeCriacao() < 1960

);

List comecamComS = filtro.filtra(desenhos,

    desenho -> desenho.getNome().startsWith("S")

);

O que é inferência de Tipos?

É um processo pelo qual o tipo de uma entidade declarada é inferido, quando não foi explicitamente estabelecido.

Exemplo de inferência na programação funcional com Java 8

//Métodos com valores de entrada sem
declaração de tipo

double media = mediaPonderada(provas, function(of(Prova.class).getNota()), function(of(Prova.class).getPeso()));

...

public <T> Function<Prova,T> function(T ignorado) {

    return Funcional.function(ignorado);

Em alguns casos, o compilador pode não ser capaz de inferir os tipos corretos.

Isso acontece especialmente no caso de operadores sobrecarregados; por exemplo, “(x,y) => x+y” não irá compilar se o Java não tiver informação de que x e y são long ou double (ou até mesmo Object).

Diferênça de aplicação entre Java 5/6/7 e Java 8

//Considere a classe

class List<E> {

   static <Z> List<Z> nil() { ... };

   static <Z> List<Z> cons(Z head, List<Z> tail) { ... };

   E head() { ... }

} 

//Em Java 5/6/7 essa chamada de método não compila

List.cons(42, List.nil());

//A tag diamante deveria ser usada para funcionar
List.cons(42, List.<Integer>nil());

Linguagem fortemente tipada

A linguagem que utiliza Infeência de Tipos é uma linguagem considerada: FORTEMENTE TIPADA.

Todos os erros de tipo são encontrados em tempo de compilação (tipagem estática), o que torna os programas mais seguros e mais rápidos, eliminando a necessidade de verificações de tipo em tempo de execução.

Toda expressão bem formada tem um tipo mais geral, que pode ser calculado automaticamente em tempo de compilação usando um processo chamado inferência de tipos.

Exemplo em Java de inferência de Tipos

Com o lançamento do Java 8, agora podemos fazer inferência de tipos como parte de expressões Lambda

/*O compilador Java é capaz de olhar para o método
  Collections#sort(List<T>, Comparator<? super T>) e,
  em seguida, a interface de Comparator#compare(T
  o1,T o2) e determinar que first e second deve ser um
  String permitindo ao programador abdicar de reafirmar   tipo da expressão lambda.

*/

List<String>names=Arrays.aList("Tom","Dick","Harry");

Collections.sort(names, (first, second) ->

first.compareTo(second));

Como era no Java 7?

O uso desse operador diamente, na verdade elimina uma redundância na parametrização de tipos.

//Antes

List<String> lista = new ArrayList<String>();

Map<Integer, Pessoa> map = new TreeMap<Integer, Pessoa>();

//Depois

List<String> lista = new ArrayList<>()
Map<Integer,Pessoa> map = new TreeMap<>();

Inferência de tipos e avaliação tardia

Código que usa inferência se parece com o código que depende de ligação tardia. No entanto, inferência de tipos a variável em vez de deixá-la como altamente Object. O compilador usa o inicializador de uma variável para determinar o tipo da variável em tempo de compilação 

Exemplo de inferência em tipos genéricos

//Java 7

final List<Boolean> bools = Arrays.asList(true,false,true);

final List<Character> string = bools.stream()

        .<Character>map(x -> x ? 'X' : 'O')

        .collect(Collectors.<Character>toList());

//Java 8

final List<Boolean> bools =
Arrays.asList(true, false,true);

    final List<Character> string = bools.stream()

            .map(x -> x ? 'X' : 'O')

            .collect(Collectors.toList());