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<?>