深入分析Java反射(二)-数组和枚举

本文主要介绍反射中可能用到的两个比较特殊的类型，数组和枚举，分别对应 java.lang.reflect.Array 和 java.lang.Enum ，后者其实并不是反射类库包中的类，但是反射的基础类库里面有使用枚举类型的方法。

使用非反射方式创建数组实例的过程如下：

fully_qualified_class_name[] variable_name  = {val1，val2，val3，...};

fully_qualified_class_name[] variable_name = new fully_qualified_class_name[${fix_length}];

例如：int[] arr = new int[10];

使用反射方式就是使用 java.lang.reflect.Array 中的相关方法：

Class<?> c = Class.forName(cName);
Object o = Array.newInstance(c, n);
for (int i = 0; i < n; i++) {
    String v = cVals[i];
    Constructor ctor = c.getConstructor(String.class);
    Object val = ctor.newInstance(v);
    Array.set(o, i, val);
}
Object[] oo = (Object[]) o;

下面列举一下 java.lang.reflect.Array 中的方法：

这里省略了一部分对于 Int 、 Boolean 等原始类型的Setter和Getter方法。

在 java.lang.Class 和数组相关的方法：

这里举个例子加深下印象：

public class ArrayCreationMain {

	/**
	 * 这个是我们创建的最终目标数组
	 */
	private static String R = "java.math.BigInteger[] bi = {123,234,345}";
	private static final String[] S = new String[]{"123", "234", "345"};

	public static void main(String[] args) throws Exception {
		Class<BigInteger> componentType = BigInteger.class;
		Object arrayObject = Array.newInstance(componentType, 3);
		for (int i = 0; i < S.length; i++) {
			String each = S[i];
			Constructor<BigInteger> constructor = componentType.getConstructor(String.class);
			BigInteger value = constructor.newInstance(each);
			Array.set(arrayObject, i, value);
		}
		Object[] result = (Object[]) arrayObject;
		System.out.println(String.format("%s[] = %s", componentType, Arrays.toString(result)));
		int length = Array.getLength(arrayObject);
		System.out.println("Length = " + length);
		for (int i = 0; i < length; i++) {
			System.out.println(String.format("index = %d,value = %s", i, Array.get(arrayObject, i)));
		}
		Class<?> arrayObjectClass = arrayObject.getClass();
		System.out.println("Is array type:" + arrayObjectClass.isArray());
		System.out.println("Component type:" + arrayObjectClass.getComponentType());
	}
}

运行后输出：

class java.math.BigInteger[] = [123, 234, 345]
Length = 3
index = 0,value = 123
index = 1,value = 234
index = 2,value = 345
Is array type:true
Component type:class




    
 java.math.BigInteger

需要注意的是， java.lang.reflect.Array 中的Setter和Getter方法如果越界操作数组元素，会抛出 ArrayIndexOutOfBoundsException ，通过Setter设置和数组初始化时候的组件类型不一致的元素会抛出 IllegalArgumentException 。

创建特定元素类型的数组：

因为Java泛型擦除的问题，实际上我们使用 Array#newInstance 方法只能得到一个Object类型的结果实例，其实这个结果实例的类型就是 ComponentType[] ，这里只是返回了它的父类(Object)类型实例，因此我们可以直接强转，例如：

String[] strArray = (String[]) Array.newInstance(String.class, 3);

获取数组类型：

在非反射方式下，我们可以通过 数组实例.class 通过class字面量直接获取数组类型，例如：

Class stringArrayClass = String[].class;

反射条件下，可以通过 Class.forName() 获取数组类型，但是调用此方法的时候有个限制，类名必须使用JVM可以识别的签名形式，就是 [L${ComponentType}; ，注意 Class.forName() 无法获取原始类型(如int、boolean)的类型，例如：

// 不能漏了左边的[L和右边的;
Class stringArrayClass = Class.forName("[Ljava.lang.String;");

// 下面这样做会抛出ClassNotFoundException
Class intClass1 = Class.forName("I");
Class intClass2 = Class.forName("int");

获取数组元素(组件)类型：

目前获取数组组件类型只能通过数组类型实例去调用 Class#getComponentType() 。

因为枚举就是普通的Java类，因此反射相关类库中并没有添加一个 java.lang.reflect.Enum 类型，反射中的API和枚举相关的有：

如果实例中的成员属性为枚举，那么枚举的反射操作实际上就是 java.lang.reflect.Field 的相关操作。

举个例子：

public class EnumerationMain {

	enum Color {
		RED, BLACK, BLUE
	}

	public static class ColorHolder {

		private Color color = Color.BLACK;

	}

	public static void main(String[] args) throws Exception {
		Class<Color> colorClass = Color.class;
		System.out.println("Color class is enum:" + colorClass.isEnum());
		System.out.println("Color values:" + Arrays.toString(colorClass.getEnumConstants()));
		ColorHolder colorHolder = new ColorHolder();
		Class<ColorHolder> holderClass = ColorHolder.class;
		Field field = holderClass.getDeclaredField("color");
		field.setAccessible(true);
		System.out.println("Old color:" + field.get(colorHolder));
		field.set(colorHolder, Color.RED);
		System.out.println("New color:" + field.get(colorHolder));
	}
}

运行后输出：

Color class is enum:true
Color values:[RED, BLACK, BLUE]
Old color:BLACK
New color:RED

之前写过一篇文章《JDK中枚举的底层实现》，从枚举类的字节码翻译出类的代码逻辑，这里翻出来那个例子(手机操作系统枚举)说一下：

public enum PhoneOsEnum {

	/**
	 * 安卓
	 */
	ANDROID(1, "android"),

	/**
	 * ios
	 */
	IOS(2, "ios");


	private final Integer type;
	private final String typeName;

	PhoneOsEnum(Integer type, String typeName) {
		this.type = type;
		this.typeName = typeName;
	}

	public Integer getType() {
		return type;
	}

	public String getTypeName() {
		return typeName;
	}
}

这个是我们使用Java的关于枚举的语法创建出来的枚举类型，是编译前我们看到的Java类文件，实际上，编译完成之后，枚举类型会变成一个普通的Java类，它有以下特点：

也就是上面提到的 PhoneOsEnum 在编译完成之后会变成：