import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ListDemo {
    public static void main(String[] args) {
        List<DogDO> dogs = new ArrayList<>();

        List<String> tom = dogs.stream().filter(dog -> dog.getName().startsWith("tom")).map(dog -> dog.getName().toLowerCase()).collect(Collectors.toList());
        System.out.println(tom);
    }
}

0 aload_0
1 invokevirtual #56 <other/list/DogDO.getName : ()Ljava/lang/String;>
4 ldc #67 <tom>
6 invokevirtual #69 <java/lang/String.startsWith : (Ljava/lang/String;)Z>
9 ireturn

private static Boolean lambda$main$0(DogDO dogDo){
   return dogDo.getName().startsWith("tom");
}

0 aload_0
1 invokevirtual #56 <other/list/DogDO.getName : ()Ljava/lang/String;>
4 invokevirtual #62 <java/lang/String.toLowerCase : ()Ljava/lang/String;>
7 areturn

private static String lambda$main$1(DogDO dogDo){
   return dogDo.getName().toLowerCase();
}

 0 new #7 <java/util/ArrayList>
 3 dup
 4 invokespecial #9 <java/util/ArrayList.<init> : ()V>
 7 astore_1
 8 aload_1
 9 invokeinterface #10 <java/util/List.stream : ()Ljava/util/stream/Stream;> count 1
14 invokedynamic #16 <test, BootstrapMethods #0>
19 invokeinterface #20 <java/util/stream/Stream.filter : (Ljava/util/function/Predicate;)Ljava/util/stream/Stream;> count 2
24 invokedynamic #26 <apply, BootstrapMethods #1>
29 invokeinterface #30 <java/util/stream/Stream.map : (Ljava/util/function/Function;)Ljava/util/stream/Stream;> count 2
34 invokestatic #34 <java/util/stream/Collectors.toList : ()Ljava/util/stream/Collector;>
37 invokeinterface #40 <java/util/stream/Stream.collect : (Ljava/util/stream/Collector;)Ljava/lang/Object;> count 2
42 checkcast #11 <java/util/List>
45 astore_2
46 getstatic #44 <java/lang/System.out : Ljava/io/PrintStream;>
49 aload_2
50 invokevirtual #50 <java/io/PrintStream.println : (Ljava/lang/Object;)V>
53 return

14 invokedynamic #16 <test, BootstrapMethods #0>

 /**
     * Facilitates the creation of simple "function objects" that implement one
     * or more interfaces by delegation to a provided {@link MethodHandle},
     * after appropriate type adaptation and partial evaluation of arguments.
     * Typically used as a bootstrap method for {@code invokedynamic}
     * call sites, to support the lambda expression and method
     * reference expression features of the Java Programming Language.
     *
     * This is the standard, streamlined metafactory; additional flexibility
     * is provided by {@link #altMetafactory(MethodHandles.Lookup, String, MethodType, Object...)}.
     * A general description of the behavior of this method is provided
     * {@link LambdaMetafactory above}.
     *
     * When the target of the {@code CallSite} returned from this method is
     * invoked, the resulting function objects are instances of a class which
     * implements the interface named by the return type of {@code invokedType},
     * declares a method with the name given by {@code invokedName} and the
     * signature given by {@code samMethodType}.  It may also override additional
     * methods from {@code Object}.
     *
     * @param caller Represents a lookup context with the accessibility
     *               privileges of the caller.  Specifically, the lookup context
     *               must have
     *               private access
     *               privileges.
     *               When used with {@code invokedynamic}, this is stacked
     *               automatically by the VM.
     * @param invokedName The name of the method to implement.  When used with
     *                    {@code invokedynamic}, this is provided by the
     *                    {@code NameAndType} of the {@code InvokeDynamic}
     *                    structure and is stacked automatically by the VM.
     * @param invokedType The expected signature of the {@code CallSite}.  The
     *                    parameter types represent the types of capture variables;
     *                    the return type is the interface to implement.   When
     *                    used with {@code invokedynamic}, this is provided by
     *                    the {@code NameAndType} of the {@code InvokeDynamic}
     *                    structure and is stacked automatically by the VM.
     *                    In the event that the implementation method is an
     *                    instance method and this signature has any parameters,
     *                    the first parameter in the invocation signature must
     *                    correspond to the receiver.
     * @param samMethodType Signature and return type of method to be implemented
     *                      by the function object.
     * @param implMethod A direct method handle describing the implementation
     *                   method which should be called (with suitable adaptation
     *                   of argument types, return types, and with captured
     *                   arguments prepended to the invocation arguments) at
     *                   invocation time.
     * @param instantiatedMethodType The signature and return type that should
     *                               be enforced dynamically at invocation time.
     *                               This may be the same as {@code samMethodType},
     *                               or may be a specialization of it.
     * @return a CallSite whose target can be used to perform capture, generating
     *         instances of the interface named by {@code invokedType}
     * @throws LambdaConversionException If any of the linkage invariants
     *                                   described {@link LambdaMetafactory above}
     *                                   are violated, or the lookup context
     *                                   does not have private access privileges.
     */
    public static CallSite metafactory(MethodHandles.Lookup caller,
                                       String invokedName,
                                       MethodType invokedType,
                                       MethodType samMethodType,
                                       MethodHandle implMethod,
                                       MethodType instantiatedMethodType)
            throws LambdaConversionException {
        AbstractValidatingLambdaMetafactory mf;
        mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                             invokedName, samMethodType,
                                             implMethod, instantiatedMethodType,
                                             false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
        mf.validateMetafactoryArgs();
        return mf.buildCallSite();
    }

package other.list;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ListDemo {
    public static void main(String[] args) {
        List<DogDO> dogs = new ArrayList<>();

        List<String> tom = dogs.stream().filter(new Predicate<DogDO>() {
            @Override
            public boolean test(DogDO dogDO) {
                return lambda$main$0(dogDO);
            }
        }).map(new Function<DogDO, String>() {

            @Override
            public String apply(DogDO dogDO) {
                return lambda$main$1(dogDO);
            }
        }).collect(Collectors.toList());
        System.out.println(tom);
    }

    private static Boolean lambda$min$0(DogDO dogDo) {
        return dogDo.getName().startsWith("tom");
    }

    private static String lambda$main$1(DogDO dogDo) {
        return dogDo.getName().toLowerCase();
    }

}