Using Lambdas to create and populate objects as an argument

I find Java lambda syntax to be uniquely obscure and confusing, compared to other languages' more straightforward lambdas...

My understanding is that you can pass a lambda in lieu of an object as a parameter of a method, and the syntax goes something like

method(() -> { /*code to return value*/ } )

But I can't get a syntax that will work.

I want to build a list of objects, and I want to populate each new object with unique data (let's say a Math.random() value). So I'm trying to do this:

ArrayList<MyType> mytypes = new ArrayList<>();
mytypes.add( () -> { MyType m = new MyType(); m.populate(Math.random()); return m } );

But that apparently isn't legit, although it seems to match what minimal examples there are out there for doing this. I've also tried

mytypes.add( t -> { MyType m = new MyType(); m.populate(Math.random()); return m } );

mytypes.add( MyType t -> { MyType m = new MyType(); m.populate(Math.random()); return m } );

mytypes.add( (MyType t) -> { MyType m = new MyType(); m.populate(Math.random()); return m } );

mytypes.add( { MyType m = new MyType(); m.populate(Math.random()); return m } );

based on various syntaxes seen online, which have been barely informative.

So what is wrong with any of this? How to do this? Is it just not possible? (Shame, because most other languages using lambdas would seem to do it intuitively.)

Lambdas can only be used where an instance of a functional interface is expected. A functional interface is an interface with a single abstract method. The lambda gets compiled into an instance implementing that interface, and the lambda body becomes the implementation of that single interface method.

Here:

ArrayList<MyType> mytypes = new ArrayList<>();
mytypes.add( () -> { MyType m = new MyType(); m.populate(Math.random()); return m } );

No overload of add takes a functional interface as a parameter. Hence the above does not compile. It should instead be written as separate statements:

ArrayList<MyType> mytypes = new ArrayList<>();
MyType m = new MyType();
m.populate(Math.random());
mytypes.add(m);

For completeness' sake, you can technically write it using a lambda with a trick, by casting the lambda to a Supplier<MyType>, which is a functional interface, and then call get to actually run the code in the lambda.

mytypes.add( ((Supplier<MyType>)(() -> { MyType m = new MyType(); m.populate(Math.random()); return m })).get() );

But please don't write code like this... I don't know what "other languages" in which this is acceptable, but this is not how we do it in Java.