java泛型嵌套

⑴ java遍歷集合的時候，怎麼看泛型

你這么寫肯定不對,你這個屬於集合嵌套,等價你list集合裡面存放的Map集合!

你第一次遍歷的時候拿出來是Map集合,

你需要在迭代一次,這次要迭代Map集合,記得要取出Map集合的Key,因為Map沒有迭代器!

也就是說,你需要嵌套迭代,算了我給你截圖下..

⑵ java 泛型類裡面可以嵌套泛型類嗎

這個你可以試驗嘛，真的有必要這樣嵌套么？我覺得沒有這個必要，當然你外部的泛型類可以提供2個參數，其中一個是給裡面的泛型類用的，不過我沒有試過，不知道可以不。等你答案哦，實踐出真知嘛，你有需求就有動力去做實驗嘛。

⑶ 如何理解java泛型嵌套泛型

嵌套什麼的其實無所謂
泛型就是強制規定集合內所存儲的數據類型，其他類型的數據是存不進去的

⑷ public static List<ArrayList<ArrayList<Double>>> 在Java中定義這個是什麼意思可以詳細的解釋下嗎

<>代表泛型，先不看泛型應該很好理解，就是一個靜態list，
有泛型就約束這個List的成員必須是ArrayList類型的，
這樣層層嵌套，就是定義一個靜態List ,它的成員都必須是ArrayList類型且ArrayList裡面的成員都是Double類型成員組成的ArrayList,
你這嵌套的的也太多層了，一般兩層都可以了

⑸ c#和java的不同是什麼

.NET(C#) Java
基本類型 基本類型
C#中有無符號數，Java沒有。

C#中有值類型，且可自己定義值類型的結構體(struct)。
Java中的基本類型(或叫基元類型)即為值類型，但Java沒有結構體，所以不能自定義值類型。
C#中的值類型（包括所有基本類型）間接繼承自Object，有自己的方法可以調用；Java中的值類型（即基本類型）不繼承自Object，只是簡單的數據，沒有方法可以調用。

C#中int等同於System.Int32，是值類型；bool等同於System.Boolean；等。
Java中int是基本類型，是值類型，而Integer是引用類型，Integer是int的包裝器，int自身沒有方法，Integer有一些方法；int與Integer之間可隱式轉換（導致裝箱和拆箱），但當Integer值為null的時候會在運行時拋出異常。boolean等類似。

Java中的int與Integer的對應在C#中類似int和Nullable<int>的對應，它們的後者都是前者的包裝，且後者可以等於null。但Nullable<int>實際上仍然是值類型的(所以仍然很輕量級)，所以從內存上講C#中int和Object的對應更接近Java的對應一些。C#中Nullable<int>到int的轉換必須顯式進行，因為Nullable<int>中的值為null時會引發運行時異常。
其他基本類型與之類似。

委託,事件

[無]

C#中的委託可以認為是方法的類型化，於是可以將方法放在變數里傳遞。事件是對委託做了一層包裝。
Java通過介面來實現C#中委託和事件的功能，可通過匿名類來達到C#中匿名委託的作用（同樣也能實現閉包的功能）。
另，C#中也有匿名類，但C#和Java的匿名類剛好各做各的事情：Java中的匿名類只有方法沒有數據；C#中的匿名類只有數據沒有方法。

非託管

[無]

C#可以有非託管代碼，可以有指針等。Java沒有。

索引器

[無]

C#有索引器，可方便容器類實現類似數組的效果。Java沒有，Java的容器基本上用put,get,set等方法達到同樣效果。

屬性

[無]

C#的屬性通過在內部定義get/set方法，使外部使用時像是在使用變數欄位，但其實是在調用get/set方法，以達到透明的封裝數據的目的。
Java沒有屬性的概念。Java通過約定為欄位XX添加getXX,setXX方法達到同樣的目的。

預編譯指令

[無]

C#有預編譯指令可方便調試，且有ConditionalAttribute來描述方法。Java沒有。

操作符重載

[無]

C#可重載操作符。Java沒有。

Java自己重載了String的+和+=，但沒有重載==，這是我這段時間犯的最多的錯誤。C#中String的==是比較值相等，Java中==是Object的默認行為：比較引用相等，要比較值相等得用equals方法。（這么多年編程以來，我似乎從來沒有遇到過要比較兩個字元串變數的引用相等。對於比較值相等來講，==符號比equals方法調用看上去優雅得多，況且方法調用還得注意空指針的情況）

內部類 內部類
Java的內部類可以直接訪問外部類的實例成員。
C#的不行。C#的內部類等同於Java的靜態內部類。

goto、switch [goto]、switch
C#允許用goto。Java的goto是保留關鍵字，不能使用。但Java允許有標簽，在有嵌套循環時可以在continue、break後面跟標簽名。

C#的switch可以使用long、String；Java不可以。

Java的switch中的case子句在後面沒有跟break的情況下直接跳到下一個case子句；
C#中只有在前一個case沒有任何代碼的情況下才允許不寫break直接跳到下一個case，C#中可以通過goto跳轉到另一case。

enum enum
C#中的枚舉是值類型，且其基於數值類型（默認基於int），可設置枚舉項對應的數字，不能在其中添加方法等任何其他成員。
Java中的枚舉是引用類型（Java除了基本類型外，任何類型都是引用類型），不是基於數值類型。除了不能繼承外，它跟普通類差別不大，可以添加成員方法和成員變數等（當然也就可以重寫toString方法）。

C#和Java的枚舉都可以用於switch。

可以將C#的枚舉作為數值看待而直接進行位運算，因此可以在一個變數中存儲多個位標記。
Java的枚舉跟數值沒有直接關系，因此不能直接這么用。Java用EnumSet來存儲枚舉標志，不需要直接使用位運算，更遠離底層。

override @Override
C#能被重寫的方法必須添加virtual關鍵字聲明為虛方法，派生類重寫子類方法時添加override關鍵字。
Java默認方法都可被重寫，派生類和子類方法簽名一樣時被認為是重寫。要聲明不能被重寫的方法需在方法前加final關鍵字。重寫時可以在方法前添加標注(即C#中的定製特性)@Override，這樣一旦此方法找不到被重寫的方法時編譯器會報錯，以防止拼寫錯誤。

定製特性 標注
C#用中括弧[]將定製特性括起來。Java用@打頭，後面跟定製特性的名字。

泛型 泛型
Java中泛型實現使用的擦除機制，為類型參數傳入類型並不導致新類型出現，即傳入了類型參數後在運行時仍然完全不知道類型參數的具體類型，它的目的是為了兼容非泛型（所以可以在泛型和非泛型之間隱式轉換，會有編譯警告但不會有編譯錯誤，這當然其實並不安全）；這同時衍生了一系列問題：不能定義泛型類型參數的數組如T[]，不能通過new T()的方式實例化泛型，等。
Java的泛型不支持值類型（使用的話會被自動包裝成引用類型）。

C#的泛型在類型參數傳入類型後會產生一個新類型(雖然CLR的優化機制會使引用類型共享同樣的代碼)，可以在運行時得到類型參數的類型信息。可以定義泛型數組，可以添加約束使其可以new。C#的泛型可以使用值類型(不會被裝箱)。

對於Java的泛型，簡單的講，它的好處只在編譯時，運行時沒有任何泛型的意義。當你在使用已有的泛型類時，這通常能滿足要求；但如果你要自己定義泛型類，那你得知道它有多少你覺得它應該可以但事實上不可以的事情。

參數引用傳遞 [無]
C#允許使用關鍵字out,ref顯式指定參數傳遞方式為引用傳遞。
Java只有值傳遞。

@字元串 [無]
C#在寫字元串時可以在引號前加個@符號來取消/的轉義作用。
Java沒有。

?? [無]
C#的??二元操作符當前面的表達式不為null時返回前面表達式的值，前面表達式為null時返回後面表達式的值。
Java沒有。

using import
C#可以用using為命名空間或類指定別名。（using還有Dispose的使用方式，與命名空間無關）
Java的import可以引入類或包(即C#的命名空間)，static import可以引入類的成員。

初始化 初始化
C#調用基類構造函數的語法為：
SubClass() : base() { }
Java調用基類構造函數的語法為：
SubClass(){
super();
}
C#和Java都可以用類似的語法調用同一個類的其他構造函數。（分別將base和super換成this）

Java有代碼塊概念，會在構造函數之前執行（基類的構造函數之後）。

在成員變數聲明時賦值，Java允許其賦值表達式中引用前面聲明的另一個變數，如：
private int x = 1;
private int y = x + 10;
這里變數y的賦值語句有變數x。
C#不允許這樣做。

interface interface
Java的介面內允許有內部類、靜態欄位等。
C#不允許。

readonly,const final
C#的const是絕對的常量，必須在聲明語句中同時賦值，只有數值、枚舉和String可以聲明為const。const的值會內聯到各個使用的地方。
C#的readonly表示變數在構造函數執行完之後是不能再變化的。它只約束變數本身，而無法約束變數引用(如果它是引用類型或者有成員是引用類型)的對象。

Java中的final(在約束變數的時候)看上去更像readonly。
但C#的readonly和const有個區別，readonly的int是不能作為switch的case語句的，const的可以。
而Java的final則是：有時候可以有時候不可以----編譯時可以得到明確值的可以，反之不可以。如：
final int x = 1; // 這個可以
final int y = new Random().nextInt(); // 這個不可以
那麼可以理解為：編譯時能得到明確值的時候，final等同於C#的const(不清楚Java在這個情況下是否會內聯，估計不會)；編譯時無法得到明確值的時候，final等同於C#的readonly。

[無] throws
Java在可能拋出異常時，除了RuntimeException(包括派生類)，都要麼捕獲，要麼在方法聲明中用throws關鍵字聲明出來表示繼續拋出。
C#沒有採用這種強制處理機制。

功能相同但語法有差異的
namespace == package (Java的package對文件結構也有要求；C#沒有)

internal == [默認] (Java中不寫訪問修飾符即表示訪問許可權是package；C#默認是private。C#的internal protected在Java中沒有。)

lock == synchronized (Java中synchronized可以修飾方法，C#可以用定製特性[MethodImplAttribute(MethodImplOptions.Synchronized)]達到同樣效果)

: == extends,implements

base == super

is == instanceof (C#有as，Java沒有)

typeof == .class

[SerializableAttribute]定製特性 == Serializable介面

[NonSerializedAttribute]定製特性 == transient

params == ... (可變數目參數)

⑹ java泛型之泛型通配符具體是什麼作用

Java中不允許嵌套泛型的內層通配符?匹配一個具體的類型，因為這可能破壞類型安全。
這樣做是可以的：
List<?> list = new ArrayList<Integer>();
而這樣做是不可以的：
List<List<?>> list = new ArrayList<List<Integer>>();

⑺ C#中不能繼承object類裡面的靜態方法

NET（C＃）的Java
基本類型基本類型
C＃，是否符號的數量，Java沒有。

C＃值類型，身體的結構（結構）可以定義自己的價值類型。
在Java基本類型（或稱為原始類型的）的值的類型，但Java是沒有的結構，所以你可以不輸入自定義值。
間接繼承自Object的值類型在C＃中（包括所有的基本類型），你可以調用該方法的Java值類型（基本類型）不繼承自Object，只是簡單的數據，也沒有辦法叫。

C＃int是為System.Int32，是值類型，布爾相當於System.Boolean。
Java int類型的基本類型是Integer類型的值是一個引用類型，整型包裝是一個整數，整數沒有自己的方法，整數某些方面之間的隱式轉換int和Integer（因裝箱和拆箱），但是當整型值是空的，在運行時拋出一個異常。布爾等。

Java的int和Integer相應的C＃類似，相應的其後者的包裝的詮釋和空的是前者，而後者可以為null。但是，可為空的其實還是值類型（它仍然是非常輕量級），所以從內存中說在C＃int和對象的對應更接近Java的對應一些。 C＃中的Nullable 的轉換為int必須是明確的，因為的可空是空的，將拋出一個運行時異常。
基本類型是相似的。

委託的事件

C＃委託可以被認為是一個方法的類型，因此該方法的變數傳遞。該事件的委託做了一層包裝。
Java的介面來實現C＃委託函數和事件，在C＃匿名類匿名委託，以達到（也實現截流的功能）。
另一個匿名的類，C＃，C＃和Java匿名類只是做不同的事情：Java中的匿名類沒有數據，匿名類在C＃中的數據是沒有辦法。

非託管

[]

?＃非託管代碼，你可以有一個指針。 Java則沒有。指數

[]

C＃索引方便的容器類的類似數組的效果。 Java不具備，Java容器基本上，得到，設置，和其他方法來達到同樣的效果。

財產

C＃屬性通過內部定義的get / set方法，外部使用，如在使用的變分詞但實際上，在調用get / set方法，以達到透明的包裝數據的目的。
Java並沒有屬性的概念。 Java的慣例領域XX getXX setXX的方式來達到同樣的目的。

預編譯指令

[無]

C＃預編譯指令，方便調試，並的ConditionalAttribute以描述的方法。 Java則沒有。

操作符重載，

[]

C＃可以重載運算符。 Java則沒有。

Java的重載字元串+ + =，但沒有重載==這是我犯了這個錯誤。 C＃字元串==等於的值，爪哇==是對象的默認行為：比較基準平等，平等的使用統計equals方法來比較值。 （編程，因為這么多年，我似乎從來沒有遇到一個參考比較兩個字元串變數都是平等的。==符號比equals方法比較值的要求平等的條件下看起來更優雅，而且，該方法調用都必須支付注意空指針）

內部類內部類
Java的內部類可以直接訪問外部類的實例成員。
C＃不會做。內部類，C＃等同於Java的靜態內部類。

跳轉，開關[返回]開關
C＃允許使用goto。 Java的轉移是一個保留關??鍵字，您不能使用。 Java允許標簽的嵌套循環能夠繼續下去，打破，後面的標簽名稱。

?＃開關可以長期使用，字元串，而Java不能。

Java的switch case子句後面沒有突破的情況下，直接跳轉到下一個case子句;
C＃中，只有以前的情況下寫的突破可以無需任何代碼直接跳轉到下一個的情況下，C＃跳轉到跳轉到另一種情況。

枚舉枚舉
C＃中的枚舉是一個值類型，數值類型（基於整數），您可以設置相應的數字列舉默認情況下，你不能添加一個方法任何其他成員。
Java的枚舉是一個引用類型（Java中除了基本類型的任何類型的引用類型），而不是基於對數字類型。除了沒有繼承它與一般的類差別不大，可以添加成員方法和成員變數（當然也可以重寫toString方法）。

?＃和Java枚舉可用於交換機。

C＃的枚舉直接位的計算數值看，這樣你就可以在一個變數標記存儲多個位。
Java的枚舉的值嗎？是沒有直接關系，因此不直接讓。 EnumSet的Java存儲枚舉標志，不需要直接使用位運算，遠離地下。

覆蓋@覆蓋
C＃添加虛擬關鍵字來聲明一個虛方法，派生類重寫子類方法，加上override關鍵字，必須被重寫。
Java默認的方法可以被重寫，派生類和子類的方法簽名一樣，正在改寫。宣布，該方法不能被重寫所需的方法之前final關鍵字。改寫前可以添加註釋的方法（在C＃中的自定義功能）@覆蓋，編譯器會抱怨，所以這種方法可以被重寫，以防止拼寫錯誤，找不到路。

自定義功能標記
C＃中括弧[]自定義功能封閉。 Java的開始@，其次是名稱的自定義功能。

通用通用
Java泛型使用擦除機制傳入的類型不會導致一個新的類型的類型參數傳入的類型參數在運行仍然不知道具體的類型的類型參數，其目的是與非通用（通用和非通用的隱式轉換之間的相容性，將是一個編譯器的警告，但會有一個編譯錯誤，當然，其實和實例化的泛型不安全的），這也產生了一系列的問題：不能定義一個數組的泛型類型參數，如T []不能為新的T（），等。
Java泛型不支持值類型（用於自動包裝成一個引用類型）。

C＃泛型類型參數傳遞的類型會產生一個新的運行時（CLR優化機制，使引用類型共享相同的代碼）的類型，類型參數的類型信息。可以定義一個泛型數組，你可以添加約束，因此，它可能是新的。 C＃泛型可以使用值類型（盒裝）。

對於Java泛型和簡單的，它的好處只有在編譯時，運行時，有沒有通用的意義。當您使用泛型類，這通常是能夠滿足要求，但如果你想定義一個泛型類，你必須知道它是多少，你覺得應該可以，但事實不能的事情。

[無]
?＃允許使用關鍵字，樓盤明確指定參數傳遞通過引用傳遞參數是按引用傳遞。
Java只按值傳遞。

@的字元串[]
C＃寫的字元串可以添加@符號前面的報價，取消/轉義角色。
Java沒有。

？ [無]
C＃？二元運算符的表面表達不返回到以前的表達式的值是空的，上面的表達式返回null後面的表達式的值的類型。
Java沒有。

採用進口
C＃可以使用指定的命名空間或別名。 （使用棄置使用過的，有沒有做的命名空間）
Java類或包的導入可以推出（C＃命名空間），靜態導入可以被引入到類的成員。初始化初始化

C＃調用基類的構造函數的語法如下：
子類（）：基地（）{}
Java調用基類的構造函數的語法是：
子類（）{
超（）;
}
C＃和Java可以使用被稱為同一類的構造函數的語法類似。 （分別基地和超級更換）
Java代碼塊的概念（基類的構造函數的構造函數之前將執行）。

成員變數聲明中分配，Java允許其賦值表達式引用了另一個變數的前面的語句，如：
私人int x = 1;
私人詮釋y = x + 10
變數y賦值語句的變數x。
C＃不允許這樣做。

介面介面
Java介面允許內部類，靜態欄位。
C＃是不允許的。 「

只讀，常量的最後
?＃的const絕對不變，分配必須是在同一個聲明語句，只有數字，枚舉和字元串可以被聲明為const。常量的值相關聯的每個使用的地方。
?＃只讀變數的構造函數之後執行，不能改變。唯一的約束變數本身，無法約束變數引用（如果它是一個引用類型或引用類型）的對象。

Java的最終（的約束變數）看起來更像是只讀的。
C＃只讀和常量之間是有區別的，只讀不能用一個switch case語句可以是const詮釋。
Java的final：有時可以有時不能----明確的價值，否則無法編譯時間。如：
最終詮釋x = 1; / /這可以
最終的詮釋y =新的隨機（）nextInt（）; / /這樣可以不
你可以理解為：編譯時明確的價值，最終相當於C＃常量（不知道Java的內聯，在這種情況下，預期不會）;編譯時不能得到一個明確的價值，最終相當於在C＃只讀。

[]拋出
Java可能拋出一個例外，除了是捕獲的RuntimeException（包括派生類）中的拋出關鍵字的方法聲明語句中走了出來說繼續拋出一個。
C＃不使用這種強制性的處理機制。

相同的功能，但是它的語法差異
命名空間==包（Java的包文件結構的要求，C＃）

內部，= [默認]（Java沒有寫訪問修飾符的訪問許可權包，C＃在預設情況下是私有的內部C＃Java中的protected）。

鎖==同步（Java中的同步方法， C＃可以自定義特徵[MethodImplAttribute（MethodImplOptions.Synchronized）]來達到同樣的效果）

：==延伸，並實現

基地==超級

是在（C＃，Java沒有）

typeof運算==== instanceof類

將SerializableAttribute自定義功能== Serializable介面

[NonSerializedAttribute]自定義功能==短暫的

＃== ... （可變數目的參數），

⑻ java map嵌套 問題急

經測試，你的代碼沒問題，不過你寫代碼的細節不是特別規范，很多時候不會那樣寫，先附上測試圖吧

在這我想指出你寫代碼的一些細節性問題，當然你寫的沒有錯，只是看著不舒服，可讀性比較差
HashMap<String,HashMap<String,String>>chuan=newHashMap<String,HashMap<String,String>>();
這句里邊應該有兩個細節性問題，第一、定義Map一般會這么寫Map<String,Object>map=HashMap<String,Object>();第二、其實這個已經寫在第一個里邊了，一般不會寫那麼復雜的泛型，泛型里可以定義Object，然後在外邊轉換就可以了，因為Object是所有類的父類。

⑼ Java8的forEach有哪些坑

結合自身的使用經歷，主要還是一些粗心問題，也建議各IDE插件或JDK自身能夠有一些語法上的智能檢測而不是運行時才做。
1、對當前集合使用forEach是不能在lambda表達式內對當前集合進行調整，這樣運行時會異常，編譯時不會異常。
2、在forEach中使用泛型集合時需要注意，如果是復合泛型或嵌套泛型可能會有問題，還是建議在使用時能夠明確類型。
如題主遇到別的坑還請回復大家一起總結學習！

⑽ 如何創建任意深度的Java中的嵌套數組

用List即可, 因為List是泛型, 也就是說可以無限的嵌套下去了
List<?>