association

2008年3月9日

Java Map 集合类简介
作者:Jack Shirazi

了解最常用的集合类型之一 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 所有元素的数组对象,因此除了确实需要使用数组中元素的情形外,其效率并不高。

我运行了一个小测试(随附文件中的 Test1),该测试使用了 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,以及随附文件中的 Test2 类)。

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,以及随附文件中的 Test2)。 因此,如果 containsValue() 是应用程序中的性能问题,它将很快显现出来,并可以通过监测您的应用程序轻松地将其识别。 这种情况下,我相信您能够想出一个有效的替换方法来实现 containsValue() 提供的等效功能。 但如果想不出办法,则一个可行的解决方案是再创建一个 Map,并将第一个 Map 的所有值作为键。 这样,第一个 Map 上的 containsValue() 将成为第二个 Map 上更有效的 containsKey()。

图 1
图 1: 使用 JDeveloper 创建并运行 Map 测试类

 

图 2
图 2: 在 JDeveloper 中使用执行监测器进行的性能监测查出应用程序中的瓶颈

 

核心 Map

Java 自带了各种 Map 类。 这些 Map 类可归为三种类型:

  1. 通用 Map,用于在应用程序中管理映射,通常在 java.util 程序包中实现
    • HashMap
    • Hashtable
    • Properties
    • LinkedHashMap
    • IdentityHashMap
    • TreeMap
    • WeakHashMap
    • ConcurrentHashMap
  2. 专用 Map,您通常不必亲自创建此类 Map,而是通过某些其他类对其进行访问
    • java.util.jar.Attributes
    • javax.print.attribute.standard.PrinterStateReasons
    • java.security.Provider
    • java.awt.RenderingHints
    • javax.swing.UIDefaults
  3. 一个用于帮助实现您自己的 Map 类的抽象类
    • 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
图 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 显示了结果,并将所有时间标准化为已预先设置大小的服务器模式(关联文件中的 Test3)。 对于已预先设置大小的 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 能够通过减少冲突数来提高执行效率。 虽然我所做的测试(关联文件中的Test4)并未表明质数可以始终获得更好的效率,但理想情形是容量取质数。 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 程序包 (http://gee.cs.oswego.edu/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 性能调整”的作者,以及受欢迎的 JavaPerformanceTuning.com 网站(提供 Java 性能信息的全球知名站点)的总监。 Jack 在 Java 性能领域提供咨询并著书立说。 他还监督 JavaPerformanceTuning.com 提供的信息,其中包括每年大约发布 1000 条性能技巧以及许多有关性能工具、讨论组等内容的文章。 Jack 早年还曾发布有关蛋白质结构预测以及黑洞热力学方面的文章,而且在其空闲时还对某些 Perl5 核心模块作出了贡献。

摘自:http://www.oracle.com/technology/global/cn/pub/articles/maps1.html
posted @ 2008-03-09 22:04 扬扬 阅读(336) | 评论 (0)编辑 收藏

2008年3月8日


AraryList学习总结
在大多数的计算机语言中,我们在申明一个数组的时候必须首先固定数组的大小,否则编译会出错,但是在很多时候,我们事先并不能确定数组的大小,这时为了保证程序能够顺利的运行我们可能不得不尽量将数组的长度定的很大,这样当数组的实际长度比较小时,就会浪费掉很多资源。为了解决在程序运行时动态改变数组大小地问题,在java中提供了这样一个类ArrayList,它能够实现与数组同样的功能,并能够动态地改变大小,就像一个能够自己伸缩的容器一样,如气球,呵呵。
1. 工作原理
在ArrayList有一个内部数组,专门用来存放放在ArrayList中的对象的reference。我
们不断调用ArrayList的add(Object object)方法增加对象,最终那个内部数组会full,这个时候“神奇”发生了,ArrayList会自动创建一个更大的内部数组把那些references从较小的数组中拷贝过来同时把要add的那个对象也塞进去,当然这样会引起额外的开销。
从这个原理来看,我认为在使用ArrayList的时候最好在构造它的时候指定一个初始容量或者通过调用ensureCapacity(int i)指定一个容易,这样在达到预设的容量之前,都不会有额外的开销,否则的话每增加一个新的对象都会引起额外的开销。当ArrayList的大小(size)不会再发生变化时,我们可以调用ArrayList的trimToSize()方法来降低ArrayList的存储容量至其实际存储容量(即size的大小)。打个比方,我们初始化一个ArrayList时指定了其容量为100,但最终它只存放了60个对象,这个时候通过调用trimToSize()方法,就可以刚好把存储空间调整为存放60个对象所需的大小,多余的空间将由垃圾回收器负责回收。请注意,只有当你确定ArrayList的大小(size)不再变化的时候才调用trimToSize()方法,否则,当你再增加新的对象就会引起额外的开销。
2. 操作ArrayList
在ArrayList被构造好之后,我们就可以利用它的方法对其中的对象进行操作了,包括
增删改查等等。通过使用泛型,我们可以很好的把ArrayList灵活的增长性和数组方便的存取访问结合起来。例如,我声明了一个泛型,ArrayList<Stirng> test =new ArrayList<String>();在通过add方法加入了若干个String对象后,就可以通过如下代码把其转化为一个String数组:String str[]=new String[test.size()];test.toArray(str)。这样test中的元素都到str中了,可以很方便的存取了。(注:泛型是JDK5.0的新特性,以后会专门单独学习总结)

本贴来自ZDNetChina中文社区 http://bbs.zdnet.com.cn ,本贴地址:http://bbs.zdnet.com.cn/viewthread.php?tid=226817

 

 

posted @ 2008-03-08 10:48 扬扬 阅读(169) | 评论 (0)编辑 收藏

2008年3月7日

使用JDOM操作XML系列文章四 使用JDOM和XPATH结合查询

package jing.xml;
/**
* <p>Title: 使用JDOM和XPATH结合查询</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author 欧朝敬 13873195792
* @version 1.0
*/
import org.jdom.*;
import org.jdom.output.*;
import org.jdom.input.*;
import org.jdom.xpath.*;

import java.io.*;
import java.util.*;

public class TreeXML {
public TreeXML() {
}

public static void main(String[] args) throws Exception {
SAXBuilder sb = new SAXBuilder(); // 新建立构造器
Document doc = sb.build(new FileInputStream("company.xml")); // 读入文件
Element root = doc.getRootElement(); // 获得根元素element
List row = root.getChildren(); //取得节点列表 编程大本营HTTp://www.timihome.net
//按CID查找直接定位到ROW元素返回的是集合
List find = XPath.selectNodes(root, "/ROOT/ROW[@PID=&acute;1&acute;]");
for (int i = 0; i < find.size(); i++) {
Element findelement = (Element) find.get(i);
System.out.println(findelement.getAttributeValue("CNAME"));
}

//多条件查询
Element findelement=(Element)XPath.selectSingleNode(root,"/ROOT/ROW[@PID=&acute;3&acute;][@CID=&acute;10&acute;]");
System.out.println(findelement.getAttributeValue("CNAME"));

XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat()); //格式华输出,产生缩进和换行

//重新格式化
Format format = outp.getFormat();
format.setEncoding("GB2312");
format.setExpandEmptyElements(true);
outp.setFormat(format);

//outp.output(doc, new FileOutputStream("jdomcompany.xml")); //输出XML文档
outp.output(doc, System.out);
System.out.println("JDOM操作XML文档完毕!");
}

编程大本营


}
  

   本页摘自URL地址: http://www.timihome.net/html/java/java_j2ee/20070625/3824.html
posted @ 2008-03-07 17:46 扬扬 阅读(218) | 评论 (0)编辑 收藏
使用JDOM操作XML系列文章三 平面式XML文件转层叠式XML文件
package jing.xml;
/**
* <p>Title: 平面式XML文件转层叠式XML文件</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author 欧朝敬 13873195792
* @version 1.0
*/
import org.jdom.*;
import org.jdom.output.*;
import org.jdom.input.*;
import org.jdom.xpath.*;
import java.io.*;
import java.util.*;

public class xmltotree {
public SAXBuilder sb = null;
public Document doc = null;
public Element root = null;
public xmltotree() throws Exception {
sb = new SAXBuilder(); // 新建立构造器
doc = sb.build(new FileInputStream("company.xml")); // 读入文件
root = doc.getRootElement(); // 获得根元素element

}

public void Listelemnet(String pid, Element element) throws Exception { 不能采集本站
List find = XPath.selectNodes(root, "/ROOT/ROW[@PID=&acute;" + pid + "&acute;]");
int rowcount = find.size();
for (int i = 0; i < rowcount; i++) {
Element findelement = (Element) find.get(i);
Element element0 = new Element("ROW");
List attrib = findelement.getAttributes();
int j = attrib.size();
for (int h = 0; h < j; h++) {
Attribute attribute = (Attribute) attrib.get(h);
element0.setAttribute(
attribute.getName(),
attribute.getValue());

}
element.addContent(element0);
Listelemnet(findelement.getAttributeValue("CID"), element0);
}
}

public static void main(String[] args) throws Exception {
xmltotree bb = new xmltotree();

Element roote = new Element("ROOT");
Document tdocument = new Document(roote); //创建文档ROOT元素

bb.Listelemnet("0", roote);

XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat()); //格式华输出,产生缩进和换行
编程大本营HTTp://www.timihome.net

Format format = outp.getFormat();
format.setEncoding("GB2312"); //设置语言
format.setExpandEmptyElements(true); //设置输出空元素为<sample></sample>格式
outp.setFormat(format);
outp.output(tdocument, new FileOutputStream("companytree.xml")); //输出XML文档
//outp.output(tdocument,System.out);
System.out.print("XML 文档生成完毕!");
}
} 
  

   本页摘自URL地址: http://www.timihome.net/html/java/java_j2ee/20070625/3823.html
posted @ 2008-03-07 17:45 扬扬 阅读(185) | 评论 (0)编辑 收藏
 

使用JDOM操作XML系列文章二 从数据库中读取记录集到平面式XML文件
package jing.xml;

/**
* <p>Title:
从数据库中读取记录集到平面式XML文件</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author
欧朝敬 13873195792
* @version 1.0
*/

//
将数据库表输出为XML文档
import org.jdom.*;
import org.jdom.output.*;
import java.sql.*;
import java.io.*;

public class databasetoxml {
public databasetoxml() {
}

public static void main(String[] args) throws Exception {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url = "jdbc:oracle:thin:@192.168.128.250:1521:sample";
Connection conn = DriverManager.getConnection(url, "scott", "tiger");

PreparedStatement pstmt = conn.prepareStatement(
"select * from company order by cid",
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pstmt.executeQuery();
Document document = new Document(new Element("ROOT")); //
创建文档ROOT元素
ResultSetMetaData rmd = rs.getMetaData();
int colcount = rmd.getColumnCount();
Element elemnetcol = new Element("COLTYPE");
for (int i = 1; i <= colcount; i++) { //
列属性
elemnetcol.setAttribute(rmd.getColumnName(i),
rmd.getColumnTypeName(i));
}
document.getRootElement().addContent(elemnetcol);

while (rs.next()) { //
不确定表生成XML记录
Element element0 = new Element("ROW");
for (int i = 1; i <= colcount; i++) {
element0.setAttribute(rmd.getColumnName(i),(rs.getString(i)==null?"":rs.getString(i)));
}
document.getRootElement().addContent(element0);
}
rs.close();
pstmt.close();
conn.close();
XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat()); //
格式华输出,产生缩进和换行

Format format = outp.getFormat();
format.setEncoding("GB2312"); //
设置语言
format.setExpandEmptyElements(true); //
设置输出空元素为<sample></sample>格式
outp.setFormat(format);

outp.output(document, new FileOutputStream("company.xml")); //
输出XML文档
System.out.print("XML
文档生成完毕!");
}
}
 

本页摘自URL地址: http://www.timihome.net/html/java/java_j2ee/20070625/3822.html
posted @ 2008-03-07 17:43 扬扬 阅读(148) | 评论 (0)编辑 收藏
 
使用JDOM操作XML系列文章一 从数据库中读取记录集到层叠式XML文

注意本系列文件使用环境:ORACLE数据和JDOM1.0版本
总计四篇文件中都使用到以下表和数据。
Oracle表结构如下:
/*此表中最关键的就是CID和PID两个字段,其它的跟据需要可以增减字段*/
CREATE TABLE SCOTT.COMPANY
(
CID NUMBER(4) NOT NULL, /*记录ID号*/
CNAME VARCHAR2(20) NOT NULL, /*名字*/
DESCPT VARCHAR2(40) NULL, /*描述*/
PID NUMBER(4) NULL /*父ID号*/
);
/*向表中插入数据*/
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 1, ´中南迈特´, ´湖南省长沙市´, 0 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 2, ´系统集成´, ´各种系统集成´, 1 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 3, ´软件开发´, ´软件开发´, 1 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 6, ´NetOA开发组´, ´Net项目开发´, 3 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 7, ´王军´, ´J2EE组王军´, 5 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 8, ´湘红´, ´J2EE组湘红´, 5 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 9, ´Windows集成组´, ´Windows系统集成´, 2 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 10, ´Linux集成组´, ´Linux相关系统集成´, 2 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 11, ´王非´, ´Linux组´, 10 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 12, ´张万´, ´NetOA组´, 6 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 13, ´李兵´, ´J2EE李兵´, 5 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 14, ´武成´, ´Linux组´, 10 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 4, ´人事部´, ´公司人事管理部门´, 1 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 5, ´J2EE项目组´, ´J2EE项目开发´, 3 );
INSERT
INTO company( company.cid, company.cname, company.descpt, company.pid )
VALUES( 15, ´王义´, ´J2EE组王义´, 5 );


package jing.xml;

/**
* <p>Title: 从数据库中读取记录集到层叠XML文件</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author 欧朝敬 13873195792
* @version 1.0
*/

//将数据库表输出为XML文档
import org.jdom.*;
import org.jdom.output.*;
import java.sql.*;
import java.io.*;

public class dbtoxmltree {
public String url = null;
public Connection conn = null;
public Document document = null;
public dbtoxmltree() throws Exception {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
url = "jdbc:oracle:thin:@192.168.128.250:1521:sample";
conn = DriverManager.getConnection(url, "scott", "tiger");
}

public void digui(int pid,Element element) throws Exception {
String sql = "select * from company where pid=" + pid;
PreparedStatement pstmt = conn.prepareStatement(
sql,
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pstmt.executeQuery();
ResultSetMetaData rmd = rs.getMetaData();
int colcount = rmd.getColumnCount();
while (rs.next()) {
Element element0 = new Element("DSTree");
for(int i=1;i<=colcount;i++){
element0.setAttribute(rmd.getColumnName(i),
(rs.getString(i) == null ? "" :
rs.getString(i)));
}
element0.setAttribute("open","false");
element.addContent(element0);
digui(rs.getInt("CID"),element0);
}
rs.close();
pstmt.close();

}

public static void main(String[] args) throws Exception {
dbtoxmltree dbxml = new dbtoxmltree();
Element root=new Element("DSTreeRoot");
dbxml.document=new Document(root);//创建文档ROOT元素
PreparedStatement pstmt = dbxml.conn.prepareStatement(
"select * from company order by cid",
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pstmt.executeQuery();

ResultSetMetaData rmd = rs.getMetaData();
int colcount = rmd.getColumnCount();
Element elementcol = new Element("COLTYPE");
for (int i = 1; i <= colcount; i++) { //列属性
elementcol.setAttribute(rmd.getColumnName(i),
rmd.getColumnTypeName(i));
}
root.addContent(elementcol);
rs.close();
pstmt.close();

dbxml.digui(0,root);

dbxml.conn.close();
XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat()); //格式华输出,产生缩进和换行
Format format = outp.getFormat();
format.setEncoding("GB2312"); //设置语言
format.setExpandEmptyElements(true); //设置输出空元素为<sample></sample>格式
outp.setFormat(format);

outp.output(dbxml.document, new FileOutputStream("companytree.xml")); //输出XML文档

System.out.print("XML 文档生成完毕!");
}
}
摘自:
http://www.timihome.net/html/java/java_j2ee/20070625/3821.html

posted @ 2008-03-07 17:41 扬扬 阅读(150) | 评论 (0)编辑 收藏

2008年3月5日

Previous Next

一个定位路径表达式返回一个节点集。


定位路径表达式

一个定位路径可以是绝对的或相对的。

绝对定位路径以一个斜线(/)开头,而相对定位路径没有。两种情况下,定位路径由一个或多个定位步骤组成,每个步骤由一个斜线分隔:

一个绝对定位路径:
/step/step/...
一个相对定位路径:
step/step/...

定位步骤从左到右,依次按顺序计算。每个步骤根据当前节点集的节点计算。如果定位路径是绝对的,那么当前节点集包含根节点。如果定位路径是相对的,那么当前节点集包含使用表达式的节点。定位步骤包括:

  • 一个轴(指定当前定位步骤和当前节点选择的节点间的树关系)
  • 一个节点测试(指定定位步骤选择的节点的节点类型和扩展名)
  • 零或多个预测(使用表达式进一步抽取定位步骤选定的节点集)

一个定位步骤的语法为:

轴名::节点测试[预测]

示例:

child::price[price=9.90]


轴和节点测试

一个轴定义相对于当前节点的节点集。节点测试用于识别轴内的一个节点。我们可以通过名或类型来执行一个节点测试。

轴名 描述
ancestor

包含当前节点的所有祖先节点

注意: 除非当前节点是根节点,否则这个轴始终包括根节点

ancestor-or-self 包括当前节点和所有当前节点的祖先节点
attribute 包含当前节点所有的属性
child 包含当前节点所有的子节点
descendant

包含当前节点的所有后代节点

注意:这个轴不包括属性或命名空间节点

descendant-or-self 包含当前节点本身和所有它的后代节点
following 包含文档中当前节点的结束标记后所有节点
following-sibling 包含当前节点后所有的同层节点

注意: 如果当前节点是属性节点或命名空间节点,那么这个轴为空

namespace 包含当前节点的所有命名空间节点
parent 包含当前节点的所有父节点
preceding 包含文档中当前节点的开始标记之前的所有节点
preceding-sibling 包含当前节点之前的所有同层节点

注意: 如果当前节点是一个属性节点或者命名空间节点,那么这个轴为空

self 当前节点本身

示例

示例 结果
child::cd 选择当前节点的子节点中所有的cd元素(如果当前节点没有cd子节点,那么将返回一个空节点集)
attribute::src 选择当前节点的src属性(如果当前节点没有src属性,那么返回一个空节点集)
child::* 选择当前节点的所有子元素
attribute::* 选择当前节点的所有属性
child::text() 选择当前节点的文本节点子节点
child::node() 选择当前节点的所有子节点
descendant::cd 选择当前节点的后代中所有cd元素
ancestor::cd 选择当前节点的祖先节点中所有cd元素
ancestor-or-self::cd 选择当前节点的祖先节点中所有cd元素,如果当前节点是一个cd元素,那么也包括当前节点
child::*/child::price

选择当前节点的孙子节点中所有price元素

/ 选择文档根


预测

一个预测过滤一个节点集为一个新的节点集。预测放在方括号([])中。

示例

示例 结果
child::price[price=9.90] 选择当前节点的子节点中price元素等于9.90的所有价格元素
child::cd[position()=1] 选择当前节点的第一个cd子元素
child::cd[position()=last()] 选择当前节点的最后一个cd子元素
child::cd[position()=last()-1] 选择当前节点的倒第二个cd元素
child::cd[position()<6] 选择当前节点的前五个cd元素
/descendant::cd[position()=7] 选择文档中第七个cd元素
child::cd[attribute::type="classic"] 选择当前节点的所有type属性等于classic的cd子节点


定位路径缩写语法

定位路径可以用缩写表示。

最重要的缩写为:child::可以从一个定位步骤中省略。

缩写 含义 示例
none child:: cd是child::cd的简写
@ attribute:: cd[@type="classic"]是child::cd[attribute::type="classic"]的简写
. self::node() .//cd是self::node()/descendant-or-self::node()/child::cd的简写
.. parent::node()

../cd是parent::node()/child::cd的简写

// /descendant-or-self::node()/ //cd是/descendant-or-self::node()/child::cd的简写

示例

示例 结果
cd 选择当前节点的子节点中所有cd元素
* 选择当前节点的所有子元素
text() 选择当前节点的子节点中所有文本节点
@src 选择当前节点的所有src属性
@* 选择当前节点的所有属性
cd[1] 选择当前节点的第一个cd子节点
cd[last()] 选择当前节点的最后一个cd子节点
*/cd 选择当前节点的所有cd孙子节点
/book/chapter[3]/para[1] 选择book节点的第三个chapter子节点的第一个para子节点
//cd 选择所有文档根的所有cd元素后代,因而在同一个文档选择所有的cd元素作为当前节点
. 选择当前节点
.//cd 选择当前节点的cd元素后代
.. 选择当前节点的父亲节点
../@src 选择当前节点的父节点的src属性
cd[@type="classic"] 选择当前节点的子节点中type属性等于classic的所有cd子节点
cd[@type="classic"][5] 选择当前节点的子节点中type属性等于classic的cd子节点中第五个节点
cd[5][@type="classic"] 选择当前节点的第五个cd子节点,如果该子节点的type属性等于classic
cd[@type and @country] 选择当前节点的子节点中由type和country两个属性的所有cd子节点
摘自:
http://61.139.52.111:8090/kj/Manfeel/oltl/session1/session1-p03.htm

Previous Next
posted @ 2008-03-05 10:16 扬扬 阅读(1185) | 评论 (0)编辑 收藏

XPath语法

Previous Next

XPath使用路径表达式定位XML文档内的节点。


XML示例文档

我们将使用如下的简单XML文档描述XPath语法:

<?xml version="1.0" encoding="ISO-8859-1"?>
            <catalog>
            <cd country="USA">
            <title>Empire Burlesque</title>
            <artist>Bob Dylan</artist>
            <price>10.90</price>
            </cd>
            <cd country="UK">
            <title>Hide your heart</title>
            <artist>Bonnie Tyler</artist>
            <price>9.90</price>
            </cd>
            <cd country="USA">
            <title>Greatest Hits</title>
            <artist>Dolly Parton</artist>
            <price>9.90</price>
            </cd>
            </catalog>


定位节点

XML文档可以看作是一个节点树(非常类似于计算机的树形文件夹)。

XPath使用模式表达式识别XML文档里的节点。一个XPath模式是一个以斜线分隔的子元素名列表,用于描述XML文档的一个路径。模式选择匹配该路径的元素。

下面的XPath表达式选择catalog元素的所有cd元素的所有price元素:

/catalog/cd/price

注意: 如果路径以一个斜线(/)开始,代表相对于一个元素的绝对路径

注意: 如果路径以两个斜线开始,表示选择文档中所有符合该条件的元素(即使它们在不同的XML树的级别)!

下面的XPath表达式选择文档中所有的cd元素:

//cd



选择未知元素

通配符(*)用来选择未知XML元素。

下面的XPath表达式选择catalog元素下所有cd元素的所有子元素:

/catalog/cd/*

下面的XPath表达式选择catalog元素的孙子元素下所有的price元素:

/catalog/*/price

下面的XPath表达式选择有两个祖先的所有price元素:

/*/*/price

下面的XPath表达式选择文档中所有元素:

//*



选择分支

通过在XPath表达式中使用方括号可以进一步地指定一个元素。

下面的XPath表达式选择catalog元素的第一个cd子元素:

/catalog/cd[1]

下面的XPath表达式选择catalog元素的最后一个子元素(注意:没有first()函数):

/catalog/cd[last()]

下面的XPath表达式选择catalog元素下含有price子元素的所有cd元素:

/catalog/cd[price]

下面的XPath表达式选择catalog元素下子元素price值等于10.90的所有cd元素:

/catalog/cd[price=10.90]

下面的XPath表达式选择catalog元素下price元素值等于10.90的所有cd元素的price元素:

/catalog/cd[price=10.90]/price



选择多个路径

通过在XPath表达式中使用|操作符,可以选择多个路径。

下面的XPath表达式选择catalog元素的子元素cd元素下所有的title和artist元素:

/catalog/cd/title | /catalog/cd/artist

下面的XPath表达式选择文档中所有title元素和artist元素:

//title | //artist

下面的XPath表达式选择文档中所有title、artist、price元素:

//title | //artist | //price

下面的XPath表达式选择catalog元素的cd子元素下所有的title元素,以及文档中所有的artist元素:

/catalog/cd/title | //artist



选择属性

在XPath中,所有属性以前缀@指定。

下面的XPath表达式选择所有名为country的属性:

//@country

下面的XPath表达式选择所有含有country属性的cd元素:

//cd[@country]

下面的XPath表达式选择选择所有含有任何属性的cd元素:

//cd[@*]

下面的XPath表达式选择属性country等于UK的所有cd元素:

//cd[@country='UK']

摘自:
http://61.139.52.111:8090/kj/Manfeel/oltl/session1/session1-p02.htm
posted @ 2008-03-05 10:12 扬扬 阅读(489) | 评论 (0)编辑 收藏
仅列出标题  

导航

<2019年10月>
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789

统计

常用链接

留言簿(1)

随笔档案

搜索

最新评论

阅读排行榜

评论排行榜