java.lang.reflect.Array.newInstance与list.toArray

 

一．

import java.util.ArrayList;  
import java.util.List;  
public class Test {  
    public static void main(String[] args) {  
          
        List list = new ArrayList();   
        list.add("1");   
        list.add("2");   
        String[] tt =(String[]) list.toArray(new String[0]);   
    }  
}

  

这段代码是没问题的，但我们看到String[] tt =(String[]) list.toArray(new String[0]) 中的参数很奇怪，然而去掉这个参 数new String[0]却在运行时报错。。。

 

二．经研究发现toArray有两个方法：

public Object[] toArray() {  
   Object[] result = new Object[size];     
   System.arraycopy(elementData, 0, result, 0, size);     
   return result;  
}  

 

不带参数的toArray方法，是构造的一个Object数组， 然后进行数据拷贝，此时进行转型就会产生ClassCastException，这也就是上述问题的root cause了。

  

public Object[] toArray(Object a[]) {     
	if (a.length < size)         
		a = (Object[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
	
	System.arraycopy(elementData, 0, a, 0, size);     
	if (a.length > size)         
		a[size] = null;     
	return a;  
}

 

而带参数的toArray方法，则是根据参数数组的类型，构造了一个对应类型的，长度跟ArrayList的size一致的空数组，虽然方法本身还是以 Object数组的形式返回结果，不过由于构造数组使用的ComponentType跟需要转型的ComponentType一致，就不会产生转型异常。

 

①不带参数的toArray方法，是构造的一个Object数组，然后进行数据拷贝，此时进行转型就会产生ClassCastException 

②带参数的toArray方法，则是根据参数数组的类型，构造了一个对应类型的，长度跟ArrayList的size一致的空数组，虽然方法本身还是以 Object数组的形式返回结果，不过由于构造数组使用的ComponentType跟需要转型的ComponentType一致，就不会产生转型异常

 

三．因此在使用toArray的时候可以参考以下方式

1. Long[] l = (Long[]) list.toArray(new Long[0]);

 

2. Long[] a = new Long[];

   Long[] l = (Long[]) list.toArray(a);

 

四．该容器中的元素已经用泛型限制了，那里面的元素就应该被当作泛型类型的来看了，然而在目前的java中却不是的，当直接String[] tt =(String[]) list.toArray()时，运行报错。回想一下，应该是java中的强制类型转换只是针对单个对象的，想要偷懒，将整个数组转换成另外一种类型的数 组是不行的，这和数组初始化时需要一个个来也是类似的。

 

 java.lang.reflect.Array.newInstance

 

1、java.lang.reflect.Array 类提供了动态创建和访问数组元素的各种静态方法。

如下例子创建了一个长度为10 的字符串数组，接着把索引位置为5 的元素设为“hello”，然后再读取索引位置为5 的元素的值

import java.lang.reflect.Array;   
  
public class ArrayTest {   
  
    public static void main(String[] args) throws Exception {   
           
        Class clazz = Class.forName("java.lang.String");   
           
        //创建一个长度为10的字符串数组，在Java中数组也可以作为Object对象   
        Object array = Array.newInstance(clazz, 10);   
           
        //把字符串数组对象的索引位置为5的元素设置为"hello"   
        Array.set(array, 5, "hello");   
           
        //获得字符串数组对象的索引位置为5的元素的值   
        String str = (String)Array.get(array, 5);   
        System.out.println(str);//hello   
    }  
  
}  

 

2、Java中动态修改数组(Array)的大小

 

private static Object resizeArray (Object oldArray, int newSize) {

	int oldSize = java.lang.reflect.Array.getLength(oldArray);
	
	Class elementType = oldArray.getClass().getComponentType();
	
	Object newArray = java.lang.reflect.Array.newInstance(
			elementType,newSize);
		
	int preserveLength = Math.min(oldSize,newSize);
	if (preserveLength > 0)
		System.arraycopy (oldArray,0,newArray,0,preserveLength);
		
	return newArray; 
}

 int oldSize = java.lang.reflect.Array.getLength(oldArray); //获取数组oldArray的长度 

 

Class elementType = oldArray.getClass().getComponentType(); //获取数组oldArray的元素类型 是字符串 整数 还是其他类的。得到的结果是一个class

 

Object newArray = java.lang.reflect.Array.newInstance(elementType,newSize); //实例一个新的数组 类型和oldArray的一样 长度参数传入的newSize

 

int preserveLength = Math.min(oldSize,newSize);   //得到新数组newArray 和oldArray两个中长度最短的，并把长度返回给preserveLength

之所以这么实现是因为考虑到复制所有类型的数组，所以把数组向上转型成Object了。

 

 

public static void main (String[] args) {
   int[] a = {1,2,3};
   a = (int[])resizeArray(a,5);
   a[3] = 4;
   a[4] = 5;
   for (int i=0; i

 

3、

package com.test;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayUtils {

	public static  T[] newArrayByArrayClass(Class clazz, int length) {  
		return (T[]) Array.newInstance(clazz.getComponentType(), length);  
	}  

	public static  T[] newArrayByClass(Class clazz, int length) {  
		return (T[]) Array.newInstance(clazz, length);  
	}  

	public static void main(String[] args) {  
		My[] byTwo = null;
		byTwo = newArrayByClass(My.class, 10);//第一种方法
		for(int i = 0;i < 10; i ++){
			//byTwo[i]=new My();
			try {
				byTwo[i]=My.class.newInstance();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
			byTwo[i].aaa =i;
		}
		System.out.println("byTwo:" + byTwo);
		
		
		My[] byOne =null; 
		byOne = newArrayByArrayClass(My[].class, 10);//第二种方法
		for(int i = 0;i < 10; i ++){
			//byOne[i]=new My();
			try {
				byOne[i]=My.class.newInstance();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
			byOne[i].aaa =i;
		}
		System.out.println("byOne:" + byOne);
		
		
		String[] sArr = newArrayByClass(String.class, 10);
		for(int i = 0;i < 10; i ++){
			sArr[i] =String.valueOf(i);
		}
		Array.set(sArr, 1, "test");
		System.out.println(Arrays.toString(sArr));
		//[0, test, 2, 3, 4, 5, 6, 7, 8, 9]
		
	}  	
}

class My 
{
	public int aaa;
	public My(){}
}

 。。