java.lang.invoke

---

1. Dynamic Method Invocation:

CallSite site = LambdaMetafactory.metafactory(
    java.lang.invoke.MethodHandles.lookup(),
    "hello",
    MethodType.methodType(void.class, String.class),
    LambdaMetafactory.FLAG_PUBLIC | LambdaMetafactory.FLAG_FINAL,
    MethodType.methodType(String.class),
    "sayHello"
);
site.dynamicInvoker().invoke("John"); // Prints "Hello John!"

2. Customizing Method Invocation Logic:

MethodHandle mh = MethodHandles.lookup().findVirtual(
    String.class, "toUpperCase", MethodType.methodType(String.class)
);
MethodHandle mhCustom = MethodHandles.filterArguments(
    mh, 0, String.class, String::toUpperCase
);
System.out.println(mhCustom.invoke("hello")); // Prints "HELLO"

3. Partial Application (Currying):

MethodHandle concatHandle = MethodHandles.lookup().findVirtual(
    String.class, "concat", MethodType.methodType(String.class, String.class)
);
MethodHandle prependHandle = MethodHandles.insertArguments(
    concatHandle, 1, "Hello "
);
System.out.println(prependHandle.invoke("World")); // Prints "Hello World"

4. Method Linking:

MethodHandle printlnHandle = MethodHandles.lookup().findVirtual(
    java.io.PrintStream.class, "println", MethodType.methodType(void.class, Object.class)
);
MethodHandle toUpperCaseHandle = MethodHandles.lookup().findStatic(
    String.class, "toUpperCase", MethodType.methodType(String.class, String.class)
);
MethodHandle composed = MethodHandles.filterArguments(
    printlnHandle, 1, toUpperCaseHandle
);
composed.invoke("hello"); // Prints "HELLO" to System.out

5. Auto-Unboxing:

MethodHandle plusHandle = MethodHandles.lookup().findStatic(
    Integer.class, "sum", MethodType.methodType(Integer.class, int.class, int.class)
);
MethodHandle unboxedHandle = MethodHandles.explicitCastArguments(
    plusHandle, MethodType.methodType(Integer.class, Integer.class, Integer.class)
);
System.out.println(unboxedHandle.invoke(4, 5)); // Prints 9

6. Variable-Arity Method Invocation (InvokeDynamic):

InvokeDynamic invoker = (args) -> String.join(",", args);
MethodHandle handle = invoker.bindTo("A", "B", "C");
System.out.println(handle.invoke()); // Prints "A,B,C"

7. Exception Handling with Method Handles:

MethodHandle mh = MethodHandles.lookup().findStatic(
    java.lang.Math.class, "log", MethodType.methodType(double.class, double.class)
);
MethodHandle fallbackHandle = MethodHandles.lookup().findVirtual(
    java.lang.Double.class, "isInfinite", MethodType.methodType(boolean.class)
);
MethodHandle catchHandle = MethodHandles.guardWithTest(
    mh, fallbackHandle, MethodHandles.ifInstanceOf(Double.class)
);
System.out.println(catchHandle.invoke(Double.POSITIVE_INFINITY)); // Prints "true"

8. Customizing Java Bean Access:

MethodHandle getterHandle = MethodHandles.lookup()
    .findGetter(Foo.class, "name", String.class)
    .filterArguments(1, String.class, String::toUpperCase);
System.out.println(getterHandle.invoke(new Foo("John"))); // Prints "JOHN"

9. High-Performance Memory Access:

ByteBuffer buffer = ByteBuffer.allocate(1024);
MethodHandle getHandle = MethodHandles.lookup()
    .findVirtual(java.nio.Buffer.class, "get", MethodType.methodType(byte.class, int.class));
for (int i = 0; i < buffer.capacity(); i++) {
    System.out.print(getHandle.invokeExact(buffer, i) + ", ");
}

10. Reflective Operations:

MethodHandle mh = MethodHandles.lookup()
    .findConstructor(Foo.class, MethodType.methodType(void.class, String.class));
Foo foo = (Foo) mh.invokeExact("John");
System.out.println(foo.getName()); // Prints "John"

11. Method Reflection:

MethodHandle mh = MethodHandles.lookup()
    .findVirtual(java.lang.String.class, "compareTo", MethodType.methodType(int.class, String.class));
System.out.println(mh.reflect(new Foo("John"), "John").invoke()); // Prints 0

12. Dynamic Method Lookup:

MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle mh = lookup.in(Foo.class)
    .findVirtual("getName", MethodType.methodType(String.class));
System.out.println(mh.invoke(new Foo("John"))); // Prints "John"

13. Class Casting:

MethodHandle mh = MethodHandles.lookup()
    .findVirtual(java.lang.Object.class, "getClass", MethodType.methodType(Class.class));
MethodHandle castHandle = MethodHandles.castArguments(
    mh, 0, Foo.class
);
Foo foo = (Foo) castHandle.invokeExact(new Foo("John"));
System.out.println(foo.getName()); // Prints "John"

14. Array Element Access:

MethodHandle mh = MethodHandles.lookup()
    .findStatic(java.lang.Math.class, "sqrt", MethodType.methodType(double.class, double.class));
MethodHandle arrayHandle = MethodHandles.arrayElementGetter(double[].class);
double[] array = {1, 4, 9};
for (int i = 0; i < array