Diferencia entre la clase interna anónima y la expresión Lambda

Clase interna anónima :

Es una clase interna sin nombre y para la que solo se crea un único objeto. Una clase interna anónima puede ser útil al crear una instancia de un objeto con ciertos «extras», como métodos de sobrecarga de una clase o interfaz, sin tener que subclasificar una clase.
Las clases internas anónimas son útiles para escribir clases de implementación para interfaces de escucha en la programación de gráficos. 
La clase interna anónima se crea principalmente de dos maneras: 
 

• Clase (puede ser abstracto o concreto )
• Interfaz

Sintaxis: la sintaxis de una expresión de clase anónima es como la invocación de un constructor, excepto que hay una definición de clase contenida en un bloque de código. 
 

// Test can be interface, abstract/concrete class
Test t = new Test() 
{
   // data members and methods
   public void test_method() 
   {
      ........
      ........
    }   
};

Para entender la clase interna anónima, tomemos un programa simple

// Java program to demonstrate
// the need for Anonymous Inner class
 
interface Age {
    int x = 21;
    void getAge();
}
 
class AnonymousDemo {
    public static void main(String[] args)
    {
        // Myclass is implementation class of Age interface
        MyClass obj = new MyClass();
 
        // calling getage() method implemented at Myclass
        obj.getAge();
    }
}
 
// Myclass implement the methods of Age Interface
class MyClass implements Age {
    @Override
    public void getAge()
    {
        // printing the age
        System.out.print("Age is " + x);
    }
}

Age is 21

Expresiones Lambda :

Las expresiones lambda básicamente expresan instancias de interfaces funcionales (una interfaz con un único método abstracto se denomina interfaz funcional. Un ejemplo es java.lang.Runnable). Las expresiones lambda implementan la única función abstracta y, por lo tanto, implementan interfaces funcionales
. Las expresiones lambda se agregan en Java 8 y proporcionan las siguientes funcionalidades. 
 

• Habilite para tratar la funcionalidad como un argumento de método o el código como datos.
• Una función que se puede crear sin pertenecer a ninguna clase.
• Una expresión lambda puede transmitirse como si fuera un objeto y ejecutarse a pedido.

// Java program to demonstrate lambda expressions
// to implement a user defined functional interface.
 
// A sample functional interface (An interface with
// single abstract method
interface FuncInterface {
    // An abstract function
    void abstractFun(int x);
 
// A non-abstract (or default) function
default void
    normalFun()
    {
        System.out.println("Hello");
    }
}
 
class Test {
    public static void main(String args[])
    {
        // lambda expression to implement above
        // functional interface. This interface
        // by default implements abstractFun()
        FuncInterface fobj = (int x) -> System.out.println(2 * x);
 
        // This calls above lambda expression and prints 10.
        fobj.abstractFun(5);
    }
}

10

Tabla de diferencia: