I am failing to understand how lambda expressions work in Java

I am somewhere between a beginner and intermediate-level java programmer and the mystifying concept of Functional programming caught my eyes a few days ago. I am accustomed to OOP practices and nothing about the use of lambda expressions in Java is clicking to me. Below is an example of my confusion

Runnable r1 = new Runnable() {
  @Override
  public void run () {
     System.out.println("Prior to Java 8");
   }
};

//Runnable using lambda expression
Runnable r2 = () - > {
    System.out.println("From Java 8");
};

I have no idea what the assignment of r2 to the lambda expression is supposed to mean. How is the entire object of an interface assigned to a block of code that simply prints out a message? The levels of abstraction for functional programming make little to no sense at all to me, and any replies would be greatly appreciated.

Essentially, your second block (r2) is syntax sugar. Note how the stuff in r2 is a lot less text. It gets even better if you compare, say:

Comparator stringLength = new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

versus:

Comparator stringLength = (a, b) -> a.length() - b.length();

But let's focus on r1 for a moment.

That, itself, is syntax sugar too! It's short for:

public void methodWeAreIn() {
    class MethodLocalClassWithoutAnImportantName implements Runnable {
        public void run() { System.out.println("boo"); }
    }

    Runnable r1 = new MethodLocalClassWithoutAnImportantName();
}

The point is: You're first defining a class, then making a single instance of this class, then discarding the specific type nature of it (you assign it to a variable of type Runnable. Just like in List<String> x = new ArrayList<String>();, you lose the ability to invoke trimToSize and ensureCapacity, which are methods that are only in ArrayList and not in List itself.) That's not a bad thing: In this particular code segment it doesn't matter.

And that's the point: Your type here (MethodLocalClassWithoutAnImportantName) is utterly irrelevant as a type - no method anywhere in your codebase has one of these as a parameter and no method returns it. It's like an anti-interface: Interfaces exist solely to have a type to implement or put in a method signature (as return type or parameter). The point of this class is the opposite. The point isn't the class structure. The point of this class is solely the implementations inside it. This is part of OO after all - sometimes you make an implementation of an interface and define no new methods or fields whatsoever, you're just implementing interfaces and perhaps overriding stuff from a superclass.

It's more sensible to reconsider what all this means. You're not so much defining a new class and then creating an instance. You're really just taking some code, and instead of running it, you stuff it in an envelope.

Now you can take this envelope and hand it off to another method (which can choose to hand it off too, or open it up and run it), or run it repeatedly, or run it later in another thread, etc. Yes, in r1 (and my method local class example), the 'envelope' is an object, but that's just a convenient way to do it, the point of the exercise is not to make new types, it's to make code that can travel around.

Lambdas just make that official.

NB: r2 is not exact syntax sugar; but you can't tell the difference unless you do things you should not do: Try to treat r2 as an object with identity. if you synchronized (r2), or try things like System.identityHashCOde(r2);, wonky stuff happens. The point is not to do that. Why would you want to?