根據條件創建特定類型的數組

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());一樣調用它method(arrayWrapper.getArray()); 並將其轉換為特定類型並由特定類型的處理器處理？

Answer 1

java.lang.reflect.Array類提供了用於處理任何類型的數組的功能，而無需知道它是什么類型。

使用該類，您可以編寫如下代碼：

public void example(Class<?> elemType) {
    Object[] arr = (Object[]) Array.newInstance(elemType, 10);

    // Do something with the array
}

（如果您希望能夠使用基本類型的數組，請不要轉換為Object[] 。）

Array是反射系統的一部分。 這意味着您將必須使用Class對象作為元素類型，並且可能具有Object類型的變量來引用元素值。

Answer 2

可以將Java泛型與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;
}

另請參閱： 如何在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>的行為最像數組）而不是數組。

對我來說，如果您需要根據數組的（運行時）類型使用不同的邏輯（“處理器”），這似乎是一個設計缺陷。