方法详细信息

• type

  public MethodType type()

  报告此方法句柄的类型。 通过invokeExact对此方法句柄的每次调用invokeExact必须与此类型完全匹配。

  结果

  方法句柄类型

• invokeExact

  public final Object invokeExact​(Object... args)
                           throws Throwable

  调用方法句柄，允许任何调用者类型描述符，但需要精确的类型匹配。 调用站点invokeExact处的符号类型描述符必须与此方法句柄type完全匹配。 参数或返回值不允许转换。

  当通过Core Reflection API观察到此方法时，它将显示为单个本机方法，获取对象数组并返回对象。 如果直接通过java.lang.reflect.Method.invoke ，通过JNI或间接通过Lookup.unreflect调用此本机方法，则会抛出UnsupportedOperationException 。

  参数

  args - 签名多态参数列表，使用varargs静态表示

  结果

  签名 - 多态结果，使用 Object静态表示

  异常

  WrongMethodTypeException - 如果目标的类型与调用者的符号类型描述符不同

  Throwable - 底层方法抛出的任何内容都会通过方法句柄调用继续传播

• invoke

  public final Object invoke​(Object... args)
                      throws Throwable

  调用方法句柄，允许任何调用者类型描述符，并可选择对参数和返回值执行转换。

  如果调用站点的符号类型描述符与此方法句柄type完全匹配，则调用将按照invokeExact进行 。

  否则，调用继续进行，好像首先通过调用asType调整此方法句柄以将该方法句柄调整为所需类型，然后调用如同invokeExact一样在调整后的方法句柄上进行。

  无法保证实际发出asType电话。 如果JVM可以预测调用的结果，它可以直接对调用者的参数执行调整，并根据自己的确切类型调用目标方法句柄。

  呼叫站点invoke处的已解析类型描述符必须是接收器asType方法的有效参数。 特别是，如果被调用者不是variable arity collector ，则调用者必须指定与被调用者类型相同的参数arity。

  当通过Core Reflection API观察到此方法时，它将显示为单个本机方法，获取对象数组并返回对象。 如果直接通过java.lang.reflect.Method.invoke ，通过JNI或间接通过Lookup.unreflect调用此本机方法，则会抛出UnsupportedOperationException 。

  参数

  args - 签名多态参数列表，使用varargs静态表示

  结果

  签名 - 多态结果，使用 Object静态表示

  异常

  WrongMethodTypeException - 如果无法将目标的类型调整为调用者的符号类型描述符

  ClassCastException - 如果可以将目标的类型调整为调用者，但引用 ClassCastException失败

  Throwable - 底层方法抛出的任何内容都会通过方法句柄调用继续传播

• invokeWithArguments

  public Object invokeWithArguments​(Object... arguments)
                             throws Throwable

  执行变量arity调用，将给定数组中的参数传递给方法句柄，就好像通过来自调用站点的不精确invoke ，其仅提及类型Object ，并且其实际参数计数是参数数组的长度。

  具体而言，执行就像通过以下步骤一样进行，尽管如果JVM可以预测它们的影响，则不能保证调用这些方法。

  • 确定参数数组的长度为N 。 对于空引用， N=0 。
  • 将数组的N元素收集为逻辑参数列表，每个参数静态类型为Object 。
  • 确定，作为M ，此方法句柄的类型的参数计数。
  • 确定N参数的一般类型TN或M参数（如果小于N ，如TN=MethodType.genericMethodType(Math.min(N, M)) 。
  • 如果N大于M ，请执行以下检查和操作以缩短逻辑参数列表：
    • 检查此方法句柄是否具有变量arity，其中trailing parameter是某种数组类型A[] 。 如果没有，请使用WrongMethodTypeException 。
    • 收集后缘元件（有N-M+1他们的）从逻辑参数列表成型的单个阵列A[] ，使用asType转换到每个后参数输入转换A 。
    • 如果任何这些转换的证明是不可能的，会失败，无论是ClassCastException如果任何尾随元件不能被转换为A或NullPointerException如果任何尾随元件是null和A是不是引用类型。
    • 将收集到A[]类型数组中的逻辑参数替换为数组本身，从而将参数列表缩短为长度M 。 此最终参数保留静态类型A[] 。
    • 调节型TN通过改变N个参数类型从Object到A[] 。
  • 强制原始目标方法句柄MH0为所需类型，如MH1 = MH0.asType(TN) 。
  • 将参数列表传播到N单独的参数A0, ... 。
  • 在解压缩的参数上调用类型调整的方法句柄：MH1.invokeExact（A0，...）。
  • 将返回值作为Object参考。

  如果目标方法句柄具有变量arity，并且参数列表比该arity长，那么从尾随数组参数的位置开始的多余参数将被收集（如果可能，就像通过asType转换一样）到一个数组中适当的类型，调用将在缩短的参数列表上进行。 通过这种方式，仍可以统一处理扩展到超过254个时隙的巨型参数列表 。

  与可以“循环”数组参数的generic调用模式（将其直接传递给目标方法）不同，此调用模式始终会创建一个新的数组参数，即使传递给invokeWithArguments的原始数组可以作为直接参数接受目标方法。 即使实际参数的数字M是arity N ，并且最后一个参数动态地是类型A[]的合适数组，它仍将被装箱成新的单元素数组，因为调用站点将参数静态地键入为Object ，不是数组类型。 这不是此方法的特殊规则，而是rules for variable-arity invocation的常规效果。

  由于asType步骤的操作，将根据需要应用以下参数转换：

  • 参考铸造
  • 拆箱
  • 扩大原始转换
  • 变量转换

  如果调用返回原语，则调用返回的结果为boxed;如果返回类型为void，则强制为null。

  与签名多态方法invokeExact和invoke ， invokeWithArguments可以通过Core Reflection API和JNI正常访问。 因此，它可以用作本机或反射代码和方法句柄之间的桥梁。

  API Note:

  此调用大致相当于以下代码：

  
   // for jumbo argument lists, adapt varargs explicitly:
   int N = (arguments == null? 0: arguments.length);
   int M = this.type.parameterCount();
   int MAX_SAFE = 127;  // 127 longs require 254 slots, which is OK
   if (N > MAX_SAFE && N > M && this.isVarargsCollector()) {
     Class<?> arrayType = this.type().lastParameterType();
     Class<?> elemType = arrayType.getComponentType();
     if (elemType != null) {
       Object args2 = Array.newInstance(elemType, M);
       MethodHandle arraySetter = MethodHandles.arrayElementSetter(arrayType);
       for (int i = 0; i < M; i++) {
         arraySetter.invoke(args2, i, arguments[M-1 + i]);
       }
       arguments = Arrays.copyOf(arguments, M);
       arguments[M-1] = args2;
       return this.asFixedArity().invokeWithArguments(arguments);
     }
   } // done with explicit varargs processing
  
   // Handle fixed arity and non-jumbo variable arity invocation.
   MethodHandle invoker = MethodHandles.spreadInvoker(this.type(), 0);
   Object result = invoker.invokeExact(this, arguments);
   

  参数

  arguments - 传递给目标的参数

  结果

  目标返回的结果

  异常

  ClassCastException - 如果参数转换无法转换参数

  WrongMethodTypeException - 如果无法调整目标的类型以获取给定数量的 Object参数

  Throwable - 目标方法调用抛出的任何内容

  另请参见：

  MethodHandles.spreadInvoker(java.lang.invoke.MethodType, int)

• invokeWithArguments

  public Object invokeWithArguments​(List<?> arguments)
                             throws Throwable

  执行变量arity调用，将给定列表中的参数传递给方法句柄，就好像通过来自调用站点的不精确invoke ，其仅提及类型Object ，并且其实际参数计数是参数列表的长度。

  此方法也等效于以下代码：

  
     invokeWithArguments(arguments.toArray())
   

  如果此方法句柄具有可变arity，则可以接受巨型大小的列表。 有关详细信息，请参见invokeWithArguments(Object[]) 。

  参数

  arguments - 传递给目标的参数

  结果

  目标返回的结果

  异常

  NullPointerException - 如果 arguments是空引用

  ClassCastException - 如果参数转换无法转换参数

  WrongMethodTypeException - 如果无法调整目标的类型以获取给定数量的 Object参数

  Throwable - 目标方法调用抛出的任何内容

• asType

  public MethodHandle asType​(MethodType newType)

  生成适配器方法句柄，该句柄将当前方法句柄的类型调整为新类型。 保证生成的方法句柄报告一个等于所需新类型的类型。

  如果原始类型和新类型相等，则返回this 。

  调用新方法句柄时，将执行以下步骤：

  • 转换传入参数列表以匹配原始方法句柄的参数列表。
  • 在已转换的参数列表上调用原始方法句柄。
  • 将原始方法句柄返回的任何结果转换为新方法句柄的返回类型。

  这种方法提供了invokeExact与普通，不精确invoke之间的关键行为差异。 当调用者的类型描述符与被调用者完全匹配时，这两个方法执行相同的步骤，但是当类型不同时，普通invoke也调用asType （或一些内部等价物）以匹配调用者和被调用者的类型。

  如果当前方法是一个变量arity方法，则句柄参数列表转换可能涉及将几个参数转换并收集到一个数组中，如described elsewhere 。 在所有其他情况下，所有转换都是成对应用的，这意味着每个参数或返回值都只转换为一个参数或返回值（或没有返回值）。 应用的转换是通过查询旧方法句柄类型和新方法句柄类型的相应组件类型来定义的。

  设T0和T1为对应的新旧参数类型，或旧的和新的返回类型。 具体而言，对于某些有效索引i ，设T0 =newType.parameterType(i)和T1 =this.type().parameterType(i) 。 或者，以其他方式返回值，让T0 =this.type().returnType()和T1 =newType.returnType() 。 如果类型相同，则新方法句柄不会更改相应的参数或返回值（如果有）。 否则，如果可能，将应用以下转换之一：

  • 如果T0和T1是引用，则应用转换为T1 。 （这些类型不需要以任何特定方式相关。这是因为null的动态值可以转换为任何引用类型。）
  • 如果T0和T1是基元，则应用Java方法调用转换（JLS 5.3）（如果存在）。 （具体来说， T0必须通过扩展原语转换转换为T1 。）
  • 如果T0是基元并且T1是引用，则应用Java转换（JLS 5.5）（如果存在）。 （具体来说，该值从T0加载到其包装类，然后根据需要将其加宽到T1 。）
  • 如果T0是引用而T1是原语，则将在运行时应用取消装箱转换，之后可能会对原始值进行Java方法调用转换（JLS 5.3）。 （这些是原始的扩展转换。） T0必须是包装类或超类型。 （在T0是Object的情况下，这些是java.lang.reflect.Method.invoke允许的转换。）取消装箱转换必须有成功的可能性，这意味着如果T0本身不是包装类，则必须存在至少一个包装类TW ，是T0的子类型，其未装箱的原始值可以扩展为T1 。
  • 如果返回类型T1标记为void，则丢弃任何返回的值
  • 如果返回类型T0为空且T1为引用，则引入空值。
  • 如果返回类型T0为空并且T1为基元，则引入零值。

  （ 注意： T0和T1都可以视为静态类型，因为它们都不是特定于任何实际参数或返回值的动态类型 。）

  如果无法进行任何一个所需的成对转换，则无法进行方法句柄转换。

  在运行时，应用于引用参数或返回值的转换可能需要额外的运行时检查，这可能会失败。 取消装箱操作可能会失败，因为原始引用为空，从而导致NullPointerException 。 取消装箱操作或参考演员也可能在对错误类型的对象的引用上失败，从而导致ClassCastException 。 虽然取消装箱操作可能会接受几种包装，但如果没有，则会抛出ClassCastException 。

  参数

  newType - 新方法句柄的预期类型

  结果

  在执行任何必要的参数转换后委派给 this的方法句柄，并安排任何必要的返回值转换

  异常

  NullPointerException - 如果 newType是空引用

  WrongMethodTypeException - 如果无法进行转换

  另请参见：

  MethodHandles.explicitCastArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)

• asSpreader

  public MethodHandle asSpreader​(类<?> arrayType,
                                 int arrayLength)

  创建一个数组传播方法句柄，它接受一个尾随数组参数并将其元素作为位置参数传播。 新方法句柄将当前方法句柄作为其目标进行调整。 适配器的类型将与目标的类型相同，除了目标类型的最终arrayLength参数被arrayLength类型的单个数组参数arrayType 。

  如果数组元素类型与原始目标上的任何相应参数类型不同，则原始目标将适合直接获取数组元素，就像调用asType一样 。

  调用时，适配器用数组的元素替换尾随数组参数，每个元素作为目标的自己的参数。 （保留参数的顺序。）通过转换和/或取消装箱将它们成对转换为目标的尾随参数的类型。 最后调用目标。 目标最终返回的内容由适配器返回。

  在调用目标之前，适配器会验证数组是否包含足够的元素，以便为目标方法句柄提供正确的参数计数。 （当需要零元素时，数组也可以为null。）

  调用适配器时，将查询提供的array参数的长度，如同array.length或arraylength字节码一样。 如果适配器接受零长度尾随数组参数，则提供的array参数可以是零长度数组或null ; 否则，如果阵列是null ，则适配器将抛出NullPointerException如果阵列没有正确数量的元素，则抛出IllegalArgumentException 。

  以下是数组传播方法句柄的一些简单示例：

  
  MethodHandle equals = publicLookup()
    .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
  assert( (boolean) equals.invokeExact("me", (Object)"me"));
  assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
  // spread both arguments from a 2-array:
  MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
  assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
  assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
  // try to spread from anything but a 2-array:
  for (int n = 0; n <= 10; n++) {
    Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
    try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
    catch (IllegalArgumentException ex) { } // OK
  }
  // spread both arguments from a String array:
  MethodHandle eq2s = equals.asSpreader(String[].class, 2);
  assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
  assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
  // spread second arguments from a 1-array:
  MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
  assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
  assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
  // spread no arguments from a 0-array or null:
  MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
  assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
  assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
  // asSpreader and asCollector are approximate inverses:
  for (int n = 0; n <= 2; n++) {
      for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
          MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
          assert( (boolean) equals2.invokeWithArguments("me", "me"));
          assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
      }
  }
  MethodHandle caToString = publicLookup()
    .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
  assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
  MethodHandle caString3 = caToString.asCollector(char[].class, 3);
  assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
  MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
  assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));
   

  参数

  arrayType - 通常为 Object[] ，从中提取扩展参数的数组参数的类型

  arrayLength - 从传入数组参数传播的参数数

  结果

  在调用原始方法句柄之前传递最终数组参数的新方法句柄

  异常

  NullPointerException - 如果 arrayType是空引用

  IllegalArgumentException - 如果 arrayType不是数组类型，或者目标不具有至少 arrayLength参数类型，或者如果 arrayLength为负数，或者结果方法句柄的类型将具有 too many parameters

  WrongMethodTypeException - 如果隐含的 asType呼叫失败

  另请参见：

  asCollector(java.lang.Class<?>, int)

• asSpreader

  public MethodHandle asSpreader​(int spreadArgPos,
                                 类<?> arrayType,
                                 int arrayLength)

  创建一个数组传播方法句柄，它接受给定位置的数组参数，并将其元素作为位置参数传播，代替数组。 新方法句柄将当前方法句柄作为其目标进行调整。 适配器的类型将与目标类型相同，除了从零开始位置spreadArgPos开始的目标类型的arrayLength参数被arrayLength类型的单个数组参数arrayType 。

  此方法的行为与asSpreader(Class, int)非常相似，但接受另外的spreadArgPos参数以指示参数列表中的哪个位置应进行扩散。

  API Note:

  例：

  
      MethodHandle compare = LOOKUP.findStatic(Objects.class, "compare", methodType(int.class, Object.class, Object.class, Comparator.class));
      MethodHandle compare2FromArray = compare.asSpreader(0, Object[].class, 2);
      Object[] ints = new Object[]{3, 9, 7, 7};
      Comparator<Integer> cmp = (a, b) -> a - b;
      assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 0, 2), cmp) < 0);
      assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 1, 3), cmp) > 0);
      assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp) == 0);
   

  参数

  spreadArgPos - 参数列表中应开始传播的位置（从零开始的索引）。

  arrayType - 通常为 Object[] ，从中提取扩展参数的数组参数的类型

  arrayLength - 从传入数组参数传播的参数数

  结果

  在调用原始方法句柄之前，在给定位置传播数组参数的新方法句柄

  异常

  NullPointerException - 如果 arrayType是空引用

  IllegalArgumentException - 如果 arrayType不是数组类型，或者目标不具有至少 arrayLength参数类型，或者 arrayLength为负数，或者 spreadArgPos具有非法值（否定，或者与arrayLength一起超过参数数量），或者如果结果方法句柄的类型将具有 too many parameters

  WrongMethodTypeException - 如果隐含的 asType呼叫失败

  从以下版本开始：

  9

  另请参见：

  asSpreader(Class, int)

• withVarargs

  public MethodHandle withVarargs​(boolean makeVarargs)

  如果布尔标志为真，则将此方法句柄调整为variable arity ，否则为fixed arity 。 如果方法句柄已经是正确的arity模式，则返回不变。

  API Note:

  当调整可能是变量arity的方法句柄时，此方法有时很有用，以确保当且仅当原始句柄是时，生成的适配器也是可变arity。 例如，此代码将句柄mh的第一个参数更改为int而不会干扰其变量arity属性： mh.asType(mh.type().changeParameterType(0,int.class)) .withVarargs(mh.isVarargsCollector())

  此调用大致相当于以下代码：

  
   if (makeVarargs == isVarargsCollector())
     return this;
   else if (makeVarargs)
     return asVarargsCollector(type().lastParameterType());
   else
     return return asFixedArity();
   

  参数

  makeVarargs - 如果返回方法句柄应具有可变的arity行为， makeVarargs true

  结果

  一个相同类型的方法句柄，可能调整了变量arity行为

  异常

  IllegalArgumentException - 如果 makeVarargs为true且此方法句柄没有尾随数组参数

  从以下版本开始：

  9

  另请参见：

  asVarargsCollector(java.lang.Class<?>) ， asFixedArity()

• asCollector

  public MethodHandle asCollector​(类<?> arrayType,
                                  int arrayLength)

  创建一个数组收集方法句柄，它接受给定数量的尾随位置参数并将它们收集到数组参数中。 新方法句柄将当前方法句柄作为其目标进行调整。 适配器的类型将与目标的类型相同，除了单个尾随参数（通常为arrayType类型）由arrayLength参数替换，其类型为元素类型arrayType 。

  如果数组类型与原始目标上的最终参数类型不同，则原始目标将适合直接获取数组类型，就像调用asType一样 。

  当被调用时，该适配器替换其尾随arrayLength由类型的单个新数组参数arrayType ，其元素包括（按顺序）被替换的参数。 最后调用目标。 目标最终返回的内容由适配器返回。

  （当arrayLength为零时，该数组也可以是共享常量。）

  （ 注意： arrayType通常与原始目标的last parameter type相同。它是asSpreader对称性的显式参数，并且还允许目标使用简单的Object作为其最后一个参数类型。）

  要创建不限于特定数量的已收集参数的收集适配器，请改用asVarargsCollector或withVarargs 。

  以下是数组收集方法句柄的一些示例：

  
  MethodHandle deepToString = publicLookup()
    .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
  assertEquals("[won]",   (String) deepToString.invokeExact(new Object[]{"won"}));
  MethodHandle ts1 = deepToString.asCollector(Object[].class, 1);
  assertEquals(methodType(String.class, Object.class), ts1.type());
  //assertEquals("[won]", (String) ts1.invokeExact(         new Object[]{"won"})); //FAIL
  assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"}));
  // arrayType can be a subtype of Object[]
  MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
  assertEquals(methodType(String.class, String.class, String.class), ts2.type());
  assertEquals("[two, too]", (String) ts2.invokeExact("two", "too"));
  MethodHandle ts0 = deepToString.asCollector(Object[].class, 0);
  assertEquals("[]", (String) ts0.invokeExact());
  // collectors can be nested, Lisp-style
  MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2);
  assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D")));
  // arrayType can be any primitive array type
  MethodHandle bytesToString = publicLookup()
    .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class))
    .asCollector(byte[].class, 3);
  assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3));
  MethodHandle longsToString = publicLookup()
    .findStatic(Arrays.class, "toString", methodType(String.class, long[].class))
    .asCollector(long[].class, 1);
  assertEquals("[123]", (String) longsToString.invokeExact((long)123));
   

  注意：生成的适配器永远不会是variable-arity method handle ，即使原始目标方法句柄是。

  参数

  arrayType - 通常为 Object[] ，将收集参数的数组参数的类型

  arrayLength - 要收集到新数组参数中的参数数

  结果

  一个新的方法句柄，它在调用原始方法句柄之前将一些尾随参数收集到一个数组中

  异常

  NullPointerException - 如果 arrayType是空引用

  IllegalArgumentException - 如果 arrayType不是数组类型或 arrayType不能分配给此方法句柄的尾随参数类型，或者 arrayLength不是合法的数组大小，或者生成的方法句柄的类型将具有 too many parameters

  WrongMethodTypeException - 如果隐含的 asType呼叫失败

  另请参见：

  asSpreader(java.lang.Class<?>, int) ， asVarargsCollector(java.lang.Class<?>)

• asCollector

  public MethodHandle asCollector​(int collectArgPos,
                                  类<?> arrayType,
                                  int arrayLength)

  创建一个数组收集方法句柄，它接受从给定位置开始的给定数量的位置参数，并将它们收集到数组参数中。 新方法句柄将当前方法句柄作为其目标进行调整。 适配器的类型将与目标的类型相同，除了collectArgPos （通常为arrayType类型）指示的位置处的参数被arrayLength参数替换，其类型为元素类型arrayType 。

  此方法的行为与asCollector(Class, int)非常相似，但不同之处在于其collectArgPos参数指示应在参数列表参数中的哪个位置进行收集。 该指数从零开始。

  API Note:

  例子：

  
      StringWriter swr = new StringWriter();
      MethodHandle swWrite = LOOKUP.findVirtual(StringWriter.class, "write", methodType(void.class, char[].class, int.class, int.class)).bindTo(swr);
      MethodHandle swWrite4 = swWrite.asCollector(0, char[].class, 4);
      swWrite4.invoke('A', 'B', 'C', 'D', 1, 2);
      assertEquals("BC", swr.toString());
      swWrite4.invoke('P', 'Q', 'R', 'S', 0, 4);
      assertEquals("BCPQRS", swr.toString());
      swWrite4.invoke('W', 'X', 'Y', 'Z', 3, 1);
      assertEquals("BCPQRSZ", swr.toString());
   

  注意：生成的适配器永远不会是variable-arity method handle ，即使原始目标方法句柄是。

  参数

  collectArgPos - 参数列表中从零开始的位置，开始收集。

  arrayType - 通常为 Object[] ，将收集参数的数组参数的类型

  arrayLength - 要收集到新数组参数中的参数数

  结果

  一个新的方法句柄，它在调用原始方法句柄之前将一些参数收集到一个数组中

  异常

  NullPointerException - 如果 arrayType是空引用

  IllegalArgumentException - 如果 arrayType不是数组类型或 arrayType不能分配给此方法句柄的数组参数类型，或者 arrayLength不是合法的数组大小，或者 collectArgPos具有非法值（负数或大于参数数），或者生成的方法句柄的类型将具有 too many parameters

  WrongMethodTypeException - 如果隐含的 asType调用失败

  从以下版本开始：

  9

  另请参见：

  asCollector(Class, int)

• asVarargsCollector

  public MethodHandle asVarargsCollector​(类<?> arrayType)

  使变量arity适配器能够接受任意数量的尾随位置参数并将它们收集到数组参数中。

  适配器的类型和行为将与目标的类型和行为相同，除了某些invoke和asType请求可能导致将尾随位置参数收集到目标的尾随参数中。 此外，适配器的last parameter type将为arrayType ，即使目标具有不同的最后一个参数类型。

  这种转化可以返回this如果该方法手柄是可变的元数的已和它的尾部参数类型是相同的arrayType 。

  使用invokeExact调用时，适配器将调用目标而不更改参数。 （ 注意：此行为与fixed arity collector不同，因为它接受整个不确定长度的数组，而不是固定数量的参数。）

  当使用普通的，不精确的invoke调用时，如果调用者类型与适配器相同，则适配器将像invokeExact一样调用目标。 （当类型匹配时，这是invoke的正常行为。）

  否则，如果调用者和适配器arity相同，并且调用者的尾随参数类型是与适配器的尾随参数类型相同或可分配的引用类型，则参数和返回值将成对转换，就像asType一样在一个固定的arity方法句柄上。

  否则，arities会有所不同，或者适配器的尾随参数类型不能从相应的调用者类型中分配。 在这种情况下，适配器通过arrayType类型的新数组替换原始尾随参数位置的所有尾随参数，其元素包含（按顺序）替换的参数。

  调用者类型必须提供足够少的参数和正确的类型，以满足目标对尾随数组参数之前的位置参数的要求。 因此，调用者必须至少提供N-1参数，其中N是目标的arity。 此外，必须存在从传入参数到目标参数的转换。 与普通invoke其他用途invoke ，如果未满足这些基本要求， WrongMethodTypeException可能会抛出WrongMethodTypeException 。

  在所有情况下，适配器都会返回目标最终返回的内容。

  在最后一种情况下，就好像目标方法句柄暂时适应了调用者类型所需的arity fixed arity collector 。 （与asCollector ，如果数组长度为零，则可以使用共享常量而不是新数组。如果对asCollector的隐含调用将抛出IllegalArgumentException或WrongMethodTypeException ，则对变量arity适配器的调用必须抛出WrongMethodTypeException ）

  的行为asType还专门为可变参数数量的适配器，保持不变的是普通的，不精确invoke总是相当于asType呼叫调整目标类型，其次为invokeExact 。 因此，当且仅当适配器和请求的类型在arity或trailing参数类型中不同时，变量arity适配器通过构建固定的arity收集器来响应asType请求。 得到的固定arity收集器的类型通过成对转换进一步调整（如果需要）到所请求的类型，就像asType的另一个应用程序asType 。

  当通过执行CONSTANT_MethodHandle常量的ldc指令获得方法句柄，并且目标方法被标记为变量arity方法（使用修饰符位0x0080 ）时，方法句柄将接受多个arities，就好像方法句柄常量是通过致电asVarargsCollector 。

  为了创建收集预定数量的参数的收集适配器，并且其类型反映该预定数量，请改用asCollector 。

  没有方法句柄转换会产生具有变量arity的新方法句柄，除非它们被记录为这样做。 因此，除了asVarargsCollector和withVarargs ，在所有方法MethodHandle和MethodHandles将返回一个方法手柄固定元数，除非他们被指定为返回原来的操作数（例如，案件asType的方法手柄自身的类型）。

  在已经是变量arity的方法句柄上调用asVarargsCollector将生成具有相同类型和行为的方法句柄。 它可能（或可能不）返回原始变量arity方法句柄。

  这是一个列表制作变量arity方法句柄的示例：

  
  MethodHandle deepToString = publicLookup()
    .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
  MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
  assertEquals("[won]",   (String) ts1.invokeExact(    new Object[]{"won"}));
  assertEquals("[won]",   (String) ts1.invoke(         new Object[]{"won"}));
  assertEquals("[won]",   (String) ts1.invoke(                      "won" ));
  assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
  // findStatic of Arrays.asList(...) produces a variable arity method handle:
  MethodHandle asList = publicLookup()
    .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
  assertEquals(methodType(List.class, Object[].class), asList.type());
  assert(asList.isVarargsCollector());
  assertEquals("[]", asList.invoke().toString());
  assertEquals("[1]", asList.invoke(1).toString());
  assertEquals("[two, too]", asList.invoke("two", "too").toString());
  String[] argv = { "three", "thee", "tee" };
  assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
  assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
  List ls = (List) asList.invoke((Object)argv);
  assertEquals(1, ls.size());
  assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));
   

  讨论：这些规则被设计为变量arity方法的Java规则的动态类型变体。 在这两种情况下，可变arity方法或方法句柄的调用者可以传递零个或多个位置参数，或者传递任何长度的预收集数组。 用户应该知道最终参数的特殊作用，以及类型匹配对最终参数的影响，它确定单个尾随参数是否被解释为整个数组或数组的单个元素集。 请注意，尾随参数的动态类型对此决定没有影响，只是调用站点的符号类型描述符和方法句柄的类型描述符之间的比较。）

  参数

  arrayType - 通常为 Object[] ，将收集参数的数组参数的类型

  结果

  一个新的方法句柄，它可以在调用原始方法句柄之前将任意数量的尾随参数收集到一个数组中

  异常

  NullPointerException - 如果 arrayType是空引用

  IllegalArgumentException - 如果 arrayType不是数组类型或 arrayType无法分配给此方法句柄的尾随参数类型

  另请参见：

  asCollector(java.lang.Class<?>, int) ， isVarargsCollector() ， withVarargs(boolean) ， asFixedArity()

• isVarargsCollector

  public boolean isVarargsCollector()

  确定此方法句柄是否支持variable arity调用。 此类方法句柄来自以下来源：

  • 致电asVarargsCollector
  • 调用lookup method ，它解析为变量arity Java方法或构造函数
  • 一个ldc一个的指令CONSTANT_MethodHandle其解析为一个可变参数数量的Java方法或构造

  结果

  如果此方法句柄接受多个简单，不精确的 invoke调用，则 invoke

  另请参见：

  asVarargsCollector(java.lang.Class<?>) ， asFixedArity()

• asFixedArity

  public MethodHandle asFixedArity()

  创建一个固定的arity方法句柄，该句柄与当前方法句柄等效。

  如果当前方法句柄不是variable arity ，则返回当前方法句柄。 即使当前方法句柄不能是asVarargsCollector的有效输入， asVarargsCollector 。

  否则，生成的fixed-arity方法句柄与当前方法句柄具有相同的类型和行为，但isVarargsCollector将为false。 fixed-arity方法句柄可能（或可能不）是asVarargsCollector的先前参数。

  这是一个列表制作变量arity方法句柄的示例：

  
  MethodHandle asListVar = publicLookup()
    .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class))
    .asVarargsCollector(Object[].class);
  MethodHandle asListFix = asListVar.asFixedArity();
  assertEquals("[1]", asListVar.invoke(1).toString());
  Exception caught = null;
  try { asListFix.invoke((Object)1); }
  catch (Exception ex) { caught = ex; }
  assert(caught instanceof ClassCastException);
  assertEquals("[two, too]", asListVar.invoke("two", "too").toString());
  try { asListFix.invoke("two", "too"); }
  catch (Exception ex) { caught = ex; }
  assert(caught instanceof WrongMethodTypeException);
  Object[] argv = { "three", "thee", "tee" };
  assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString());
  assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString());
  assertEquals(1, ((List) asListVar.invoke((Object)argv)).size());
  assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());
   

  结果

  一个新方法句柄，只接受固定数量的参数

  另请参见：

  asVarargsCollector(java.lang.Class<?>) ， isVarargsCollector() ， withVarargs(boolean)

• bindTo

  public MethodHandle bindTo​(Object x)

  将值x绑定到方法句柄的第一个参数，而不调用它。 新方法句柄通过将当前方法句柄绑定到给定参数来将其作为其目标进行调整。 绑定句柄的类型将与目标的类型相同，除了将省略单个前导引用参数。

  调用时，绑定句柄将给定值x作为目标的新前导参数插入。 其他参数也保持不变。 目标最终返回的内容由绑定句柄返回。

  参考x必须可转换为目标的第一个参数类型。

  注意：因为方法句柄是不可变的，所以目标方法句柄保留其原始类型和行为。

  注意：生成的适配器永远不会是variable-arity method handle ，即使原始目标方法句柄是。

  参数

  x - 要绑定到目标的第一个参数的值

  结果

  一个新的方法句柄，它在调用原始方法句柄之前将给定值预先添加到传入的参数列表中

  异常

  IllegalArgumentException - 如果目标没有作为引用类型的前导参数类型

  ClassCastException - 如果 x无法转换为目标的前导参数类型

  另请参见：

  MethodHandles.insertArguments(java.lang.invoke.MethodHandle, int, java.lang.Object...)

• toString

  public String toString()

  返回方法句柄的字符串表示形式，从字符串"MethodHandle"开始，以方法句柄类型的字符串表示形式结束。 换句话说，此方法返回一个等于值的字符串：

  
   "MethodHandle" + type().toString()
   

  （ 注意：此API的未来版本可能会向字符串表示添加更多信息。因此，应用程序不应解析当前语法。）

  重写：

  toString在类 Object

  结果

  方法句柄的字符串表示形式