关于泛型的应用

完成一个数组操作类,其中可以加入任意类型的数据,具体操作类型由外部决定

我编写的代码如下:

class Array<T>
{
	private T array[];
	public Array(T var[])
	{
		setVar(var);
	}
	public void setVar(T var[])
	{
		this.array=var;
	}
	public T[] getVar()
	{
		return this.array;
	}
}
class Check<V>
{
	private Array ar=null;
	public Check(Array ar)
	{
		this.ar =ar;
	}
	public  int checkArray(V mycheck)
	{
		int pos = -1;
		for(int i=0;i<ar.getVar().length;i++)
		{
			if(ar.getVar()[i].equals(mycheck))
			{
				pos=i;
			}
		}
		return pos;	
	}
	public  void print(int pos)
	{
		if(pos==-1)
			System.out.println("抱歉没有找到!");
		else
			System.out.println("已经找到了:"+ar.getVar()[pos]+"他在:"+pos+"位置处");
		
	}
}
public class override
{
	public static void  main(String args[])
	{
		Float array1[] = {30.1f,20.3f,20.0f,48.0f};
		Double array2[] = {30.2,30.4,28.0,19.0};
		Integer array3[] = {12,13,15,18,21};
		Array<Float> A1 = new Array<Float>(array1);
		Array<Double> A2 = new Array<Double>(array2);
		Array<Integer> A3 = new Array<Integer>(array3);
		Check<Float> ck = new Check<Float>(A1);
		Check ck1 = new Check(A2);//这里隐式调用会出现警告不影响使用
		Check<Integer> ck2 = new Check<Integer>(A3);
		ck.print(ck.checkArray(new Float(30.1f)));
		ck1.print(ck1.checkArray(new Double(19.0)));
		ck2.print(ck2.checkArray(new Integer(15)));
	}
}

代码执行结果:

已经找到了:30.1他在:0位置处
已经找到了:19.0他在:3位置处
已经找到了:15他在:2位置处

为什么不直接在类里面定义泛型数组呢? 原因是JAVA并不支持泛型数组的定义,看如下代码(转载)

List<String>[] ls = new ArrayList<String>[10];//此段代码不支持

List<String>[] ls = new ArrayList[10]//这段代码编译通过了

这是为什么呢?

然而根据Sun的一篇文档，里面提到了一种情况：

List<String>[] lsa = new List<String>[10]; // Not really allowed.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // Unsound, but passes run time store check
String s = lsa[1].get(0); // Run-time error: ClassCastException.

这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList<Integer>而不会出现ArrayStoreException，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。

基于以上的原因，Java不支持声明泛型数组，更确切地表达是：数组的类型不可以是类型变量，除非是采用通配符的方式，看下面这个例子：

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // Correct.
String s = (String) lsa[1].get(0); // Run time error, but cast is explicit.

因为对于通配符的方式，最后取出数据是要做显式的类型转换的，所以并不会存在上一个例子的问题。