Question

我有一个enum类型的开关盒，具体取决于我要创建的数组。看起来像：

switch (type) {
    case BOOLEAN:
        Boolean[] booleans = new Boolean[];
    case STRING:
        String[] strings = new String[];
}

我想知道是否有可能将其提取为某种方法，使其工作方式类似于：

ArrayWrapper arrayWrapper = // some logic for which I am looking for

然后我有一个通用方法可以接受任何类型的数组，我想像这样调用它 method(arrayWrapper.getArray());并将其转换为特定类型并由特定类型处理器处理？

Answer 1

java.lang.reflect.Array类提供了用于处理任何类型的数组的功能，而无需知道它是什么类型。

使用该类，您可以编写如下代码：

SELECT CASE WHEN 0x30783031 = '0x01' THEN 1 ELSE 0 END;

（如果您希望能够使用基本类型的数组，请不要转换为public void example(Class<?> elemType) { Object[] arr = (Object[]) Array.newInstance(elemType, 10); // Do something with the array }。）

Object[]是反射系统的一部分。这意味着您将必须使用Array对象作为元素类型，并且可能具有Class类型的变量来引用元素值。

Answer 2

可以将

Java Generics与Reflection API结合使用以获得T[]的实例：

@SuppressWarnings("unchecked")
public static <T> T[] createArrayInstance(Class<T> clazz, int size) {
    return (T[])Array.newInstance(clazz, size);
}

如果出于任何原因要在结果数组中存储一个值：

@SuppressWarnings("unchecked")
public static <T> T[] createArrayInstance(T obj) {
    T[] a = (T[])Array.newInstance(obj.getClass(), 1);//or whatever size you want
    a[0] = obj;
    return a;
}

另请参阅：How to create a generic array in Java?

Answer 3

一种可能的方法是将数组的元素类型绑定到通用类型参数，并尽早将处理器和数组绑定在一起：

public class ArrayProcessingWrapper<T> {
  private final T[] array;
  private final ArrayProcessor<T> processor;

  public ArrayProcessingWrapper(T[] array, ArrayProcessor<T> processor) {
    super();
    this.array = array;
    this.processor = processor;
  }

  public void processArray() {
    this.processor.process(this.array);
  }

}

另一种方法可能是遵循功能

public abstract class Processor<T> {
  private final Supplier<T[]> arraySupplier;

  public Processor(final Supplier<T[]> arraySupplier) {
    super();
    this.arraySupplier = arraySupplier;
  }

  public T[] createArray() {
    return this.arraySupplier.get();
  }

  public void processNewArray() {
    this.doProcess(this.createArray());
  }

  protected abstract void doProcess(T[] data);
}

public class BooleanProcessor extends Processor<Boolean> {
  public BooleanProcessor(Supplier<Boolean[]> arraySupplier) {
    super(arraySupplier);
  }

  @Override
  protected void doProcess(Boolean[] data) {
    // Do fancy boolean stuff...
  }
}

但也请查看Iterable<E>和/或Collection<E>（其中ArrayList<E>的行为最像数组）而不是数组。

在我看来，如果您需要根据数组的（运行时）类型使用不同的逻辑（“处理器”），这似乎是一个设计缺陷。

根据条件创建特定类型的数组

3 个答案: