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。