java泛型与数组

① java 泛型 和 数组问题

public class myclass
{
pubillc list<student> students;
}

call:
list<myclass> cls=new list<myclass>
myclass cl=new ...;
cl.students.add(new student());
....
cls.add( cl);

② java中关于泛型与数组的疑问

public static void main(String[] args) {

// 不能使用泛型数组

// Cannot create a generic array of List<String>

//List<String>[] lists = new List<String>[10];

// 但是你可以使用集合数组, 如果你非要这样做的话

List[] test2 = new List[10];

// 我不确定你这样做的动机是什么, 如果非要使用到泛型集合数组的话, 也可以这样

// Key: 索引

// Value: 泛型集合

// 缺点: 索引需要自己维护

Map<Integer, List<String>> collectionArray = new LinkedHashMap<Integer, List<String>>();

}

③ 北大青鸟java培训：JAVA泛型浅谈

1.概述在引入泛型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。
java课程http://www.kmbdqn.cn/发现引入范型后，一个复杂类型就可以在细分成更多的类型。
例如原先的类型List，现在在细分成List<Object>,List<String>等更多的类型。
注意，现在List<Object>,List<String>是两种不同的类型，他们之间没有继承关系，即使String继承了Object。
2.定义&使用类型参数的命名风格为：推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。
最好避免小写字母，这使它和其他的普通的形式参数很容易被区分开来。
使用T代表类型，无论何时都没有比这更具体的类型来区分它。
这经常见于泛型方法。
如果有多个类型参数，我们可能使用字母表中T的临近的字母，比如S。
如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混淆。
对内部类也是同样。
2.1定义带类型参数的类在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，就像使用普通的类型一样。
注意，父类定义的类型参数不能被子类继承。
2.2定义待类型参数方法在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。

④ Java中定义了泛型，不就是和数组没区别了吗

泛型和数组怎么了？我觉得你这问题好像没睡醒问的，恩，你去好好看看吧。

⑤ 为什么Java不支持泛型类型的数组

首先看一下Java中的泛型做了什么。看下面这段代码：

上面的代码中，最后一行是重点。根据本文第一部分的介绍，“Stringvalue=ref.getValue()”会被替换成“Stringvalue=(String)ref.getValue()”。当然我们知道，ref实际上是指向一个存储着StringBuffer对象的GenTest对象。所以，编译器生成出来的代码是隐含着错误的，在运的时候就会抛出ClassCastException。

但是，如果没有“Stringvalue=ref.getValue();”这行代码，那么程序可以说没有任何错误。这全都是Java中多态的功劳。我们来分析一下，对于上面代码中创建出来的GenTest对象，其实无论value引用实际指向的是什么对象，对于类中的代码来说都是没有任何影响的——因为在GenTest类中，这个对象仅仅会被当作是基类型的对象（在这里也就是Object的对象）来使用。所以，无论是String的对象，还是StringBuffer的对象，都不可能引发任何问题。举例来说，如果调用valued的hashcode方法，那么，如果value指向的是String的对象，实际执行的就是String类中的hashcode方法，如果是StringBuffer的对象，那么实际执行的就是StringBuffer类中的hashcode方法。

从这里可以看出，即使支持泛型数组也不会带来什么灾难性的后果，最多就是可能引发ClassCastException。而且平心而论，这个还是程序员自己的错误，实在算不得是Java编译器的错误。

⑥ 数组和泛型的区别

数组是JAVA语言内置的数据类型，它是一个线性的序列，所以它可以快速的访问其他的元素。但是速度是要有代价的，当你创建了一个数组之后，它的容量就固定了，而且在其生命周期里是不能改变的。还有一点，JAVA里面的数组是会做边界检查的，所以当你越界访问时，会抛出RuntimeException，所以不用担心在C或C++因为不做边界检查而出现的问题了，当然边界检查是以牺牲效率为代价的。数组与其它容器类的区别体现在三个方面：效率、类型识别和可以持有primitives。
JAVA里面提供的其他容器还包括List，Set和Map。他们处理对象的时候就好像这些这些对象都没有自己的类型一样，容器将它所含的元素都看成是JAVA中所有类的根类Object类型的，这样我们只需创建一种容器，就能把所有的类型的对象全部放进去。但是当取出的时候，那就需要我们自己进行类型转换了，不过在JAVA Tiger版里面新引入了“泛型”的概念，结合容器类一起使用就可以解决类型转换的问题，关于“泛型”这就不详细讲解了。从上面的角度来看，这种做法很不错，但是就是苦了primitives，如果是常量的话，可以把primitive转换成wrapper类然后放进容器里面，如果是变量的话，那就只能放在你自己的类里了。与其他容器类相比，数组会在编译的时候作类型检查，从而防止你插入错误类型的对象，或者在提取对象的时候把对象的类型给搞错了，JAVA在编译和运行的时候都能阻止你将一个不恰当的消息传给对象。至于效率，数组无疑是要高于其他容器类的，因为有些容器类的实现就是基于数组的，比如ArrayList。不论从类型检查还是效率的角度来考虑，我们首选数组来作为容器都是没错的，但是数组的缺点就是功能太弱了，所以才会有容器类的出现。
要多说几句的就是，java.util包里面有一个Arrays类，它包括了一组可以用于数组的static的工具方法，其中最基本的是四个方法：用来比较两个数组是否相等的equals()；用来填充数组的fill()；用来对数组进行排序的sort()；以及用于在一个已经排序的数组中查找元素的binarySearch()。所有这些方法都对primitives和Object进行了重载。此外还有一个asList()方法，它接受一个数组，然后把它转成一个List容器。JAVA标准类库还提供了一个System.array()的静态方法，它能以较快的速度拷贝数组，对primitive和Object都进行了重载，但是注意当对Object数组进行拷贝时，进行的是浅拷贝(shallow )。

⑦ 泛型和数组以及Java是如何实现泛型的

要区分数组和泛型容器的功能，这里先要理解三个概念：协变性（covariance）、逆变性（contravariance）和无关性（invariant）。
若类A是类B的子类，则记作A ≦ B。设有变换f()，若：
当A ≦ B时，有f(A)≦ f(B)，则称变换f()具有协变性；

当A ≦ B时，有f(B)≦ f(A)，则称变换f()具有逆变性；

如果以上两者皆不成立，则称变换f()具有无关性。

在Java中，数组具有协变性，而泛型具有无关性，示例代码如下：
Object[] array = new String[10];

//编译错误
ArrayList<Object> list=new ArrayList<String>();

这两句代码，数组正常编译通过，而泛型抛出了编译期错误，应用之前提出的概念对代码进行分析，可知：
1、String ≦ Object
2、数组的变换可以表达为f(A)=A[]，通过之前的示例，可以得出下推论：

f(String) = String[] 以及 f(Object) = Object[];
4、通过代码验证，String[] ≦ Object[] 是成立的，由此可见，数组具有协变性。

⑧ JAVA怎么初始化泛型数组

首先由于Java泛型的实现，不可以使用如下的代码：

public class GenSet<E> {
private E a[];

public GenSet() {
a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
}
}

那么我们如何在保持类型安全的同时实现这一点？

我在Java论坛上看到了这样的解决方案：

import java.lang.reflect.Array;

class Stack<T> {
public Stack(Class<T> clazz, int capacity) {
array = (T[])Array.newInstance(clazz, capacity);
}

private final T[] array;
}

在这里，我们需要讨论"checked" and "unchecked"。

Checked：strong typing。GenSet明确知道它包含的对象类型（即它的构造函数是使用Class <E>参数显式调用的，当方法传递非类型E的参数时，方法将抛出异常。请参阅Collections.checkedCollection。

在这种情况，我们需要这样写：

public class GenSet<E> {

private E[] a;

public GenSet(Class<E> c, int s) {
// Use Array native method to create array
// of a type only known at run time
@SuppressWarnings("unchecked")
final E[] a = (E[]) Array.newInstance(c, s);
this.a = a;
}

E get(int i) {
return a[i];
}
}



Unchecked: weak typing。实际上没有对作为参数传递的任何对象进行类型检查。

在这种情况，我们需要这样写：

public class GenSet<E> {

private Object[] a;

public GenSet(int s) {
a = new Object[s];
}

E get(int i) {
@SuppressWarnings("unchecked")
final E e = (E) a[i];
return e;
}
}

请注意，数组的组件类型应该是类型参数的擦除：

public class GenSet<E extends Foo> { // E has an upper bound of Foo

private Foo[] a; // E erases to Foo, so use Foo[]

public GenSet(int s) {
a = new Foo[s];
}

...
}

所有的这些都源于Java中泛型一个的特性但也是一个weakness：它是使用擦除实现的，因此除非实施一些显式机制（type-checking），否则“泛型”类不知道它们在运行时创建的类型参数，故无法提供 type-safety。