温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
如果回憶有顏色,我想那應該是紫色的。紫色的回憶,如落花的心情,當落花如愁的時候,情也寂寥成無人可訴的衷腸。抓不住幸福的我,也只能任無法把握的思緒塗抹成紫色的期盼,在我漂過的地方留下天水相連的思念。你懂,對麼？於是回憶剪碎了我的憂傷,你站立成默讀的態勢,讓一切隨了遺憾,因為我不是那結著丁香愁怨的女子,而你也不是撐著油紙傘的詩人。
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(19015)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_094',
blogTitle:'JasperReports+iReport在eclipse中的使用 ',
blogAbstract:'
1）它可以PDF，HTML，XML等多种形式产生报表或动态报表，在新版本还支持CSV，XLS，RTF等格式的报表；
2）它按预定义的XML文档来组织数据，来源多（如：关系数据库，Java容器对象（collection，arrays）等）；
报表的填充过程：
先产生报表设计对象-&序列化该对象-&存储在磁盘或网络-&产生XML文件（表格数据）。
表单的设计过程就是用定义于XML文件中的Java表达式来实现报表的设计。
3）它带数据一致性验证；
4）报表引擎必须先接受数据（通过参数等多种形式）来产生报表，更多的是来自数据源，引擎直接接收用于填充表格的数据源对象，或者通过自身提供的JDBC连接对象来处理数据库的数据；',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:8,
publishTime:1,
permalink:'blog/static/',
commentCount:5,
mainCommentCount:5,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'如果回憶有顏色,我想那應該是紫色的。紫色的回憶,如落花的心情,當落花如愁的時候,情也寂寥成無人可訴的衷腸。抓不住幸福的我,也只能任無法把握的思緒塗抹成紫色的期盼,在我漂過的地方留下天水相連的思念。你懂,對麼？於是回憶剪碎了我的憂傷,你站立成默讀的態勢,讓一切隨了遺憾,因為我不是那結著丁香愁怨的女子,而你也不是撐著油紙傘的詩人。 ',
hmcon:'1',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}Eclipse问题 怎么map也不认_百度知道
Eclipse问题 怎么map也不认
类型 Map 不是通用的；不能使用参数 &String, String& 将它参数化
我有更好的答案
21、JDK1.5以上才可以使用泛型，所以检查当前项目配置的JDK是否正确、检查import进来的Map是否是java
用的是1.6导入也正常
hashmap就可以
采纳率：82%
Map&String,String& map = new hashMap&String,String&;
JDK 没有配置好，先检查设置
其他1条回答
为您推荐：
其他类似问题
eclipse的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。博客分类：
几年前当Java5还未正式发布的时候，看到过一些人写的介绍Tiger中的新特性，当时对我第一感觉冲击最大的就是泛型(generics)和注释(annotation)，因为它们直接影响了我们编码的语法习惯。
在后来的使用过程中，对于泛型一直没有特别深入的使用过，没有遇到那样的需求和场景。只需要了解Java中的泛型是编译期的，运行期被“擦拭”掉了；然后还有几种通配符的表示就足够了。
直到一天我在查看Java5中Enum的源代码时，发现它是这么定义的：
public abstract class Enum&E extends Enum&E&& implements Comparable&E&, Serializable {
这个类似递归结构的 Enum&E extends Enum&E&& 究竟表达什么意思？
随后我又看到了在Collections工具类中的max 方法：
怎么TMD还会有这么复杂的泛型表达式!?
（幸好的是这种情况在我们实际开发过程中不多见，甚至不应该见到，大概只有像JDK这种为了保留对老版本的兼容才会设计出这么复杂的泛型表达式出来。）
上面的问题，你可以通过： 来获取答案，中文版的在：
这篇泛型指南的文章，非常详细。
或许你看了上面的文章，依然心存疑虑。我下面的内容则是对这篇文档的一些补充（会和这篇文档有点重合）。
在回到我之前抛出的问题上：
public static void foo(List&? extends Number& l){
l.add(new Integer(2));
// 编译通过么？ Why ?
public static void bar(List&? super Number& l){
l.add(new Integer(2));
// 编译通过么？ Why ?
l.add(new Float(2));
这里主要说说 &? extends T& 和 &? super T& 这两种通配符对于方法参数的使用原则。
即 PECS 原则 (producser-extends, consumer-super)
或者也叫 Get and Put 原则
当没有使用通配符的情况下，我们定义一个方法：
public static &E& void test(List&E& l){
E e = l.get(0);
l.set(0, e);
我们从List中 get和set都没有问题，因为这个E 它的类型是某种明确的类型。
而当使用通配符时来描述参数时，就有些不同了。
我们先定义一下两种通配符：
&? extends E& 是 Upper Bound（上限） 的通配符
&? super E& 是 Lower Bound（下限） 的通配符
1) 当使用 Upper Bound 通配符时：
&?& 是 &? extends Object& 的简写。(关于&?&是否和&? extends Object&完全等价，在结束的时候来描述)
在eclipse里错误提示为： The method set(int, capture#2-of ?) in the type List&capture#2-of ?& is not applicable for the arguments (int, Object)
注： &capture#2-of ?& 是一个占位符，表示编译器对通配符的捕获，更多见：
set报错的原因是因为此时方法中的类型是不可具体化的(reified)，你可以传递一个String，Number，Book，等任何继承自Object的类作为List的参数类型给test方法，而list要求集合中的类型必须是一致的，set的时候没有办法保证set进去的数据类型是否和list中原本的类型一致，比如你传给test方法的是 List&Book&， 那么在方法中set进去一个Object显然类型就不一致了。
这也是通配符带来灵活性的同时所要付出的代价。
结论：使用了 &? extends E& 这样的通配符，test方法的参数list变成了只能get不能set（除了null） 或者不严谨的说它变成了只读参数了， 有些类似一个生产者，提供数据。
2) 当使用 Lower Bound 的通配符时：
public static void test(List&? super Number& list){
Number n = list.get(0);
// 编译错误
Object o = list.get(0);
list.set(0, new Object());
// 编译错误
list.set(0, new Long(0));
list.set(0, new Integer(0));
这时get只能get出最宽泛的父类型，即Object。
这时set的时候，必须是Number或Number的子类。
原因和上面的get类似。
结论： 使用了&? super E& 这种通配符，test方法的参数list的get受到了很大的制约，只能最宽泛的方式来获取list中的数据，相当于get只提供了数据最小级别的访问权限（想想，你可能原本是放进去了一个Book，却只能当作Object来访问）。
它更多适合于set的使用场景，像是一个消费者，主要用来消费数据。
上面便是对通配符的使用原则的说明，简单的说 PECS原则是指导我们在泛型方法中使用通配符的直接原则。参数作为生产者使用&? extends E&，作为消费者时使用&? super E& 。
那么说完了 PECS原则，我们再回过头来分析那两个复杂的泛型表达式是怎么含义
1) class Enum&E extends Enum&E&&
它确实是一个 “递归类型限制”(recursive type bound)
要说明白这个问题，我们要先明白2点：
a) Enum可以理解为一组同一类型的有限的数据集合；
b) Java对Enum中的数据类型要求必须也是枚举类型（即必须是继承Enum类的）。
对于 a) 我们先定义一个 Enum&T& 表明定义了T这种类型作为它内部的数据类型，这么看它就像个普通的集合。
再来根据b) 定义类型E，要求E必须是继承自 Enum&T&，便成了
&E extends Enum&T&&
实际上 E和T是一回事，它们是同一类型，所以它就是 &E extends Enum&E&&
暂停，可能我上面的表达不太合理可能会误人子弟，递归类型限制是有些抽象，它应该有严谨的数学描述，我想不清楚怎么表达，我先用另一个简单些例子来说明吧
public static &T extends Comparable&T&& T max(List&T& list)
这个方法用来获取list 中的最大值，它定义了一个 &T extends Comparable&T&& 的类型表达式
这个递归类型限制的表达式容易理解一些，
&T extends Comparable&T&& 表示的是：针对可以与自身进行比较的每个类型T。
或者说，每个实现了Comparable&T&接口的类型T，比如 String 实现了 Comparable&String& ， Long实现了Comparable&Long&等等
而Enum因为使用enum关键字的原因，让我们忽略了它底层的实现其实也是
class EnumSample extends Enum&EnumSample& 这一事实，
比如 我们定义了 BoundKind 这样的一个枚举：
public enum BoundKind{ }
编译器会转换为：
public final class BoundKind extends java.lang.Enum&BoundKind&
看到了，这和
String implements Comparable&String& 类似
这样我们套回到&E extends Enum&E&& 就是 &BoundKind extends Enum&BoundKind&&
这下好理解了， &E extends Enum&E&& 就直接按字面理解：每个继承自Enum&E&的类型E，比如 BoundKind 继承了 Enum&BoundKind&
通过与&T extends Comparable&T&&的对比，我们可以理解 &E extends Enum&E&&了。
那现在我们再回到Collections工具类中的max 方法：
我们先简化一下这个表达式，看看
&T extends Comparable&? super T&& 怎么理解？
既然 &T extends Comparable&T&& 我们都理解了，把Comparable&T& 改为
Comparable&? super T& 也没什么费解的
在《Java1.5 Generics Tutorial》一文中的解释是：
T 精确的(exactly)和自己能比较是不需要的。所需要的 是T能够和它的父类中的一个进行比较。
而《Effictive Java》第二版中对此是用 PECS原则来解释的：
下面是修改过的使用通配符类型的声明：
为了从初始声明中得到修改后的版本，要应用PECS转换两次，最直接的是运用到参数List。它产生T实例，因此将类型从List&T&改为List&? extends T&。（ok好理解）
。。。。。。
更灵活的是运用到类型参数T。最初T 被指定用来扩展Comparable&T&，但是T的comparable消费T实例（并产生表示顺序关系的整值）。因此，参数化类型Comparable&T&被有限制通配符类型Comparable&? super T&取代。comparable始终是消费者，因此使用时始终应该是Comparable&? super T& 优先于 Comparable&T&。
蓝色粗体的那句翻译的不好。还是看一下代码来理解吧：
public static &T extends Comparable&? super T&& T max(Collection&? extends T& coll) {
Iterator&? extends T& i = coll.iterator();
T candidate = i.next();
while (i.hasNext()) {
T next = i.next();
if (next.compareTo(candidate) & 0) // here comparaTo
candidate =
第5行，Bloch认为 next.compareTo(cand) 是一句消费操作，在消费一个candidate对象时，根据PECS原则，candidate的类型应该使用 &? super T& 来提高它的灵活性。
我觉得Bloch将第5行当作消费操作挺别扭的，我个人偏向《Java1.5 Generics Tutorial》中的解释。
但归根到底，都是降低限制，提高比较时的灵活性。
最后，我们再来完整的理解：&T extends Object & Comparable&? super T&&
就只是比 &T extends Comparable&? super T&& 多了一个限制(bounds)。
Object & Comparable&? super T& 是一个多限定(multiple bounds)的用法，
语法为： T1 & T2 … & Tn
一个有多个界限的类型的参数是所有界限中列出来的类型的子类。当多个界限被使用的时候，界限中的第一个类型被用作这个类型参数的erasure。
最终这个方法的返回值，按照第一个限定，擦拭为Object类型了。这是因为在以前版本中此方法就是返回的Object类型，需要兼容。
（此句话随口而说，验证发现有误，发现类型推导比较复杂，就不去理解了）
因为多限定（multiple bounds）的存在，泛型方法中又对应的增加了一个很不优雅的调用方式。下面用一段代码来说明:
public class GenericsTest {
static class Book {};
static class StoryBook extends Book implements Comparable&StoryBook& {
public int compareTo(StoryBook o) {
return 0; //FIXME
static class TechBook extends Book implements Comparable&TechBook& {
public int compareTo(TechBook o) {
return 0; //FIXME
public static &E& Set&E& merge(Set&? extends E& s1, Set&? extends E& s2) {
HashSet&E& newSet = new HashSet&E&(s1);
newSet.addAll(s2);
return newS
public static void main(String[] args) {
HashSet&StoryBook& s1 = new HashSet&StoryBook&();
HashSet&TechBook& s2 = new HashSet&TechBook&();
Set&Book& sb = merge(s1, s2); // 错误
// 需通过显式的类型参数(explicit type parameter)来告诉它要使用哪种类型
Set&Book& bs = GenericsTest.&Book&merge(s1,s2); //OK
Set&Comparable&?&& s = GenericsTest.&Comparable&?&&merge(s1,s2);
上面直接调用merge(s1,s2) 那行代码错误的提示信息：
Type mismatch: cannot convert from
Set&GenericsTest.Book&Comparable&?&& to Set&GenericsTest.Book&
这归于泛型的类型推导(type inference)，当无法推导出明确的类型时，就需要显式的描述，如上面代码中红色粗体字。
有关于 &?& 与 &? extends Object&是否是一回事
今天中午发现同事桌上有本《Java编程思想》第四版，随手翻了一下，发现泛型一章的介绍中，
有句描述：“UnboundedWildcards.java 展示了编译器处理List&?&和List&? Extends Object&时是不同的。”
这让我奇怪，查看了一下它的代码，主要因为是对于Raw类型的造型为泛型时的警告信息不同。
将一个Raw的ArrayList造型给 List&?& 没有问题，而给List&? Extends Object&却会有警告。
在网上查了一下，发现对于&?&与&? extends Object&是否等同，是有些不同意见的。
这个报告里，有两段代码反映了两者的不同：
public static void main(String[] args)
foo((List&? extends String&) customer ); //[1]
foo((List&? extends Object&) customer ); //[2] 编译有警告
foo((List&?&) customer ); //[3]
编译没有警告
public static void foo(List&?& list) {
Object o2 = new List&?&[3];
// 编译居然OK，估计直接当作Raw处理了
Object o3 = new List&? extends Object&[3]; // 报错
上面两段代码，表明了当与Raw类型造型时，&?&在编译器的处理方式的确与&? Extends Object&有所不同，根据场景它可能被编译器忽略掉泛型信息而直接当作Raw类型，而&? Extends Object&则不会。
但这种差异，有些吹毛求疵，除了跟Raw类型转换方面存在差异，在语义上两者可以认为是完全等同的，
The introduction of the capture conversion simplified a lot of things. One of the things it did is make "?" equivalent to "? extends Object".
Unfortunately, JLS3 doesn't say they are equivalent.
SUN的开发人员回复说：
? should be considered equivalent to ? extends Object. I will note this at the end of the text about bounds for wildcards in 4.5.1.
Hence, Foo&?& is semantically equivalent to Foo&? extends Object&
但查了一下发现目前 JLS3中还依然没有增加他说要加的那句注释，见：
我们暂从语义上认为两者相等。
浏览 13512
浏览: 52127 次
来自: 杭州
牛逼！！。。。。。。
这种问题原因千奇百怪，你总结的原因，没有普遍性
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'&&&&&&&&&&&&&&&&&&
posts - 113,comments - 263,trackbacks - 0
知识星球 连接一千位铁杆粉丝 下载App 知识星球提示：检测到你的环境有风险，请勿支付 努力加载中 请使用微信扫描二维码加入星球 知识星球 返现 ¥（仅限当前链接） 点此分享 点此分享 分享到朋友圈
随笔分类(160)
随笔档案(113)
文章分类(2)
文章档案(2)
Comprehensive
积分与排名
阅读排行榜
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
阅读(23087)
&re: Java8之Stream/Map[未登录]
总结的很详细！&&&&&&举例详解Java编程中HashMap的初始化以及遍历的方法
转载 & & 投稿：goldensun
这篇文章主要介绍了Java编程中HashMap的初始化以及遍历的方法,是Java入门学习中的基础知识,需要的朋友可以参考下
一、HashMap的初始化
1、HashMap 初始化的文艺写法
&& HashMap 是一种常用的数据结构，一般用来做数据字典或者 Hash 查找的容器。普通青年一般会这么初始化：
HashMap&String, String& map =
new HashMap&String, String&();
map.put("Name", "June");
map.put("QQ", "");
看完这段代码，很多人都会觉得这么写太啰嗦了，对此，文艺青年一般这么来了：
HashMap&String, String& map =
new HashMap&String, String&() {
put("Name", "June");
put("QQ", "");
&& 嗯，看起来优雅了不少，一步到位，一气呵成的赶脚。然后问题来了，有童鞋会问：纳尼？这里的双括号到底什么意思，什么用法呢？哈哈，其实很简单，看看下面的代码你就知道啥意思了。
public class Test {
/*private static HashMap& String, String& map = new HashMap& String, String&() {
put("Name", "June");
put("QQ", "");
public Test() {
System.out.println("Constructor called：构造器被调用");
System.out.println("Static block called：静态块被调用");
System.out.println("Instance initializer called：实例初始化块被调用");
public static void main(String[] args) {
new Test();
System.out.println("=======================");
new Test();
Static block called：静态块被调用
Instance initializer called：实例初始化被调用
Constructor called：构造器被调用
=======================
Instance initializer called：实例初始化被调用
Constructor called：构造器被调用
也就是说第一层括弧实际是定义了一个匿名内部类 (Anonymous Inner Class)，第二层括弧实际上是一个实例初始化块 (instance initializer block)，这个块在内部匿名类构造时被执行。这个块之所以被叫做“实例初始化块”是因为它们被定义在了一个类的实例范围内。
上面代码如果是写在 Test 类中，编译后你会看到会生成 Test$1.class 文件，反编译该文件内容：
D:\eclipse_indigo\workspace_home\CDHJobs\bin\pvuv\&jad -p Test$1.class
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Test.java
package pvuv.
import java.util.HashM
// Referenced classes of package pvuv.zhaopin:
class Test$1 extends HashMap // 创建了一个 HashMap 的子类
{ // 第二个 {} 中的代码放到了构造方法中去了
put("Name", "June");
put("QQ", "");
D:\eclipse_indigo\workspace_home\CDHJobs\bin\pvuv\&
2、推而广之
& 这种写法，推而广之，在初始化 ArrayList、Set 的时候都可以这么玩，比如你还可以这么玩：
List&String& names = new ArrayList&String&() {
for (int i = 0; i & 10; i++) {
add("A" + i);
System.out.println(names.toString()); // [A0, A1, A2, A3, A4, A5, A6, A7, A8, A9]
3、Java7：增加对 collections 的支持
在 Java 7 中你可以像 Ruby, Perl、Python 一样创建 collections 了。
Note：这些集合是不可变的。
PS：由于原文[5]作者并没有标出 java 7 哪个小版本号引入的这些新特性，对于留言报错的同学，请尝试大于 1.7.0_09 或者 java8 试试？
List list = new ArrayList();
list.add("item");
String item = list.get(0);
Set& String& set = new HashSet& String&();
set.add("item");
Map& String, Integer& map = new HashMap& String, Integer&();
map.put("key", 1);
int value = map.get("key");
// 现在你还可以：
List& String& list = ["item"];
String item = list[0];
Set& String& set = {"item"};
Map& String, Integer& map = {"key" : 1};
int value = map["key"];
4、文艺写法的潜在问题
&&& 文章开头提到的文艺写法的好处很明显就是一目了然。这里来罗列下此种方法的坏处，如果这个对象要串行化，可能会导致串行化失败。
& 1.此种方式是匿名内部类的声明方式，所以引用中持有着外部类的引用。所以当串行化这个集合时外部类也会被不知不觉的串行化，当外部类没有实现serialize接口时，就会报错。
2.上例中，其实是声明了一个继承自HashMap的子类。然而有些串行化方法，例如要通过Gson串行化为json，或者要串行化为xml时，类库中提供的方式，是无法串行化Hashset或者HashMap的子类的，从而导致串行化失败。解决办法：重新初始化为一个HashMap对象：
new HashMap(map);
这样就可以正常初始化了。
5、执行效率问题
&& 当一种新的工具或者写法出现时，猿们都会来一句：性能怎么样？（这和男生谈论妹纸第一句一般都是：“长得咋样？三围多少？”一个道理:)）
关于这个两种写法我这边笔记本上测试文艺写法、普通写法分别创建 10,000,000 个 Map 的结果是 ，相差 13%。
public class Test {
public static void main(String[] args) {
long st = System.currentTimeMillis();
for (int i = 0; i & ; i++) {
HashMap& String, String& map = new HashMap& String, String&() {
put("Name", "June");
put("QQ", "");
System.out.println(System.currentTimeMillis() - st); // 1217
for (int i = 0; i & ; i++) {
HashMap& String, String& map = new HashMap& String, String&();
map.put("Name", "June");
map.put("QQ", "");
System.out.println(System.currentTimeMillis() - st); // 1064
6、由实例初始化块联想到的一些变量初始化问题
& 从代码上看，a 为什么可以不先声明类型？你觉得 a、b、c 的值分别是多少？能说明理由么？
TIPS：如果你对这块机制不了解，建议试着反编译一下字节码文件。
6.1 测试源码
public class Test {
int e = 6;
int c = 1;
this.f = 5;
int e = 66;
int f = 55;
int c = 11;
int b = 1;
int a = 33;
static int d = 44;
int g = 7;
int h = 8;
public int test(){
int h = 88;
System.out.println("h - 成员变量：" + this.h);
System.out.println("h - 局部变量: " + h);
public static void main(String[] args) {
System.out.println("a: " + new Test().a);
System.out.println("b: " + new Test().b);
System.out.println("c: " + new Test().c);
System.out.println("d: " + new Test().d);
System.out.println("f: " + new Test().f);
System.out.println("e: " + new Test().e);
System.out.println("g: " + new Test().test());
6.2 字节码反编译：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Test.java
import java.io.PrintS
public class Test
this.e = 6;
this.c = 11;
int c = 1;
int e = 66;
public int test()
int h = 88;
System.out.println((new StringBuilder("h - \u\u53D8\u91CF\uFF1A")).append(this.h).toString());
System.out.println((new StringBuilder("h - \u5C40\u90E8\u53D8\u91CF: ")).append(h).toString());
public static void main(String args[])
System.out.println((new StringBuilder("a: ")).append((new Test()).a).toString());
System.out.println((new StringBuilder("b: ")).append((new Test()).b).toString());
System.out.println((new StringBuilder("c: ")).append((new Test()).c).toString());
new Test();
System.out.println((new StringBuilder("d: ")).append(d).toString());
System.out.println((new StringBuilder("f: ")).append((new Test()).f).toString());
System.out.println((new StringBuilder("e: ")).append((new Test()).e).toString());
System.out.println((new StringBuilder("g: ")).append((new Test()).test()).toString());
static int d = 4;
6.3 output：
h - 成员变量：8
h - 局部变量: 88
二、HashMap遍历方法示例
Map map = new HashMap();
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next(); Object key = entry.getKey();
Object val = entry.getValue();
效率高,以后一定要使用此种方式！
第二种:
Map map = new HashMap();
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
Object key = iter.next();
Object val = map.get(key);
效率低,以后尽量少使用！
HashMap的遍历有两种常用的方法，那就是使用keyset及entryset来进行遍历，但两者的遍历速度是有差别的，下面请看实例：
public class HashMapTest {
public static void main(String[] args) ...{
HashMap hashmap = new HashMap();
for (int i = 0; i & 1000; i ) ...{
hashmap.put("" i, "thanks");
long bs = Calendar.getInstance().getTimeInMillis();
Iterator iterator = hashmap.keySet().iterator();
while (iterator.hasNext()) ...{
System.out.print(hashmap.get(iterator.next()));
System.out.println();
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
listHashMap();
public static void listHashMap() ...{
java.util.HashMap hashmap = new java.util.HashMap();
for (int i = 0; i & 1000; i ) ...{
hashmap.put("" i, "thanks");
long bs = Calendar.getInstance().getTimeInMillis();
java.util.Iterator it = hashmap.entrySet().iterator();
while (it.hasNext()) ...{
java.util.Map.Entry entry = (java.util.Map.Entry) it.next();
// entry.getKey() 返回与此项对应的键
// entry.getValue() 返回与此项对应的值
System.out.print(entry.getValue());
System.out.println();
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
对于keySet其实是遍历了2次，一次是转为iterator，一次就从hashmap中取出key所对于的value。而entryset只是遍历了第一次，他把key和value都放到了entry中，所以就快了。
注:Hashtable的遍历方法和以上的差不多！
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具
