1.声明一个map: Map map = new HashMap();
2.向map中放值,注意：map是key-value的形式存放的.如:
map.put("sa","dd");
3.从map中取值:String str = map.get("sa").toString();结果是:str = "dd";
4.遍历一个map，从中取得key 和value
JDK1.5
Map m = new HashMap();
for (Object o : map.keySet()) {
map.get(o);
}
JDK1.4
Map map = new HashMap() ;
Iterator it = map.entrySet().iterator() ;
while (it.hasNext())
{
Map.Entry entry = (Map.Entry) it.next() ;
Object key = entry.getKey() ;
Object value = entry.getValue() ;
}
了解最常用的集合类型之一Map 的基础知识以及如何针对您应用程序特有的数据优化Map。
本文相关下载：
·Jack 的HashMap 测试
·Oracle JDeveloper 10g
java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象元素列表。List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将List 看作是具有数值键的Map。而实际上，除了List 和Map 都在定义java.util 中
外，两者并没有直接的联系。本文将着重介绍核心Java 发行套件中附带的Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用Map。
了解Map 接口和方法
Java 核心类中有很多预定义的Map 类。在介绍具体实现之前，我们先介绍一下Map 接口本身，以便了解所有实现的共同点。Map 接口定义了四种类型的方法，每个Map 都包含这些方法。下面，我们从两个普通的方法（表1）开始对这些方法加以介绍。
表1：覆盖的方法。我们将这Object 的这两个方法覆盖，以正确比较Map 对象的等价性。
equals(Object o)
比较指定对象与此Map 的等价性
hashCode()
返回此Map 的哈希码
Map 构建
Map 定义了几个用于插入和删除元素的变换方法（表2）。
表2：Map 更新方法：可以更改Map 内容。
clear()
从Map 中删除所有映射
remove(Object key)
从Map 中删除键和关联的值
put(Object key, Object value)
将指定值与指定键相关联
clear()
从Map 中删除所有映射
putAll(Map t)
将指定Map 中的所有映射复制到此map
尽管您可能注意到，纵然假设忽略构建一个需要传递给putAll() 的Map 的开销，使用putAll() 通常也并不比使用大量的put() 调用更有效率，但putAll() 的存在一点也不稀奇。这是因为，putAll() 除了迭代put() 所执行的将每个键值对添加到Map 的算法以外，还需要迭代所传递的Map 的元素。但应注意，putAll() 在添加所有元素之前可以正确调整Map 的大小，因此如果您未亲自调整Map 的大小（我们将对此进行简单介绍），则putAll() 可能比预期的更有效。
查看Map
迭代Map 中的元素不存在直接了当的方法。如果要查询某个Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该Map 的“视图”。有三种可能的视图（参见表3）
?所有键值对—参见entrySet()
?所有键—参见keySet()
?有值—参见values()
前两个视图均返回Set 对象，第三个视图返回Collection 对象。就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代Collection 对象或Set 对象。要进行迭代，您必须获得一个Iterator 对象。因此，要迭代Map 的元素，必须进行比较烦琐的编码
Iterator keyValuePairs = aMap.entrySet().iterator();
Iterator keys = aMap.keySet().iterator();
Iterator values = aMap.values().iterator();
值得注意的是，这些对象（Set、Collection 和Iterator）实际上是基础Map 的视图，而不是包含所有元素的副本。这使它们的使用效率很高。另一方面，Collection 或Set 对象的toArray() 方法却创建包含Map 所有元素的数组对象，因此除了确实需要使用数组中元素的情形外，其效率并不高。
我运行了一个小测试（随附文件中的），该测试使用了HashMap，并使用以下两种方法对迭代Map 元素的开销进行了比较：
int mapsize = aMap.size();
Iterator keyValuePairs1 = aMap.entrySet().iterator();
for (int i = 0; i < mapsize; i++)
{
Map.Entry entry = (Map.Entry) keyValuePairs1.next();
Object key = entry.getKey();
Object value = entry.getValue();
...
}
Object[] keyValuePairs2 = aMap.entrySet().toArray();
for (int i = 0; i < rem; i++) {
{
Map.Entry entry = (Map.Entry) keyValuePairs2[i];
Object key = entry.getKey();
Profilers in Oracle JDeveloper
Oracle JDeveloper 包含一嵌入的监测器，它测量内存和执行时间，使您能够快速识别代码中的瓶颈。我曾使用Jdeveloper 的执行监测器监测HashMap 的containsKey() 和containsValue() 方法，并很快发现containsKey() 方法的速度比containsValue() 方法慢很多（实际上要慢几个数量级！）。（参见图1和图2，以及随附文件中的类）。
Object value = entry.getValue();
...
}
此测试使用了两种测量方法：一种是测量迭代元素的时间，另一种测量使用toArray 调用创建数组的其他开销。第一种方法（忽略创建数组所需的时间）表明，使用已从toArray 调用中创建的数组迭代元素的速度要比使用Iterator 的速度大约快30%-60%。但如果将使用toArray 方法创建数组的开销包含在内，则使用Iterator 实际上要快10%-20%。因此，如果由于某种原因要创建一个集合元素的数组而非迭代这些元素，则应使用该数组迭代元素。但如果您不需要此中间数组，则不要创建它，而是使用Iterator 迭代元素。
表3：返回视图的Map 方法：使用这些方法返回的对象，您可以遍历Map 的元素，还可以删除Map 中的元素。
entrySet()
返回Map 中所包含映射的Set 视图。Set 中的每个元素都是一个Map.Entry 对象，可以使用getKey() 和getValue() 方法（还有一个setValue() 方法）访问后者的键元素和值元素
keySet()
返回Map 中所包含键的Set 视图。删除Set 中的元素还将删除Map 中相应的映射（键和值）
values()
返回map 中所包含值的Collection 视图。删除Collection 中的元素还将删除Map 中相应的映射（键和值）
访问元素
表 4 中列出了Map 访问方法。Map 通常适合按键（而非按值）进行访问。Map 定义中没有规定这肯定是真的，但通常您可以期望这是真的。例如，您可以期望containsKey() 方法与get() 方法一样快。另一方面，containsValue() 方法很可能需要扫描Map 中的值，因此它的速度可能比较慢。
表4：Map 访问和测试方法：这些方法检索有关Map 内容的信息但不更改Map 内容。
get(Object key)
返回与指定键关联的值
containsKey(Object key)
如果Map 包含指定键的映射，则返回true
containsValue(Object value)
如果此Map 将一个或多个键映射到指定值，则返回true
isEmpty()
如果Map 不包含键-值映射，则返回true
size()
返回Map 中的键-值映射的数目
对使用containsKey() 和containsValue() 遍历HashMap 中所有元素所需时间的测试表明，containsValue() 所需的时间要长很多。实际上要长几个数量级！（参见图1和图2，以及随附文件中的。因此，如果containsValue() 是应用程序中的性能问题，它将很快显现出来，并可以通过监测您的应用程序轻松地将其识别。这种情况下，我相
信您能够想出一个有效的替换方法来实现containsValue() 提供的等效功能。但如果想不出办法，则一个可行的解决方案是再创建一个Map，并将第一个Map 的所有值作为键。这样，第一个Map 上的containsValue() 将成为第二个Map 上更有效的containsKey()。
图1：使用JDeveloper 创建并运行Map 测试类
图2：在JDeveloper 中使用执行监测器进行的性能监测查出应用程序中的瓶颈
核心Map
Java 自带了各种Map 类。这些Map 类可归为三种类型：
1.通用Map，用于在应用程序中管理映射，通常在java.util 程序包中实现
o HashMap
o Hashtable
o Properties
o LinkedHashMap
o IdentityHashMap
o TreeMap
o WeakHashMap
o ConcurrentHashMap
2.专用Map，您通常不必亲自创建此类Map，而是通过某些其他类对其进行访问
o java.util.jar.Attributes
o javax.print.attribute.standard.PrinterStateReasons
o java.security.Provider
o java.awt.RenderingHints
o javax.swing.UIDefaults
3.一个用于帮助实现您自己的Map 类的抽象类
o AbstractMap
内部哈希：哈希映射技术
几乎所有通用Map 都使用哈希映射。这是一种将元素映射到数组的非常简单的机制，您应了解哈希映射的工作原理，以便充分利用Map。
哈希映射结构由一个存储元素的内部数组组成。由于内部采用数组存储，因此必然存在一个用于确定任意键访问数组的索引机制。实际上，该机制需要提供一个小于数组大小的整数索引值。该机制称作哈希函数。在Java 基于哈希的Map 中，哈希函数将对象转换为一个适合内部数组的整数。您不必为寻找一个易于使用的哈希函数而大伤脑筋：每个对象都包含一个返回整数值的hashCode() 方法。要将该值映射到数组，只需将其转换为一个正值，然后在将该值除以数组大小后取余数即可。以下是一个简单的、适用于任何对象的Java 哈希函数
int hashvalue = Maths.abs(key.hashCode()) % table.length;
（% 二进制运算符（称作模）将左侧的值除以右侧的值，然后返回整数形式的余数。）
实际上，在 1.4 版发布之前，这就是各种基于哈希的Map 类所使用的哈希函数。但如果您查看一下代码，您将看到
int hashvalue = (key.hashCode() & 0x7FFFFFFF) % table.length;
它实际上是使用更快机制获取正值的同一函数。在1.4 版中，HashMap 类实现使用一个不同且更复杂的哈希函数，该函数基于Doug Lea 的util.concurrent 程序包（稍后我将更详细地再次介绍Doug Lea 的类）。
图3：哈希工作原理
该图介绍了哈希映射的基本原理，但我们还没有对其进行详细介绍。我们的哈希函数将任意对象映射到一个数组位置，但如果两个不同的键映射到相同的位置，情况将会如何？这是一种必然发生的情况。在哈希映射的术语中，这称作冲突。Map 处理这些冲突的方法是在索引位置处插入一个链接列表，并简单地将元素添加到此链接列表。因此，一个基于哈希的Map 的基本put() 方法可能如下所示
public Object put(Object key, Object value) {
//我们的内部数组是一个 Entry 对象数组
//Entry[] table;
//获取哈希码，并映射到一个索引
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % table.length;
//循环遍历位于 table[index] 处的链接列表，以查明
//我们是否拥有此键项—如果拥有，则覆盖它
for (Entry e = table[index] ; e != null ; e = e.next) {
//必须检查键是否相等，原因是不同的键对象
//可能拥有相同的哈希
if ((e.hash == hash) && e.key.equals(key)) {
//这是相同键，覆盖该值
//并从该方法返回 old 值
Object old = e.value;
e.value = value;
return old;
}
}
//仍然在此处，因此它是一个新键，只需添加一个新 Entry
//Entry 对象包含 key 对象、 value 对象、一个整型的 hash、
//和一个指向列表中的下一个 Entry 的 next Entry
//创建一个指向上一个列表开头的新 Entry，
//并将此新 Entry 插入表中
Entry e = new Entry(hash, key, value, table[index]);
table[index] = e;
return null;
}
如果看一下各种基于哈希的Map 的源代码，您将发现这基本上就是它们的工作原理。此外，还有一些需要进一步考虑的事项，如处理空键和值以及调整内部数组。此处定义的put() 方法还包含相应get() 的算法，这是因为插入包括搜索映射索引处的项以查明该键是否已经存在。（即get() 方法与put() 方法具有相同的算法，但get() 不包含插入和覆盖代码。）使用链接列表并不是解决冲突的唯一方法，某些哈希映射使用另一种“开放式寻址”方案，本文对其不予介绍。
优化Hasmap
如果哈希映射的内部数组只包含一个元素，则所有项将映射到此数组位置，从而构成一个较长的链接列表。由于我们的更新和访问使用了对链接列表的线性搜索，而这要比Map 中的每个数组索引只包含一个对象的情形要慢得多，因此这样做的效率很低。访问或更新链接列表的时间与列表的大小线性相关，而使用哈希函数问或更新数组中的单个元素则与数组大小无关—就渐进性质（Big-O 表示法）而言，前者为O(n)，而后者为O(1)。因此，使用一个较大的数组而不是让太多的项聚集在太少的数组位置中是有意义的。
调整Map 实现的大小
在哈希术语中，内部数组中的每个位置称作“存储桶”(bucket)，而可用的存储桶数（即内部数组的大小）称作容量(capacity)。为使Map 对象有效地处理任意数目的项，Map 实现可以调整自身的大小。但调整大小的开销很大。调整大小需要将所有元素重新插入到新数组中，这是因为不同的数组大小意味着对象现在映射到不同的索引值。先前冲突的键可能不再冲突，而先前不冲突的其他键现在可能冲突。这显然表明，如果将Map 调整得足够大，则可以减少甚至不再需要重新调整大小，这很有可能显著提高速度。
使用 1.4.2 JVM 运行一个简单的测试，即用大量的项（数目超过一百万）填充HashMap。表 5 显示了结果，并将所有时间标准化为已预先设置大小的服务器模式（关联文件中的。对于已预先设置大小的JVM，客户端和服务器模式JVM 运行时间几乎相同（在放弃JIT 编译阶段后）。但使用Map 的默认大小将引发多次调整大小操作，开销很大，在服务器模式下要多用50% 的时间，而在客户端模式下几乎要多用两倍的时间！
表5：填充已预先设置大小的HashMap 与填充默认大小的HashMap 所需时间的比较
客户端模式
服务器模式
预先设置的大小
100%
100%
默认大小
294%
157%
使用负载因子
为确定何时调整大小，而不是对每个存储桶中的链接列表的深度进行记数，基于哈希的Map 使用一个额外参数并粗略计算存储桶的密度。Map 在调整大小之前，使用名为“负载因子”的参数指示Map 将承担的“负载”量，即它的负载程度。负载因子、项数（Map 大小）与容量之间的关系简单明了：
如果（负载因子）x（容量）>（Map 大小），则调整Map 大小
例如，如果默认负载因子为0.75，默认容量为11，则11 x 0.75 = 8.25，该值向下取整为8 个元素。因此，如果将第8 个项添加到此Map，则该Map 将自身的大小调整为一个更大的值。相反，要计算避免调整大小所需的初始容量，用将要添加的项数除以负载因子，并向上取整，例如，
对于负载因子为0.75 的100 个项，应将容量设置为100/0.75 = 133.33，并将结果向上取整为134（或取整为135 以使用奇数）
奇数个存储桶使map 能够通过减少冲突数来提高执行效率。虽然我所做的测试（关联文件中的并未表明质数可以始终获得更好的效率，但理想情形是容量取质数。1.4 版后的某些Map（如HashMap 和LinkedHashMap，而非Hashtable 或IdentityHashMap）使用需要2 的幂容量的哈希函数，但下一个最高2 的幂容量由这些Map 计算，因此您不必亲自计算。
负载因子本身是空间和时间之间的调整折衷。较小的负载因子将占用更多的空间，但将降低冲突的可能性，从而将加快访问和更新的速度。使用大于0.75 的负载因子可能是不明智的，而使用大于1.0 的负载因子肯定是不明知的，这是因为这必定会引发一次冲突。使用小于0.50 的负载因子好处并不大，但只要您有效地调整Map 的大小，应不会对小负载因子造成性能开销，而只会造成内存开销。但较小的负载因子将意味着如果您未预先调整Map 的大小，则导致更频繁的调整大小，从而降低性能，因此在调整负载因子时一定要注意这个问题。
选择适当的Map
应使用哪种Map？它是否需要同步？要获得应用程序的最佳性能，这可能是所面临的两个最重要的问题。当使用通用Map 时，调整Map 大小和选择负载因子涵盖了Map 调整选项。
以下是一个用于获得最佳Map 性能的简单方法
1.将您的所有Map 变量声明为Map，而不是任何具体实现，即不要声明为HashMap 或Hashtable，
或任何其他Map 类实现。
Map criticalMap = new HashMap(); //好
HashMap criticalMap = new HashMap(); //差
这使您能够只更改一行代码即可非常轻松地替换任何特定的Map 实例。
2.下载Doug Lea 的util.concurrent 程序包
(https://www.doczj.com/doc/be8515199.html,/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html)。将
ConcurrentHashMap 用作默认Map。当移植到1.5 版时，将
java.util.concurrent.ConcurrentHashMap 用作您的默认Map。不要将ConcurrentHashMap 包装
在同步的包装器中，即使它将用于多个线程。使用默认大小和负载因子。
3.监测您的应用程序。如果发现某个Map 造成瓶颈，则分析造成瓶颈的原因，并部分或全部更改该Map
的以下内容：Map 类；Map 大小；负载因子；关键对象equals() 方法实现。专用的Map 的基
本上都需要特殊用途的定制Map 实现，否则通用Map 将实现您所需的性能目标。
Map 选择
也许您曾期望更复杂的考量，而这实际上是否显得太容易？好的，让我们慢慢来。首先，您应使用哪种Map？答案很简单：不要为您的设计选择任何特定的Map，除非实际的设计需要指定一个特殊类型的Map。设计时通常不需要选择具体的Map 实现。您可能知道自己需要一个Map，但不知道使用哪种。而这恰恰就是使用Map 接口的意义所在。直到需要时再选择Map 实现—如果随处使用“Map”声明的变量，则更改应用程序中任何特殊Map 的Map 实现只需要更改一行，这是一种开销很少的调整选择。是否要使用默认的Map 实现？我很快将谈到这个问题。
同步Map
同步与否有何差别？（对于同步，您既可以使用同步的Map，也可以使用Collections.synchronizedMap() 将未同步的Map 转换为同步的Map。后者使用“同步的包装器”）这是一个异常复杂的选择，完全取决于您如何根据多线程并发访问和更新使用Map，同时还需要进行维护方面的考虑。例如，如果您开始时未并发更新特定Map，但它后来更改为并发更新，情况将如何？在这种情况下，很容易在开始时使用一个未同步的Map，并在后来向应用程序中添加并发更新线程时忘记将此未同步的Map 更改为同步的Map。这将使您的应用程序容易崩溃（一种要确定和跟踪的最糟糕的错误）。但如果默认为同步，则将因随之而来的可怕性能而序列化执行多线程应用程序。看起来，我们需要某种决策树来帮助我们正确选择。
Doug Lea 是纽约州立大学奥斯威戈分校计算机科学系的教授。他创建了一组公共领域的程序包（统称
util.concurrent），该程序包包含许多可以简化高性能并行编程的实用程序类。这些类中包含两个Map，即ConcurrentReaderHashMap 和ConcurrentHashMap。这些Map 实现是线程安全的，并且不需要对并发访问或更新进行同步，同时还适用于大多数需要Map 的情况。它们还远比同步的Map（如Hashtable）或使用同步的包装器更具伸缩性，并且与HashMap 相比，它们对性能的破坏很小。util.concurrent 程序包构成了JSR166 的基础；JSR166 已经开发了一个包含在Java 1.5 版中的并发实用程序，而Java 1.5 版将把这些Map 包含在一个新的java.util.concurrent 程序包中。
后续步骤
下载Oracle JDeveloper 10g：改变您对Java 开发的看法
Oracle JDeveloper 10g中的监测器：该监测器利用Java 虚拟机中的某些特性，使您能够发现应用程序代码中的编程缺陷、性能问题以及内存泄漏。可以将监测器与调试器和CodeCoach 一起使用来进行功能强大且有效的应用程序代码故障排除。了解更多有关事件监测、执行监测以及内存监测的信息。
所有这一切意味着您不需要一个决策树来决定是使用同步的Map 还是使用非同步的Map，而只需使用ConcurrentHashMap。当然，在某些情况下，使用ConcurrentHashMap 并不合适。但这些情况很少见，并且应具体情况具体处理。这就是监测的用途。
结束语
通过Oracle JDeveloper 可以非常轻松地创建一个用于比较各种Map 性能的测试类。更重要的是，集成良好的监测器可以在开发过程中快速、轻松地识别性能瓶颈- 集成到IDE 中的监测器通常被较频繁地使用，以便帮助构建一
个成功的工程。现在，您已经拥有了一个监测器并了解了有关通用Map 及其性能的基础知识，可以开始运行您自己的测试，以查明您的应用程序是否因Map 而存在瓶颈以及在何处需要更改所使用的Map。
以上内容介绍了通用Map 及其性能的基础知识。当然，有关特定Map 实现以及如何根据不同的需求使用它们还存在更多复杂和值得关注的事项，这些将在本文第2 部分中介绍。
Jack Shirazi 是O'Reilly 的“Java 性能调整”的作者，以及受欢迎的https://www.doczj.com/doc/be8515199.html, 网站（提供Java 性能信息的全球知名站点）的总监。Jack 在Java 性能领域提供咨询并著书立说。他还监督
https://www.doczj.com/doc/be8515199.html, 提供的信息，其中包括每年大约发布1000 条性能技巧以及许多有关性能工具、讨论组等内容的文章。Jack 早年还曾发布有关蛋白质结构预测以及黑洞热力学方面的文章，而且在其空闲时还对某些Perl5 核心模块作出了贡献。
?
命名规范
定义这个规范的目的是让项目中所有的文档都看起来像一个人写的，增加可读性，减少项目组中因为换人而带来的损失。（这些规范并不是一定要绝对遵守，但是一定要让程序有良好的可读性）
Package 的命名
Package 的名字应该都是由一个小写单词组成。
Class 的命名
Class 的名字必须由大写字母开头而其他字母都小写的单词组成
Class 变量的命名
变量的名字必须用一个小写字母开头。后面的单词用大写字母开头。Static Final 变量的命名
Static Final 变量的名字应该都大写，并且指出完整含义。
参数的命名
参数的名字必须和变量的命名规范一致。
数组的命名
数组应该总是用下面的方式来命名：
而不是：
方法的参数
使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字：
Java 文件样式
所有的Java(*.java) 文件都必须遵守如下的样式规则
版权信息
版权信息必须在java 文件的开头，比如：
其他不需要出现在javadoc 的信息也可以包含在这里。
Package/Imports
package 行要在import 行之前，import 中标准的包名要在本地的包名之前，而且按照字母顺序排列。如果import 行中包含了同一个包中的不同子目录，则应该用* 来处理。
package https://www.doczj.com/doc/be8515199.html,.stats;
这里java.io.* 使用来代替InputStream and OutputStream 的。
Class
接下来的是类的注释，一般是用来解释类的。
接下来是类定义，包含了在不同的行的extends 和implements
Class Fields
接下来是类的成员变量：
public 的成员变量必须生成文档（JavaDoc）。proceted、private和package 定义的成员变量如果名字含义明确的话，可以没有注释。
存取方法
接下来是类变量的存取的方法。它只是简单的用来将类的变量赋值获取值的话，可以简单的写在一行上。
其它的方法不要写在一行上。
构造函数
接下来是构造函数，它应该用递增的方式写（比如：参数多的写在后面）。
访问类型("public", "private" 等.) 和任何"static", "final" 或"synchronized" 应该在一行中，并且方法和参数另写一行，这样可以使方法和参数更易读。
克隆方法
如果这个类是可以被克隆的，那么下一步就是clone 方法：
类方法
下面开始写类的方法：
toString 方法
无论如何，每一个类都应该定义toString 方法：
main 方法
如果main(String[]) 方法已经定义了, 那么它应该写在类的底部.
代码编写格式
代码样式
代码应该用unix 的格式，而不是windows 的（比如：回车变成回车+换行）
文档化
必须用javadoc 来为类生成文档。不仅因为它是标准，这也是被各种java 编译器都认可的方法。使用@author 标记是不被推荐的，因为代码不应该是被个人拥有的。
缩进
缩进应该是每行2个空格. 不要在源文件中保存Tab字符. 在使用不同的源代码管理工具时Tab字符将因为用户设置的不同而扩展为不同的宽度.
如果你使用UltrEdit 作为你的Java 源代码编辑器的话，你可以通过如下操作来禁止保存Tab字符, 方法是通过UltrEdit中先设定Tab 使用的长度室2个空格，然后用Format|Tabs to Spaces 菜单将Tab 转换为空格。
页宽
页宽应该设置为80字符. 源代码一般不会超过这个宽度, 并导致无法完整显示, 但这一设置也可以灵活调整. 在任何情况下, 超长的语句应该在一个逗号或者一个操作符后折行. 一条语句折行后, 应该比原来的语句再缩进2个字符.
{}中}语句应该单独作为一行. 例如, 下面的第1行是错误的, 第2行是正确的:
括号
左括号和后一个字符之间不应该出现空格, 同样, 右括号和前一个字符之间也不应该出现空格. 下面的例子说
明括号和空格的错误及正确使用:
不要在语句中使用无意义的括号. 括号只应该为达到某种目的而出现在源代码中。下面的例子说明错误和正确的用法:
程序编写规范
exit()
exit 除了在main 中可以被调用外，其他的地方不应该调用。因为这样做不给任何代码代码机会来截获退出。一个类似后台服务地程序不应该因为某一个库模块决定了要退出就退出。
异常
申明的错误应该抛出一个RuntimeException或者派生的异常。
顶层的main()函数应该截获所有的异常，并且打印（或者记录在日志中）在屏幕上。
垃圾收集
JAVA使用成熟的后台垃圾收集技术来代替引用计数。但是这样会导致一个问题：你必须在使用完对象的实例以后进行清场工作。比如一个prel的程序员可能这么写：
除非输出流一出作用域就关闭，非引用计数的程序语言，比如JAVA，是不能自动完成变量的清场工作的。必须象下面一样写：
Clone
下面是一种有用的方法：
final 类
绝对不要因为性能的原因将类定义为final 的（除非程序的框架要求）
如果一个类还没有准备好被继承，最好在类文档中注明，而不要将她定义为final 的。这是因为没有人可以保证会不会由于什么原因需要继承她。
访问类的成员变量
大部分的类成员变量应该定义为protected 的来防止继承类使用他们。
注意，要用"int[] packets"，而不是"int packets[]"，后一种永远也不要用。
编程技巧
byte 数组转换到characters
为了将byte 数组转换到characters，你可以这么做：
Utility 类
Utility 类（仅仅提供方法的类）应该被申明为抽象的来防止被继承或被初始化。
初始化
下面的代码是一种很好的初始化数组的方法：
枚举类型
JAVA 对枚举的支持不好，但是下面的代码是一种很有用的模板：
这种技术实现了RED, GREEN, BLUE 等可以象其他语言的枚举类型一样使用的常量。他们可以用== 操作符来比较。
但是这样使用有一个缺陷：如果一个用户用这样的方法来创建颜色BLACK
那么这就是另外一个对象，==操作符就会产生错误。她的equal() 方法仍然有效。由于这个原因，这个技术的缺陷最好注明在文档中，或者只在自己的包中使用。
Swing
避免使用AWT 组件
混合使用AWT 和Swing 组件
如果要将AWT 组件和Swing 组件混合起来使用的话，请小心使用。实际上，尽量不要将他们混合起来使用。
滚动的AWT 组件
AWT 组件绝对不要用JscrollPane 类来实现滚动。滚动AWT 组件的时候一定要用AWT ScrollPane 组件来实现。
避免在InternalFrame 组件中使用AWT 组件
java中Map类 Map以按键/数值对的形式存储数据，和数组非常相似，在数组中存在的索引，它们本身也是对象。 Map的接口 Map－－－实现Map Map.Entry－－Map的内部类，描述Map中的按键/数值对。 SortedMap---扩展Map，使按键保持升序排列 关于怎么使用，一般是选择Map的子类，而不直接用Map类。 下面以HashMap为例。 public static void main(String args[]) { HashMap hashmap = new HashMap(); hashmap.put("Item0", "Value0"); hashmap.put("Item1", "Value1"); hashmap.put("Item2", "Value2"); hashmap.put("Item3", "Value3"); Set set = hashmap.entrySet(); Iterator iterator = set.iterator(); while (iterator.hasNext() { Map.Entry mapentry = (Map.Entry) iterator.next(); System.out.println(mapentry.getkey() + "/" + mapentry.getValue()); } } 注意，这里Map的按键必须是唯一的，比如说不能有两个按键都为null。 如果用过它，就会知道它的用处了。 又比如: Map
Java集合类 Java集合类 (1) 1.Map (3) 1.1.HashMap (3) 1.1.1.底层实现 (3) 1.1.2.特点 (3) 1.1.3.源码分析 (4) 1.1.4.多线程可能出现的问题 (5) 1.2.ConcurrentHashMap (6) 1.2.1.底层实现 (6) 1.2.2.源码分析 (7) 1.3.HashTable (9) 1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键 字。9 1.3.2.HashTable的key和value都不可以为null。 (9) 1.3.3.扩容时，capacity=2*capacity+1 (9) 1.3.4.数组默认大小为11 (9) 1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9) 1.4.TreeMap (9) 1.4.1.底层实现为红黑树 (9) 1.4. 2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据 其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10) 1.4.3.接口实现 (10) 1.4.4.Entry (11) 1.5.LinkedHashMap (11) 1.5.1.底层是数组+链表+红黑树+双向链表 (11) 1.5.2.维护链表顺序和访问顺序 (11) 1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在 元素被访问后改变其在双向链表中的位置。 (11) 1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess 方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值 false时，recordAccess方法什么也不会做。 (11) 1.5.5.LRU实现 (11) 2.Collection (11) 2.1.List (12) 2.1.1.ArrayList (12) 2.1.2.LinkedList (13) 2.1.3.CopyOnWriteArrayList (13) 2.2.Set (14) 2.2.1.HashSet (14)
JAVA常用的高级数据类型——集合类型 一、JAVA语言中的集合类型主要有三种形式：Set（集）、List（列表）、Map（映射），每种类型的集合都包括三部分：接口、实现和算法。 a)集合接口实现集合的操作和集合的具体功能实现细节的相互分离—— Set接口、List接口、Map接口 b)集合的具体功能实现类实质上是各种可重用的数据结构的具体表示 List接口的实现类有ArrayList、LinkedList、Stack和Vector等 集合类，Vector 类提供了实现可增长数组的功能，随着更多元素加 入其中，数组变的更大。在删除一些元素之后，数组变小。 Set接口的实现类有HashSet、LinkedHashSet和TreeSet等集合类 Map接口的实现类有HashMap、Hashtable、LinkedHashMap、Properties和TreeMap等集合类。 c)集合的算法指可以对实现集合接口的各个集合的功能实现类提供如排 序、查找、交换和置换等方面的功能实现。 二、List接口 1.List接口代表有序的集合，可以对List接口代表的有序集合中每个元素 的插入位置进行精确地控制，并利用元素的整数索引（代表元素在集合中的位置）访问元素中的各个成员，List接口代表的集合是允许出现重复元素的。 2.List接口主要成员方法： 1）void add（int index,E element）在列表指定位置插入指定元素 2）E get(int index) 返回结合中指定位置的元素 3）E remove(int index) 移除集合中指定位置的元素 4）E set(int index,E elment) 用指定元素替换集合中指定位置的元素 5）boolean add(E o) 向列表的尾部追加指定的元素 6）boolean contains(Object o) 如果列表包含指定的元素，则返回true。 7）boolean isEmpty() 如果列表不包含元素，则返回 true。 8）int size() 返回列表中的元素数 9）Iterator iterator()返回以正确顺序在列表的元素上进行迭代的迭代器。 3.List的实现类 List在数据结构中分别表现为数组（ArrayList）、向量（Vector）、链表（LinkedList）、堆栈（Stack）和队列等形式。 Vector集合和ArrayList集合都是采用数组形式来保存对象，区别在于ArrayList集合本身不具有线程同步的特性，不能用在多线程的环境下，可以使用ArrayList集合能够节省由于同步而产生的系统性能的开销。而Vector集合实现了对线程同步的支持，因此在多线程并发访问的应用环境下，该集合本身能够保证自身具有线程安全性。在多线程的并发访问中，可以将Vector集合的对象实例设计为类中的成员属性，而应该将ArrayList 集合的对象实例设计为局部对象。 public class UserInfo{ List oneVector=new Vector(); public void execute(){
Java中的Set,List,Map的区别 (转) 对JAVA的集合的理解是相对于数组 相对于数组的是大小固定的，并且同一个数组只能存放类型一样的数据（基本类型/引用类型） JAVA集合可以存储和操作数目不固定的一组数据。 所有的JAVA集合都位于 java.util包中！ JAVA集合只能存放引用类型的的数据，不能存放基本数据类型. JAVA集合主要分为三种类型： Set(集) List(列表) Map(映射) Collection 接口 Collection是最基本的集合接口，声明了适用于JAVA集合（只包括Set和List）的通用方法。 Set 和List 都继承了Conllection,Map没有 Collection接口的方法： boolean add(Object o) :向集合中加入一个对象的引用 void clear() :删除集合中所有的对象，即不再持有这些对象的引用 boolean isEmpty() :判断集合是否为空 boolean contains(Object o): 判断集合中是否持有特定对象的引用 Iterartor iterator() : 返回一个Iterator对象，可以用来遍历集合中的元素 boolean remove(Object o):从集合中删除一个对象的引用 int size() :返回集合中元素的数目 Object[] toArray() :返回一个数组，该数组中包括集合中的所有元素 关于：Iterator() 和toArray() 方法都用于集合的所有的元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。 Iterator接口声明了如下方法： hasNext(): 判断集合中元素是否遍历完毕，如果没有，就返回true next() :返回下一个元素 remove():从集合中删除上一个有next()方法返回的元素。 Set(集合)： Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。 Set接口主要实现了两个实现类： HashSet : HashSet类按照哈希算法来存取集合中的对象，存取速度比较快
1.本讲内容：集合collection （数组和集合90%功能相似，但是最大的区别是，数组在初始化的时候必须确定大小，而集合不用，而且集合是一堆的类，使用起来非常方便。） 讲集合collection之前，我们先分清三个概念： 1colection 集合，可用来存储任何对象的一种数据结构（容器）。 2Collection 集合接口，指的是，是Set、List 和Queue 接口的超类接口 3Collections 集合工具类，指的是类。 SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个Iterator 接口也是必须了解的。 SCJP考试要求了解的类有：HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays 下面给出一个集合之间的关系图： 上图中加粗线的ArrayList 和HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。 我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。 4List 关注事物的索引列表 5Set 关注事物的唯一性 6Queue 关注事物被处理时的顺序 7Map 关注事物的映射和键值的唯一性 一、Collection 接口 Collection接口是Set 、List 和Queue 接口的父接口，提供了多数集合常用的方法声明，包括add()、remove()、contains() 、size() 、iterator() 等。 add(E e) 将指定对象添加到集合中 remove(Object o) 将指定的对象从集合中移除，移除成功返回true,不成功返回false contains(Object o) 查看该集合中是否包含指定的对象，包含返回true,不包含返回flase size() 返回集合中存放的对象的个数。返回值为int clear() 移除该集合中的所有对象，清空该集合。 iterator() 返回一个包含所有对象的iterator对象，用来循环遍历 toArray() 返回一个包含所有对象的数组,类型是Object toArray(T[] t) 返回一个包含所有对象的指定类型的数组 我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：例子1： package edu.xjfu;
JAVA的容器---List,Map,Set Collection ├List │├LinkedList │├ArrayList │└Vector │└Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection接口 Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。 如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下： Iterator it = collection.iterator(); // 获得一个迭代子 while(it.hasNext()) { Object obj = it.next(); // 得到下一个元素 } 由Collection接口派生的两个接口是List和Set。
数据库 oracle-->数据库管理系统-->SQL、PL/SQL-->Java(JDBC+SQL) DBA,数据库编程程序员 1.概念导论 1）什么是数据库 有组织和结构存储数据。可以存储 字符、字节、图形、图像等类型数据 DB(数据库):数据集合 DBMS(数据库管理系统)：对数据集合进行管理和操作的软件 --Oracle --DB2 --MySQL --SQLSERVER JDBC 1.什么是JDBC 全称Java DataBase Connection,Java数据库访问。 JDBC是Java访问数据库的一项技术 JDBC是SUN推出的Java访问数据库的一套标准。由一系列接口构成。 各个数据库厂商负责提供JDBC接口API的实现包。 开发者只需要掌握JDBC接口的使用,就可以实现对各种数据库的操作，不需要了解开发商的实现类。 XML 1、什么是xml(xtendsible markup language可扩 展的标记语言)? 1)定义 基于文本的通用的数据保存格式。 (1)通用的点的坐标 Point类point对象(x=10,y=20) a,序列化 b,数据库表 c,文件 ... (2)数据格式
HTML 知识准备 1、分层：表现层：UI界面（DOS界面、桌面类型、web类型） 业务层： 数据层：文件、Oracle数据库 2、Web类型的应用程序----B/S类型 打开Browser，输入URL，浏览器将请求发送到服务器 服务器得到请求，分析，返回响应 浏览器得到响应，解析（翻译），显示为页面 3、web学习阶段 客户端技术：HTML+CSS+Javascript---Web基础 服务器端技术：JSP、PHP、https://www.doczj.com/doc/be8515199.html, 4、web基础的课程 HTML：页面的创建 CSS：页面的外观 JavaScript：页面的动态效果和交互行为--3 一：HTML概述 1、超文本标记语言：一种编写页面的纯文本的标记语言，文件以.html或者.htm为后缀，依靠浏览器运行显示----解释性的语言 2、标记：一些用<>括起来的内容，特殊的显示 3、主流浏览器：IE/Firefox/Chrome/ 4、浏览器兼容性：符合标准规范，具体问题 CSS 一：CSS概述 1、CSS：级联样式表（层叠样式表） 2、特征：为页面定义外观的语言，实现内容和表现的分离，多个样式可以合为一个，如果冲突，以优先级为准 二：基础语法 1、语法：属性名称:值;属性名称:值;比如--color:red; 2、如何应用 方式一（内联方式）：<元素style=""/>---将样式直接定义在元素的style属性里 方式二（内部样式表）：在页面的head里的style里定义样式 方式三（外部样式表）：定义一个单独的.css的文件（定义样式）；然后，在页面的head里用link引入---推荐方式 3、外部样式表的优点：实现内容和表现的分离，提高代码的可重用性和可维护性
慕课网分享：40个Java集合面试问题和答案 Java集合框架为Java编程语言的基础，也是Java面试中很重要的一个知识点。这里，慕课网列出了一些关于Java集合的重要问题和答案，程序员们，你能回答出几道问题呢？ 1.Java集合框架是什么?说出一些集合框架的优点? 每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。集合框架的部分优点如下： (1)使用核心集合类降低开发成本，而非实现我们自己的集合类。 (2)随着使用经过严格测试的集合框架类，代码质量会得到提高。 (3)通过使用JDK附带的集合类，可以降低代码维护成本。 (4)复用性和可操作性。 2.集合框架中的泛型有什么优点? Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。 3.Java集合框架的基础接口有哪些?
Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。 List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。 Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。 一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。 4.为何Collection不从Cloneable和Serializable接口继承? Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。 当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。 在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。 5.为何Map接口不继承Collection接口? 尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。 如果Map继承Collection接口，那么元素去哪儿?Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。 6.Iterator是什么? Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。 7.Enumeration和Iterator接口的区别? Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。 迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。
java中List的用法和实例详解 List的用法 List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表1所示。 表1 List接口定义的常用方法及功能 从表1可以看出，List接口提供的适合于自身的常用方法均与索引有关，这是因为List集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。 List接口的常用实现类有ArrayList和LinkedList，在使用List集合时，通常情况下声明为List类型，实例化时根据实际情况的需要，实例化为ArrayList或LinkedList，例如： List
第一章初识java 一、java语言的历史 ●第一代java语言：Oak 二、java语言的现状 ?Java SE:主要用于桌面程序的开发。 ?Java EE:主要用于网页程序的开发。 ?Java ME:主要用于嵌入式系统程序的开发。（安卓）三、java语言的特点 ●跨平台（不同的操作系统都可运行） ●简单（没有直接使用指针） ●面向对象（世间万物皆为对象） ●半编译半解释（java文件---class文件----虚拟机） ●分布式（多个客户端访问、通过服务器的配置分发到 不同的服务器） ●健壮（异常的处理） ●安全（任何语言都具备、虚拟机沙箱原理） ●多线程、高性能、动态 四、java语言与C、C++语言的不同与区别 ●自动内存管理：Java对于内存的分配是动态的，并具 有垃圾回收机制。 ●不在类外定义全局变量。 ●Java中将不再使用goto语句。
●Java中取消了指针。 ●运行时系统对类型转换进行类型相容性检查 ●Java不支持头文件，使用import与其它类通讯。 ●Java中不包含结构和联合；所有的内容都封装在类中。 ●Java中不支持宏，它通过final 关键字来声明一个常 量。 ●Java不支持多重继承，可以通过Java中的接口实现 多重继承的功能。 ●CC++ 一般情况下都是偏硬件的，java一般偏软件（应 用、基于浏览器） ●（补充）.net、php （网页制作比较快捷）、在安全级 别要求高的企业一般使用java（银行、政府系统） 五、环境的搭建 1、默认路径如下 ●C:\Program Files\Java\jdk1.6.0_02：提供编程中需要 的api包 ●C:\Program Files\Java\jre1.6.0_02：虚拟机文件所在的 位置 2.安装后各个文件夹代表的含义
Java中的集合类 (Collection framework)我们在前面学习过java数组，java数组的程度是固定的，在同一个数组中只能存放相同的类型数据。数组可以存放基本类型的数据，也可以存入对象引用的数据。 在创建数组时，必须明确指定数组的长度，数组一旦创建，其长度就不能改变，在许多应用的场合，一组数据的数目不是固定的，比如一个单位的员工数目是变化的，有老的员工跳槽，也有新的员工进来。 为了使程序方便地存储和操纵数目不固定的一组数据，JDK中提供了java集合类，所有java集合类都位于java.util包中，与java数组不同，java集合类不能存放基本数据类型数据，而只能存放对象的引用。 Java集合类分为三种 Set(集合)：集合中对象不按特定的方式排序。并且没有重复对象，但它有些实现类中的对象按特定方式排序。--无序，不能重复 List（列表）：集合中的对象按照检索位置排序，可以有重复对象，允许按照对象在集中的索引位置检索对象，List和数组有些相似。--有序，可以重复 Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复，它的有些实现类能对集合中的键对象进行排序。 Java的主要集合类的框架图 Collection和Iterator接口 在Collection接口中声明了适用于java集合（只包括Set和List）通用方法。 Collection接口的方法 方法描述
boolean add(Object o) 向集合中加入一个对象的引用 void clear( ) 删除集合中所有对象，即不再对持有对象的引用boolean contains(Object o) 判断在集合中是否含有特定对象的引用 boolean isEmpty() 判断集合是否为空 Iterator iterator( ) 返回一个Iterator对象，可用它来遍历集合中的元素boolean remove(Object o) 从集合中删除一个对象的引用 int size( ) 返回集合中元素的数目 Object [ ] toArray() 返回一个数组，该数组包含集合中的所有元素 Set接口和List即可都继承了Collection接口，而Map接口没有继承Collection接口，因此可以对Set对象和List对象调用以上方法，但是不能对Map对象调用以上方法。Collection接口的iterator()和toArray()方法多用于获得集合中的所有元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。 Iterator隐藏底层集合的数据结构，向客户程序提供了遍历各种类型的集合的统一接口。Iterator接口中声明了如下方法： ●hasNext()：判断集合中的元素是否遍历完毕，如果没有，就返回true。 ●next()：返回下一个元素 ●remove()：从集合中删除上一个由next()方法返回的元素。 注意：如果集合中的元素没有排序，Iterator遍历集合中元素的顺序是任意的，并不一定与像集合中加入的元素的顺序一致。 Set（集） Set是最简单的一种集合，集合中的对象不按特定方式排序，并没有重复对象。Set接口主要有两个实现类：HashSet类还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构，链表数据结构能提高插入核算出元素的性能。TreeSet类实现了SortedSet接口中，具有排序功能。 List(列表) List的主要特征使其元素已先行方式存储，集合中允许存放重复对象。List接口主要的实现类包括： ●ArrayList—ArrayList代表长度可变的数组。允许对元素进行快速的随机访问，但是向 ArrayList中插入与删除元素的速度较慢。 ●LinkedList—在实现中采用链表数据结构。对顺序访问进行了优化，向List中插入和 删除元素的速度较快，随机访问速度则相对较慢，随机访问是指检索位于特定索引位置元素。 Map（映射） Map（映射）是一种吧键对和值对象进行映射的集合。它的每一个元素都包含一对键对象和值对象，而之对象仍可以是Map类型。以此类推，这样就形成了多级映射。向Map集合中加入元素时，必须提供一对键对象和值对象，从Map集合上检索元素只要给出键对象，就会返回值对象。 实例1 CollectionAll.java
帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记，添加批注？ Java 中集合?用法总结（转载） wade0564 收录于2010-07-08 阅读数：查看 收藏数：7 公众公开 原文来源 tags ： java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章，想收藏这篇好文章吗，赶快 吧，1分钟拥有自己的个人图书馆！ 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList （异步，线程不安全，空间用完时自动增长原容量一半）│└Vector （同 步，线程安全，空间用完时自动增长原容量一倍）│ └Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口： | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条 | 目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为 可终止的，被终 | 止，然后被回收。丢弃某个键时， 其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序，或?根据创建映射时提供的 Comparator 进行 排序，具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了 | 非同步和允许 使用 null 之外，HashMap 类与 Hashtable ?致相同。）此类不保证映射的顺序，特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的，或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet 、keySet 和 values 方法返回 ）进行迭代时，此顺序就会反映 出来。要采用此排序方式，还需要提供一些其他操作（此接?是 SortedSet 的对应映 射）。 Collection 接口： | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味，有多少男人可以读懂？珍稀的白头叶猴（组图）三鹿门事件之——中国，...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品：守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语，十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事
java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和V ector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将List 看作是具有数值键的Map。而实际上，除了List 和Map 都在定义java.util 中外，两者并没有直接的联系。本文将着重介绍核心Java 发行套件中附带的Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用Map。 了解Map 接口和方法 Java 核心类中有很多预定义的Map 类。在介绍具体实现之前，我们先介绍一下Map 接口本身，以便了解所有实现的共同点。Map 接口定义了四种类型的方法，每个Map 都包含这些方法。下面，我们从两个普通的方法（表1）开始对这些方法加以介绍。 表1：覆盖的方法。我们将这Object 的这两个方法覆盖，以正确比较Map 对象的等价性。 Map 构建 Map 定义了几个用于插入和删除元素的变换方法（表2）。 表2：Map 更新方法：可以更改Map 内容。 尽管您可能注意到，纵然假设忽略构建一个需要传递给putAll() 的Map 的开销，使用putAll() 通常也并不比使用大量的put() 调用更有效率，但putAll() 的存在一点也不稀奇。这是因为，putAll() 除了迭代put() 所执行的将每个键值对添加到Map 的算法以外，还需要迭代所传递的Map 的元素。但应注意，putAll() 在添加所有元素之前可以正确调整Map 的大小，因此如果您未亲自调整Map 的大小（我们将对此进行简单介绍），则putAll() 可能比预期的更有效。 查看Map 迭代Map 中的元素不存在直接了当的方法。如果要查询某个Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该Map 的“视图”。有三种可能的视图（参见表3） 所有键值对—参见entrySet() 所有键—参见keySet() 所有值—参见values() 前两个视图均返回Set 对象，第三个视图返回Collection 对象。就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代Collection 对象或Set 对象。要进行迭代，
Java集合体系结构分析与比较 1. Java集合框架图 Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型. Java集合框架图如下: 集合接口:6个接口(短虚线表示),表示不同集合类型,是集合框架的基础. 抽象类:5个抽象类(长虚线表示),对集合接口的部分实现.可扩展为自定义集合类. 实现类:8个实现类(实线表示),对接口的具体实现. 在很大程度上,一旦您理解了接口,您就理解了框架.虽然您总要创建接口特定的实现,但访问实际集合的方法应该限制在接口方法的使用上;因此,允许您更改基本的数据结构而不必改变其它代码. Java集合的顶层接口是Collection,Collection 接口是一组允许重复的对象.Java集合框架主要由以下三个接口组成: (1) Set 接口继承Collection,但不允许重复,使用自己内部的一个排列机制. (2) List 接口继承Collection,允许重复,以元素安插的次序来放置元素,不会重新排列.
(3) Map接口是一组成对的键-值对象,即所持有的是 key-value pairs.Map中不能有重复的key,拥有自己的内部排列机制. 容器中的元素类型都为Object,从容器取得元素时,必须把它转换成原来的类型.简化后的集合框架图如下: 2. 接口Collection 用于表示任何对象或元素组,想要尽可能以常规方式处理一组元素时,就使用这一接口. (1) 单元素添加、删除操作: boolean add(Object o):将对象添加给集合 boolean remove(Object o): 如果集合中有与o相匹配的对象,则删除对象o (2) 查询操作: int size():返回当前集合中元素的数量 boolean isEmpty():判断集合中是否有任何元素 boolean contains(Object o):查找集合中是否含有对象o Iterator iterator():返回一个迭代器,用来访问集合中的各个元素 (3) 组操作:作用于元素组或整个集合 boolean containsAll(Collection c): 查找集合中是否含有集合c 中所有元素 boolean addAll(Collection c) : 将集合c 中所有元素添
java中HashMap详解 HashMap 和HashSet 是Java Collection Framework 的两个重要成员，其中HashMap 是Map 接口的常用实现类，HashSet 是Set 接口的常用实现类。虽然HashMap 和HashSet 实现的接口规范不同，但它们底层的Hash 存储机制完全一样，甚至HashSet 本身就采用HashMap 来实现的。 通过HashMap、HashSet 的源代码分析其Hash 存储机制 实际上，HashSet 和HashMap 之间有很多相似之处，对于HashSet 而言，系统采用Hash 算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；对于HashMap 而言，系统key-value 当成一个整体进行处理，系统总是根据Hash 算法来计算key-value 的存储位置，这样可以保证能快速存、取Map 的key-value 对。 在介绍集合存储之前需要指出一点：虽然集合号称存储的是Java 对象，但实际上并不会真正将Java 对象放入Set 集合中，只是在Set 集合中保留这些对象的引用而言。也就是说：Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的Java 对象。 集合和引用 就像引用类型的数组一样，当我们把Java 对象放入数组之时，并不是真正的把Java 对象放入数组中，只是把对象的引用放入数组中，每个数组元素都是一个引用变量。
HashMap 的存储实现 当程序试图将多个key-value 放入HashMap 中时，以如下代码片段为例： Java代码 1. HashMap
一、集合框架和泛型 1.集合框架 (1)定义：java中的集合是指一系列存储数据的接口和类，这些类和接口都位于java.util包 中 (2)原因(为什么使用集合框架)：a、数组的大小是固定的；b、数组保存数据类型是单一的； c、数组操作数据比较复杂 (3)分类：主要有Collection、Map两个接口组成。 Collection接口是集合中最大的接口（与Map接口是等级并列关系）
Collection接口的常用方法，所有的List Set都有这些方法 <1>Collection 接口存储一组不唯一、无序的对象. <2>List 接口存储一组不唯一、有序的对象. <3>Set 接口存储一组唯一、无序的对象. <4>Map 接口存储一组键值对象, 提供key-value(k-v)的映射. <5>Iterator:迭代器. <6>Collections:工具类.（提供了对集合进行排序、遍历等多种算法实现） 2、List 接口. List 接口的实现类: <1>ArrayList:实现了长度可变的数组,在内存中分配连续的空间,遍历元素和随机访问元素效率高. *常用方法：
<2>LinkedList:采用了链表存储方式,插入、删除元素是效率较高. *常用方法： 3、Set接口 <1>存储唯一、无序的对象. <2>Set 里面存放的是对象的引用. <3>采用equals()方法比较两个对象是否为同一对象. <4>Set是接口，没法new，不存在get()方法（因为set无序）
set接口中的数据不能通过下标去访问 遍历集合：转换成数组增强型for 迭代器 Set 接口的实现类: HashSet HashSet集合的特点：集合内的元素是无序排列的 HashSet类是非线性安全的 允许集合元素值为null 4、Iterator接口 <1>增强型for <2>迭代器Iterator *获取Iterator：Collection 接口的iterate()方法. *Iterator 的方法: *boolean hasNext(): 判断是否存在另一个可访问的元素. *Object next(): 返回要访问的下一个元素. 5、Map 接口. Map 接口存储一组成对的键key 值value Key：唯一无序value：不唯一无序 (1) 以键值对形式存储数据（2）不允许出现重复键(3) 元素存储顺序无序Map 接口实现类: <1>HashMap. *常用方法: