# 2.2-新集合类型
[原文链接](https://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained) [译文链接](http://ifeve.com/google-guava-newcollectiontypes) **译者:**沈义扬,校对:丁一
Guava引入了很多JDK没有的、但我们发现明显有用的新集合类型。这些新类型是为了和JDK集合框架共存,而没有往JDK集合抽象中硬塞其他概念。作为一般规则,Guava集合非常精准地遵循了JDK接口契约。
## Multiset
统计一个词在文档中出现了多少次,传统的做法是这样的:
```
Map<String, Integer> counts = new HashMap<String, Integer>();
for (String word : words) {
Integer count = counts.get(word);
if (count == null) {
counts.put(word, 1);
} else {
counts.put(word, count + 1);
}
}
```
这种写法很笨拙,也容易出错,并且不支持同时收集多种统计信息,如总词数。我们可以做的更好。
Guava提供了一个新集合类型 [Multiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multiset.html),它可以多次添加相等的元素。维基百科从数学角度这样定义Multiset:”集合[set]概念的延伸,它的元素可以重复出现…与集合[set]相同而与元组[tuple]相反的是,Multiset元素的顺序是无关紧要的:Multiset {a, a, b}和{a, b, a}是相等的”。——_译者注:这里所说的集合__[set]是数学上的概念,Multiset继承自JDK中的Collection接口,而不是Set接口,所以包含重复元素并没有违反原有的接口契约。_
可以用两种方式看待Multiset:
* 没有元素顺序限制的ArrayList<E>
* Map<E, Integer>,键为元素,值为计数
Guava的Multiset API也结合考虑了这两种方式:
当把Multiset看成普通的Collection时,它表现得就像无序的ArrayList:
* add(E)添加单个给定元素
* iterator()返回一个迭代器,包含Multiset的所有元素(包括重复的元素)
* size()返回所有元素的总个数(包括重复的元素)
当把Multiset看作Map<E, Integer>时,它也提供了符合性能期望的查询操作:
* count(Object)返回给定元素的计数。HashMultiset.count的复杂度为O(1),TreeMultiset.count的复杂度为O(log n)。
* entrySet()返回Set<Multiset.Entry<E>>,和Map的entrySet类似。
* elementSet()返回所有不重复元素的Set<E>,和Map的keySet()类似。
* 所有Multiset实现的内存消耗随着不重复元素的个数线性增长。
值得注意的是,除了极少数情况,Multiset和JDK中原有的Collection接口契约完全一致——具体来说,TreeMultiset在判断元素是否相等时,与TreeSet一样用compare,而不是Object.equals。另外特别注意,Multiset.addAll(Collection)可以添加Collection中的所有元素并进行计数,这比用for循环往Map添加元素和计数方便多了。
| **方法** | **描述** |
|:--- |:--- |
| [count(E)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multiset.html#count%28java.lang.Object%29) | 给定元素在Multiset中的计数 |
| [elementSet()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multiset.html#elementSet%28%29) | Multiset中不重复元素的集合,类型为Set<E> |
| [entrySet()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multiset.html#entrySet%28%29) | 和Map的entrySet类似,返回Set<Multiset.Entry<E>>,其中包含的Entry支持getElement()和getCount()方法 |
| [add(E, int)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multiset.html#add%28java.lang.Object,int%29) | 增加给定元素在Multiset中的计数 |
| [remove(E, int)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multiset.html#remove%28java.lang.Object, int%29) | 减少给定元素在Multiset中的计数 |
| [setCount(E, int)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multiset.html#setCount%28E, int%29) | 设置给定元素在Multiset中的计数,不可以为负数 |
| size() | 返回集合元素的总个数(包括重复的元素) |
### Multiset不是Map
请注意,Multiset<E>不是Map<E, Integer>,虽然Map可能是某些Multiset实现的一部分。准确来说Multiset是一种Collection类型,并履行了Collection接口相关的契约。关于Multiset和Map的显著区别还包括:
* Multiset中的元素计数只能是正数。任何元素的计数都不能为负,也不能是0。elementSet()和entrySet()视图中也不会有这样的元素。
* multiset.size()返回集合的大小,等同于所有元素计数的总和。对于不重复元素的个数,应使用elementSet().size()方法。(因此,add(E)把multiset.size()增加1)
* multiset.iterator()会迭代重复元素,因此迭代长度等于multiset.size()。
* Multiset支持直接增加、减少或设置元素的计数。setCount(elem, 0)等同于移除所有elem。
* 对multiset 中没有的元素,multiset.count(elem)始终返回0。
### Multiset的各种实现
Guava提供了多种Multiset的实现,大致对应JDK中Map的各种实现:
| **Map** | **对应的****Multiset** | **是否支持****null****元素** |
|:--- |:--- |:--- |
| HashMap | [HashMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/HashMultiset.html) | 是 |
| TreeMap | [TreeMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/TreeMultiset.html) | 是(如果comparator支持的话) |
| LinkedHashMap | [LinkedHashMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/LinkedHashMultiset.html) | 是 |
| ConcurrentHashMap | [ConcurrentHashMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ConcurrentHashMultiset.html) | 否 |
| ImmutableMap | [ImmutableMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableMultiset.html) | 否 |
### SortedMultiset
[SortedMultiset](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/SortedMultiset.html)是Multiset 接口的变种,它支持高效地获取指定范围的子集。比方说,你可以用 latencies.subMultiset(0,BoundType.CLOSED, 100, BoundType.OPEN).size()来统计你的站点中延迟在100毫秒以内的访问,然后把这个值和latencies.size()相比,以获取这个延迟水平在总体访问中的比例。
TreeMultiset实现SortedMultiset接口。在撰写本文档时,ImmutableSortedMultiset还在测试和GWT的兼容性。
## Multimap
每个有经验的Java程序员都在某处实现过Map<K, List<V>>或Map<K, Set<V>>,并且要忍受这个结构的笨拙。例如,Map<K, Set<V>>通常用来表示非标定有向图。Guava的 [Multimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html)可以很容易地把一个键映射到多个值。换句话说,Multimap是把键映射到任意多个值的一般方式。
可以用两种方式思考Multimap的概念:”键-单个值映射”的集合:
```
a -> 1 a -> 2 a ->4 b -> 3 c -> 5
```
或者”键-值集合映射”的映射:
```
a -> [1, 2, 4] b -> 3 c -> 5
```
一般来说,Multimap接口应该用第一种方式看待,但asMap()视图返回Map<K, Collection<V>>,让你可以按另一种方式看待Multimap。重要的是,不会有任何键映射到空集合:一个键要么至少到一个值,要么根本就不在Multimap中。
很少会直接使用Multimap接口,更多时候你会用ListMultimap或SetMultimap接口,它们分别把键映射到List或Set。
### 修改Multimap
[Multimap.get(key)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html#get%28K%29)以集合形式返回键所对应的值视图,即使没有任何对应的值,也会返回空集合。ListMultimap.get(key)返回List,SetMultimap.get(key)返回Set。
对值视图集合进行的修改最终都会反映到底层的Multimap。例如:
```
Set<Person> aliceChildren = childrenMultimap.get(alice);
aliceChildren.clear();
aliceChildren.add(bob);
aliceChildren.add(carol);
```
其他(更直接地)修改Multimap的方法有:
| **方法签名** | **描述** | **等价于** |
|:--- |:--- |:--- |
| [put(K, V)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#put%28K, V%29) | 添加键到单个值的映射 | multimap.get(key).add(value) |
| [putAll(K, Iterable<V>)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#putAll%28K, java.lang.Iterable%29) | 依次添加键到多个值的映射 | Iterables.addAll(multimap.get(key), values) |
| [remove(K, V)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#remove%28java.lang.Object, java.lang.Object%29) | 移除键到值的映射;如果有这样的键值并成功移除,返回true。 | multimap.get(key).remove(value) |
| [removeAll(K)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#removeAll%28java.lang.Object%29) | 清除键对应的所有值,返回的集合包含所有之前映射到K的值,但修改这个集合就不会影响Multimap了。 | multimap.get(key).clear() |
| [replaceValues(K, Iterable<V>)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#replaceValues%28K, java.lang.Iterable%29) | 清除键对应的所有值,并重新把key关联到Iterable中的每个元素。返回的集合包含所有之前映射到K的值。 | multimap.get(key).clear(); Iterables.addAll(multimap.get(key), values) |
### Multimap的视图
Multimap还支持若干强大的视图:
* [`asMap`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html#asMap%28%29)为Multimap<K, V>提供Map<K,Collection<V>>形式的视图。返回的Map支持remove操作,并且会反映到底层的Multimap,但它不支持put或putAll操作。更重要的是,如果你想为Multimap中没有的键返回null,而不是一个新的、可写的空集合,你就可以使用asMap().get(key)。(你可以并且应当把asMap.get(key)返回的结果转化为适当的集合类型——如SetMultimap.asMap.get(key)的结果转为Set,ListMultimap.asMap.get(key)的结果转为List——Java类型系统不允许ListMultimap直接为asMap.get(key)返回List——_译者注:也可以用__Multimaps中的asMap静态方法帮你完成类型转换_)
* [`entries`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html#entries%28%29)用Collection<Map.Entry<K, V>>返回Multimap中所有”键-单个值映射”——包括重复键。(对SetMultimap,返回的是Set)
* [`keySet`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html#keySet%28%29)用Set表示Multimap中所有不同的键。
* [`keys`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimap.html#keys%28%29)用Multiset表示Multimap中的所有键,每个键重复出现的次数等于它映射的值的个数。可以从这个Multiset中移除元素,但不能做添加操作;移除操作会反映到底层的Multimap。
* [`values()`](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimap.html#values%28%29)用一个”扁平”的Collection<V>包含Multimap中的所有值。这有一点类似于Iterables.concat(multimap.asMap().values()),但它直接返回了单个Collection,而不像multimap.asMap().values()那样是按键区分开的Collection。
### Multimap不是Map
Multimap<K, V>不是Map<K,Collection<V>>,虽然某些Multimap实现中可能使用了map。它们之间的显著区别包括:
* Multimap.get(key)总是返回非null、但是可能空的集合。这并不意味着Multimap为相应的键花费内存创建了集合,而只是提供一个集合视图方便你为键增加映射值——_译者注:如果有这样的键,返回的集合只是包装了__Multimap中已有的集合;如果没有这样的键,返回的空集合也只是持有Multimap引用的栈对象,让你可以用来操作底层的Multimap。因此,返回的集合不会占据太多内存,数据实际上还是存放在Multimap中。_
* 如果你更喜欢像Map那样,为Multimap中没有的键返回null,请使用asMap()视图获取一个Map<K, Collection<V>>。(或者用静态方法[Multimaps.asMap()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimaps.html#asMap%28com.google.common.collect.ListMultimap%29)为ListMultimap返回一个Map<K, List<V>>。对于SetMultimap和SortedSetMultimap,也有类似的静态方法存在)
* 当且仅当有值映射到键时,Multimap.containsKey(key)才会返回true。尤其需要注意的是,如果键k之前映射过一个或多个值,但它们都被移除后,Multimap.containsKey(key)会返回false。
* Multimap.entries()返回Multimap中所有”键-单个值映射”——包括重复键。如果你想要得到所有”键-值集合映射”,请使用asMap().entrySet()。
* Multimap.size()返回所有”键-单个值映射”的个数,而非不同键的个数。要得到不同键的个数,请改用Multimap.keySet().size()。
### Multimap的各种实现
Multimap提供了多种形式的实现。在大多数要使用Map<K, Collection<V>>的地方,你都可以使用它们:
| **实现** | **键行为类似** | **值行为类似** |
|:--- |:--- |:--- |
| [ArrayListMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ArrayListMultimap.html) | HashMap | ArrayList |
| [HashMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/HashMultimap.html) | HashMap | HashSet |
| [LinkedListMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/LinkedListMultimap.html)* | LinkedHashMap* | LinkedList* |
| [LinkedHashMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/LinkedHashMultimap.html)** | LinkedHashMap | LinkedHashMap |
| [TreeMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/TreeMultimap.html) | TreeMap | TreeSet |
| [`ImmutableListMultimap`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableListMultimap.html) | ImmutableMap | ImmutableList |
| [ImmutableSetMultimap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableSetMultimap.html) | ImmutableMap | ImmutableSet |
除了两个不可变形式的实现,其他所有实现都支持null键和null值
*LinkedListMultimap.entries()保留了所有键和值的迭代顺序。详情见doc链接。
**LinkedHashMultimap保留了映射项的插入顺序,包括键插入的顺序,以及键映射的所有值的插入顺序。
请注意,并非所有的Multimap都和上面列出的一样,使用Map<K, Collection<V>>来实现(特别是,一些Multimap实现用了自定义的hashTable,以最小化开销)
如果你想要更大的定制化,请用[Multimaps.newMultimap(Map, Supplier<Collection>)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/co…ultimaps.html#newMultimap%28java.util.Map,%20com.google.common.base.Supplier%29)或[list](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimaps.html#newListMultimap%28java.util.Map, com.google.common.base.Supplier%29)和 [set](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Multimaps.html#newSetMultimap%28java.util.Map, com.google.common.base.Supplier%29)版本,使用自定义的Collection、List或Set实现Multimap。
## BiMap
传统上,实现键值对的双向映射需要维护两个单独的map,并保持它们间的同步。但这种方式很容易出错,而且对于值已经在map中的情况,会变得非常混乱。例如:
```
Map<String, Integer> nameToId = Maps.newHashMap();
Map<Integer, String> idToName = Maps.newHashMap();
nameToId.put("Bob", 42);
idToName.put(42, "Bob");
//如果"Bob"和42已经在map中了,会发生什么?
//如果我们忘了同步两个map,会有诡异的bug发生...
```
[BiMap<K, V>](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/BiMap.html)是特殊的Map:
* 可以用 [inverse()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/BiMap.html#inverse%28%29)反转BiMap<K, V>的键值映射
* 保证值是唯一的,因此 [values()](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/BiMap.html#values%28%29)返回Set而不是普通的Collection
在BiMap中,如果你想把键映射到已经存在的值,会抛出IllegalArgumentException异常。如果对特定值,你想要强制替换它的键,请使用 [BiMap.forcePut(key, value)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/BiMap.html#forcePut%28java.lang.Object,java.lang.Object%29)。
```
BiMap<String, Integer> userId = HashBiMap.create();
...
String userForId = userId.inverse().get(id);
```
### BiMap的各种实现
| **键****–****值实现** | **值****–****键实现** | **对应的****BiMap****实现** |
|:--- |:--- |:--- |
| HashMap | HashMap | [HashBiMap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/HashBiMap.html) |
| ImmutableMap | ImmutableMap | [ImmutableBiMap](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableBiMap.html) |
| EnumMap | EnumMap | [EnumBiMap](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/EnumBiMap.html) |
| EnumMap | HashMap | [EnumHashBiMap](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/EnumHashBiMap.html) |
注:[Maps](https://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#Maps)类中还有一些诸如synchronizedBiMap的BiMap工具方法.
## Table
```
Table<Vertex, Vertex, Double> weightedGraph = HashBasedTable.create();
weightedGraph.put(v1, v2, 4);
weightedGraph.put(v1, v3, 20);
weightedGraph.put(v2, v3, 5);
weightedGraph.row(v1); // returns a Map mapping v2 to 4, v3 to 20
weightedGraph.column(v3); // returns a Map mapping v1 to 20, v2 to 5
```
通常来说,当你想使用多个键做索引的时候,你可能会用类似Map<FirstName, Map<LastName, Person>>的实现,这种方式很丑陋,使用上也不友好。Guava为此提供了新集合类型[Table](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html),它有两个支持所有类型的键:”行”和”列”。Table提供多种视图,以便你从各种角度使用它:
* [rowMap()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#rowMap%28%29):用Map<R, Map<C, V>>表现Table<R, C, V>。同样的, [rowKeySet()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#rowKeySet%28%29)返回”行”的集合Set<R>。
* [row(r)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#row%28R%29) :用Map<C, V>返回给定”行”的所有列,对这个map进行的写操作也将写入Table中。
* 类似的列访问方法:[columnMap()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#columnMap%28%29)、[columnKeySet()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#columnKeySet%28%29)、[column(c)](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#column%28C%29)。(基于列的访问会比基于的行访问稍微低效点)
* [cellSet()](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.html#cellSet%28%29):用元素类型为[Table.Cell<R, C, V>](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Table.Cell.html)的Set表现Table<R, C, V>。Cell类似于Map.Entry,但它是用行和列两个键区分的。
Table有如下几种实现:
* [HashBasedTable](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/HashBasedTable.html):本质上用HashMap<R, HashMap<C, V>>实现;
* [TreeBasedTable](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/TreeBasedTable.html):本质上用TreeMap<R, TreeMap<C,V>>实现;
* [ImmutableTable](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/ImmutableTable.html):本质上用ImmutableMap<R, ImmutableMap<C, V>>实现;注:ImmutableTable对稀疏或密集的数据集都有优化。
* [ArrayTable](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ArrayTable.html):要求在构造时就指定行和列的大小,本质上由一个二维数组实现,以提升访问速度和密集Table的内存利用率。ArrayTable与其他Table的工作原理有点不同,请参见Javadoc了解详情。
## ClassToInstanceMap
[ClassToInstanceMap](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/ClassToInstanceMap.html)是一种特殊的Map:它的键是类型,而值是符合键所指类型的对象。
为了扩展Map接口,ClassToInstanceMap额外声明了两个方法:[T getInstance(Class<T>)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/ClassToInstanceMap.html#getInstance%28java.lang.Class%29) 和[T putInstance(Class<T>, T)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/…llect/ClassToInstanceMap.html#putInstance%28java.lang.Class,java.lang.Object%29),从而避免强制类型转换,同时保证了类型安全。
ClassToInstanceMap有唯一的泛型参数,通常称为B,代表Map支持的所有类型的上界。例如:
```
ClassToInstanceMap<Number> numberDefaults=MutableClassToInstanceMap.create();
numberDefaults.putInstance(Integer.class, Integer.valueOf(0));
```
从技术上讲,ClassToInstanceMap<B>实现了Map<Class<? extends B>, B>——或者换句话说,是一个映射B的子类型到对应实例的Map。这让ClassToInstanceMap包含的泛型声明有点令人困惑,但请记住B始终是Map所支持类型的上界——通常B就是Object。
对于ClassToInstanceMap,Guava提供了两种有用的实现:[MutableClassToInstanceMap](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/MutableClassToInstanceMap.html)和 [ImmutableClassToInstanceMap](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/ImmutableClassToInstanceMap.html)。
## RangeSet
RangeSet描述了一组不相连的、非空的区间。当把一个区间添加到可变的RangeSet时,所有相连的区间会被合并,空区间会被忽略。例如:
```
RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10)); // {[1,10]}
rangeSet.add(Range.closedOpen(11, 15));//不相连区间:{[1,10], [11,15)}
rangeSet.add(Range.closedOpen(15, 20)); //相连区间; {[1,10], [11,20)}
rangeSet.add(Range.openClosed(0, 0)); //空区间; {[1,10], [11,20)}
rangeSet.remove(Range.open(5, 10)); //分割[1, 10]; {[1,5], [10,10], [11,20)}
```
请注意,要合并Range.closed(1, 10)和Range.closedOpen(11, 15)这样的区间,你需要首先用[Range.canonical(DiscreteDomain)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/…mmon/collect/Range.html#canonical%28com.google.common.collect.DiscreteDomain%29)对区间进行预处理,例如DiscreteDomain.integers()。
注:RangeSet不支持GWT,也不支持JDK5和更早版本;因为,RangeSet需要充分利用JDK6中NavigableMap的特性。
### RangeSet的视图
RangeSet的实现支持非常广泛的视图:
* complement():返回RangeSet的补集视图。complement也是RangeSet类型,包含了不相连的、非空的区间。
* subRangeSet(Range<C>):返回RangeSet与给定Range的交集视图。这扩展了传统排序集合中的headSet、subSet和tailSet操作。
* asRanges():用Set<Range<C>>表现RangeSet,这样可以遍历其中的Range。
* asSet(DiscreteDomain<C>)(仅ImmutableRangeSet支持):用ImmutableSortedSet<C>表现RangeSet,以区间中所有元素的形式而不是区间本身的形式查看。(这个操作不支持DiscreteDomain 和RangeSet都没有上边界,或都没有下边界的情况)
### RangeSet的查询方法
为了方便操作,RangeSet直接提供了若干查询方法,其中最突出的有:
* contains(C):RangeSet最基本的操作,判断RangeSet中是否有任何区间包含给定元素。
* rangeContaining(C):返回包含给定元素的区间;若没有这样的区间,则返回null。
* encloses(Range<C>):简单明了,判断RangeSet中是否有任何区间包括给定区间。
* span():返回包括RangeSet中所有区间的最小区间。
## RangeMap
RangeMap描述了”不相交的、非空的区间”到特定值的映射。和RangeSet不同,RangeMap不会合并相邻的映射,即便相邻的区间映射到相同的值。例如:
```
RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
rangeMap.put(Range.closed(1, 10), "foo"); //{[1,10] => "foo"}
rangeMap.put(Range.open(3, 6), "bar"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo"}
rangeMap.put(Range.open(10, 20), "foo"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo", (10,20) => "foo"}
rangeMap.remove(Range.closed(5, 11)); //{[1,3] => "foo", (3,5) => "bar", (11,20) => "foo"}
```
### RangeMap的视图
RangeMap提供两个视图:
* asMapOfRanges():用Map<Range<K>, V>表现RangeMap。这可以用来遍历RangeMap。
* subRangeMap(Range<K>):用RangeMap类型返回RangeMap与给定Range的交集视图。这扩展了传统的headMap、subMap和tailMap操作。
- Spring 中文文档 3.1
- 第一部分 Spring framework 概述
- 第 1 章 Spring Framework 介绍
- 1.1 依赖注入和控制反转
- 1.2 模块
- 1.3 使用方案
- 第二部分 Spring 3 的新特性
- 第 2 章 Spring 3.0 的新特性和增强
- 2.1 Java 5
- 2.2 改进的文档
- 2.3 新的文章和教程
- 2.4 新的模块组织方式和系统构建方式
- 2.5 新特性概述
- 第 3 章 Spring 3.1 的新特性和增强
- 3.1 新特性概述
- 第三部分 核心技术
- 第 4 章 IoC 容器
- 4.1 Spring IoC 容器和 bean 的介绍
- 4.2 容器概述
- 4.3 Bean 概述
- 4.4 依赖
- 4.5 Bean 的范围
- 4.6 自定义 bean 的性质
- 4.7 Bean 定义的继承
- 4.8 容器扩展点
- 4.9 基于注解的容器配置
- 4.10 类路径扫描和管理的组件
- 4.11 使用 JSR 330 标准注解
- 4.12 基于 Java 的容器配置
- Hibernate 中文文档 3.2
- 前言
- 1. 翻译说明
- 2. 版权声明
- 第 1 章 Hibernate入门
- 1.1. 前言
- 1.2. 第一部分 - 第一个Hibernate应用程序
- 1.2.1. 第一个class
- 1.2.2. 映射文件
- 1.2.3. Hibernate配置
- 1.2.4. 用Ant构建
- 1.2.5. 启动和辅助类
- 1.2.6. 加载并存储对象
- 1.3. 第二部分 - 关联映射
- 1.3.1. 映射Person类
- 1.3.2. 单向Set-based的关联
- 1.3.3. 使关联工作
- 1.3.4. 值类型的集合
- 1.3.5. 双向关联
- 1.3.6. 使双向连起来
- 1.4. 第三部分 - EventManager web应用程序
- 1.4.1. 编写基本的servlet
- 1.4.2. 处理与渲染
- 1.4.3. 部署与测试
- 1.5. 总结
- 第 2 章 体系结构(Architecture)
- 2.1. 概况(Overview)
- 2.2. 实例状态
- 2.3. JMX整合
- 2.4. 对JCA的支持
- 2.5. 上下文相关的(Contextual)Session
- 第 3 章 配置
- 3.1. 可编程的配置方式
- 3.2. 获得SessionFactory
- 3.3. JDBC连接
- 3.4. 可选的配置属性
- 3.4.1. SQL方言
- 3.4.2. 外连接抓取(Outer Join Fetching)
- 3.4.3. 二进制流 (Binary Streams)
- 3.4.4. 二级缓存与查询缓存
- 3.4.5. 查询语言中的替换
- 3.4.6. Hibernate的统计(statistics)机制
- 3.5. 日志
- 3.6. 实现NamingStrategy
- 3.7. XML配置文件
- 3.8. J2EE应用程序服务器的集成
- 3.8.1. 事务策略配置
- 3.8.2. JNDI绑定的SessionFactory
- 3.8.3. 在JTA环境下使用Current Session context (当前session上下文)管理
- 3.8.4. JMX部署
- 第 4 章 持久化类(Persistent Classes)
- 4.1. 一个简单的POJO例子
- 4.1.1. 实现一个默认的(即无参数的)构造方法(constructor)
- 4.1.2. 提供一个标识属性(identifier property)(可选)
- 4.1.3. 使用非final的类 (可选)
- 4.1.4. 为持久化字段声明访问器(accessors)和是否可变的标志(mutators)(可选)
- 4.2. 实现继承(Inheritance)
- 4.3. 实现equals()和hashCode()
- 4.4. 动态模型(Dynamic models)
- 4.5. 元组片断映射(Tuplizers)
- 第 5 章 对象/关系数据库映射基础(Basic O/R Mapping)
- 5.1. 映射定义(Mapping declaration)
- 5.1.1. Doctype
- 5.1.1.1. EntityResolver
- 5.1.2. hibernate-mapping
- 5.1.3. class
- 5.1.4. id
- 5.1.4.1. Generator
- 5.1.4.2. 高/低位算法(Hi/Lo Algorithm)
- 5.1.4.3. UUID算法(UUID Algorithm )
- 5.1.4.4. 标识字段和序列(Identity columns and Sequences)
- 5.1.4.5. 程序分配的标识符(Assigned Identifiers)
- 5.1.4.6. 触发器实现的主键生成器(Primary keys assigned by triggers)
- 5.1.5. composite-id
- 5.1.6. 鉴别器(discriminator)
- 5.1.7. 版本(version)(可选)
- 5.1.8. timestamp (可选)
- 5.1.9. property
- 5.1.10. 多对一(many-to-one)
- 5.1.11. 一对一
- 5.1.12. 自然ID(natural-id)
- 5.1.13. 组件(component), 动态组件(dynamic-component)
- 5.1.14. properties
- 5.1.15. 子类(subclass)
- 5.1.16. 连接的子类(joined-subclass)
- 5.1.17. 联合子类(union-subclass)
- 5.1.18. 连接(join)
- 5.1.19. 键(key)
- 5.1.20. 字段和规则元素(column and formula elements)
- 5.1.21. 引用(import)
- 5.1.22. any
- 5.2. Hibernate 的类型
- 5.2.1. 实体(Entities)和值(values)
- 5.2.2. 基本值类型
- 5.2.3. 自定义值类型
- 5.3. 多次映射同一个类
- 5.4. SQL中引号包围的标识符
- 5.5. 其他元数据(Metadata)
- 5.5.1. 使用 XDoclet 标记
- 5.5.2. 使用 JDK 5.0 的注解(Annotation)
- 5.6. 数据库生成属性(Generated Properties)
- 5.7. 辅助数据库对象(Auxiliary Database Objects)
- 第 6 章 集合类(Collections)映射
- 6.1. 持久化集合类(Persistent collections)
- 6.2. 集合映射( Collection mappings )
- 6.2.1. 集合外键(Collection foreign keys)
- 6.2.2. 集合元素(Collection elements)
- 6.2.3. 索引集合类(Indexed collections)
- 6.2.4. 值集合于多对多关联(Collections of values and many-to-many associations)
- 6.2.5. 一对多关联(One-to-many Associations)
- 6.3. 高级集合映射(Advanced collection mappings)
- 6.3.1. 有序集合(Sorted collections)
- 6.3.2. 双向关联(Bidirectional associations)
- 6.3.3. 双向关联,涉及有序集合类
- 6.3.4. 三重关联(Ternary associations)
- 6.3.5. 使用&amp;lt;idbag&amp;gt;
- 6.4. 集合例子(Collection example)
- 第 7 章 关联关系映射
- 7.1. 介绍
- 7.2. 单向关联(Unidirectional associations)
- 7.2.1. 多对一(many to one)
- 7.2.2. 一对一(one to one)
- 7.2.3. 一对多(one to many)
- 7.3. 使用连接表的单向关联(Unidirectional associations with join tables)
- 7.3.1. 一对多(one to many)
- 7.3.2. 多对一(many to one)
- 7.3.3. 一对一(one to one)
- 7.3.4. 多对多(many to many)
- 7.4. 双向关联(Bidirectional associations)
- 7.4.1. 一对多(one to many) / 多对一(many to one)
- 7.4.2. 一对一(one to one)
- 7.5. 使用连接表的双向关联(Bidirectional associations with join tables)
- 7.5.1. 一对多(one to many) /多对一( many to one)
- 7.5.2. 一对一(one to one)
- 7.5.3. 多对多(many to many)
- 7.6. 更复杂的关联映射
- 第 8 章 组件(Component)映射
- 8.1. 依赖对象(Dependent objects)
- 8.2. 在集合中出现的依赖对象 (Collections of dependent objects)
- 8.3. 组件作为Map的索引(Components as Map indices )
- 8.4. 组件作为联合标识符(Components as composite identifiers)
- 8.5. 动态组件 (Dynamic components)
- 第 9 章 继承映射(Inheritance Mappings)
- 9.1. 三种策略
- 9.1.1. 每个类分层结构一张表(Table per class hierarchy)
- 9.1.2. 每个子类一张表(Table per subclass)
- 9.1.3. 每个子类一张表(Table per subclass),使用辨别标志(Discriminator)
- 9.1.4. 混合使用“每个类分层结构一张表”和“每个子类一张表”
- 9.1.5. 每个具体类一张表(Table per concrete class)
- 9.1.6. Table per concrete class, using implicit polymorphism
- 9.1.7. 隐式多态和其他继承映射混合使用
- 9.2. 限制
- 第 10 章 与对象共事
- 10.1. Hibernate对象状态(object states)
- 10.2. 使对象持久化
- 10.3. 装载对象
- 10.4. 查询
- 10.4.1. 执行查询
- 10.4.1.1. 迭代式获取结果(Iterating results)
- 10.4.1.2. 返回元组(tuples)的查询
- 10.4.1.3. 标量(Scalar)结果
- 10.4.1.4. 绑定参数
- 10.4.1.5. 分页
- 10.4.1.6. 可滚动遍历(Scrollable iteration)
- 10.4.1.7. 外置命名查询(Externalizing named queries)
- 10.4.2. 过滤集合
- 10.4.3. 条件查询(Criteria queries)
- 10.4.4. 使用原生SQL的查询
- 10.5. 修改持久对象
- 10.6. 修改脱管(Detached)对象
- 10.7. 自动状态检测
- 10.8. 删除持久对象
- 10.9. 在两个不同数据库间复制对象
- 10.10. Session刷出(flush)
- 10.11. 传播性持久化(transitive persistence)
- 10.12. 使用元数据
- 第 11 章 事务和并发
- 11.1. Session和事务范围(transaction scope)
- 11.1.1. 操作单元(Unit of work)
- 11.1.2. 长对话
- 11.1.3. 关注对象标识(Considering object identity)
- 11.1.4. 常见问题
- 11.2. 数据库事务声明
- 11.2.1. 非托管环境
- 11.2.2. 使用JTA
- 11.2.3. 异常处理
- 11.2.4. 事务超时
- 11.3. 乐观并发控制(Optimistic concurrency control)
- 11.3.1. 应用程序级别的版本检查(Application version checking)
- 11.3.2. 扩展周期的session和自动版本化
- 11.3.3. 脱管对象(deatched object)和自动版本化
- 11.3.4. 定制自动版本化行为
- 11.4. 悲观锁定(Pessimistic Locking)
- 11.5. 连接释放模式(Connection Release Modes)
- 第 12 章 拦截器与事件(Interceptors and events)
- 12.1. 拦截器(Interceptors)
- 12.2. 事件系统(Event system)
- 12.3. Hibernate的声明式安全机制
- 第 13 章 批量处理(Batch processing)
- 13.1. 批量插入(Batch inserts)
- 13.2. 批量更新(Batch updates)
- 13.3. StatelessSession (无状态session)接口
- 13.4. DML(数据操作语言)风格的操作(DML-style operations)
- 第 14 章 HQL: Hibernate查询语言
- 14.1. 大小写敏感性问题
- 14.2. from子句
- 14.3. 关联(Association)与连接(Join)
- 14.4. join 语法的形式
- 14.5. select子句
- 14.6. 聚集函数
- 14.7. 多态查询
- 14.8. where子句
- 14.9. 表达式
- 14.10. order by子句
- 14.11. group by子句
- 14.12. 子查询
- 14.13. HQL示例
- 14.14. 批量的UPDATE和DELETE
- 14.15. 小技巧 & 小窍门
- 第 15 章 条件查询(Criteria Queries)
- 15.1. 创建一个Criteria 实例
- 15.2. 限制结果集内容
- 15.3. 结果集排序
- 15.4. 关联
- 15.5. 动态关联抓取
- 15.6. 查询示例
- 15.7. 投影(Projections)、聚合(aggregation)和分组(grouping)
- 15.8. 离线(detached)查询和子查询
- 15.9. 根据自然标识查询(Queries by natural identifier)
- 第 16 章 Native SQL查询
- 16.1. 使用SQLQuery
- 16.1.1. 标量查询(Scalar queries)
- 16.1.2. 实体查询(Entity queries)
- 16.1.3. 处理关联和集合类(Handling associations and collections)
- 16.1.4. 返回多个实体(Returning multiple entities)
- 16.1.4.1. 别名和属性引用(Alias and property references)
- 16.1.5. 返回非受管实体(Returning non-managed entities)
- 16.1.6. 处理继承(Handling inheritance)
- 16.1.7. 参数(Parameters)
- 16.2. 命名SQL查询
- 16.2.1. 使用return-property来明确地指定字段/别名
- 16.2.2. 使用存储过程来查询
- 16.2.2.1. 使用存储过程的规则和限制
- 16.3. 定制SQL用来create,update和delete
- 16.4. 定制装载SQL
- 第 17 章 过滤数据
- 17.1. Hibernate 过滤器(filters)
- 第 18 章 XML映射
- 18.1. 用XML数据进行工作
- 18.1.1. 指定同时映射XML和类
- 18.1.2. 只定义XML映射
- 18.2. XML映射元数据
- 18.3. 操作XML数据
- 第 19 章 提升性能
- 19.1. 抓取策略(Fetching strategies)
- 19.1.1. 操作延迟加载的关联
- 19.1.2. 调整抓取策略(Tuning fetch strategies)
- 19.1.3. 单端关联代理(Single-ended association proxies)
- 19.1.4. 实例化集合和代理(Initializing collections and proxies)
- 19.1.5. 使用批量抓取(Using batch fetching)
- 19.1.6. 使用子查询抓取(Using subselect fetching)
- 19.1.7. 使用延迟属性抓取(Using lazy property fetching)
- 19.2. 二级缓存(The Second Level Cache)
- 19.2.1. 缓存映射(Cache mappings)
- 19.2.2. 策略:只读缓存(Strategy: read only)
- 19.2.3. 策略:读/写缓存(Strategy: read/write)
- 19.2.4. 策略:非严格读/写缓存(Strategy: nonstrict read/write)
- 19.2.5. 策略:事务缓存(transactional)
- 19.3. 管理缓存(Managing the caches)
- 19.4. 查询缓存(The Query Cache)
- 19.5. 理解集合性能(Understanding Collection performance)
- 19.5.1. 分类(Taxonomy)
- 19.5.2. Lists, maps 和sets用于更新效率最高
- 19.5.3. Bag和list是反向集合类中效率最高的
- 19.5.4. 一次性删除(One shot delete)
- 19.6. 监测性能(Monitoring performance)
- 19.6.1. 监测SessionFactory
- 19.6.2. 数据记录(Metrics)
- 第 20 章 工具箱指南
- 20.1. Schema自动生成(Automatic schema generation)
- 20.1.1. 对schema定制化(Customizing the schema)
- 20.1.2. 运行该工具
- 20.1.3. 属性(Properties)
- 20.1.4. 使用Ant(Using Ant)
- 20.1.5. 对schema的增量更新(Incremental schema updates)
- 20.1.6. 用Ant来增量更新schema(Using Ant for incremental schema updates)
- 20.1.7. Schema 校验
- 20.1.8. 使用Ant进行schema校验
- 第 21 章 示例:父子关系(Parent Child Relationships)
- 21.1. 关于collections需要注意的一点
- 21.2. 双向的一对多关系(Bidirectional one-to-many)
- 21.3. 级联生命周期(Cascading lifecycle)
- 21.4. 级联与未保存值(Cascades and unsaved-value)
- 21.5. 结论
- 第 22 章 示例:Weblog 应用程序
- 22.1. 持久化类
- 22.2. Hibernate 映射
- 22.3. Hibernate 代码
- 第 23 章 示例:复杂映射实例
- 23.1. Employer(雇主)/Employee(雇员)
- 23.2. Author(作家)/Work(作品)
- 23.3. Customer(客户)/Order(订单)/Product(产品)
- 23.4. 杂例
- 23.4.1. "Typed" one-to-one association
- 23.4.2. Composite key example
- 23.4.3. 共有组合键属性的多对多(Many-to-many with shared composite key attribute)
- 23.4.4. Content based discrimination
- 23.4.5. Associations on alternate keys
- 第 24 章 最佳实践(Best Practices)
- HttpClient 教程
- 前言
- 第一章 基础
- 第二章 连接管理
- 第三章 HTTP状态管理
- 第四章 HTTP认证
- 第五章 HTTP客户端服务
- 第六章 高级主题
- Mybatis 中文文档 3.4
- 参考文档
- 简介
- 入门
- XML 映射配置文件
- Mapper XML 文件
- 动态 SQL
- Java API
- SQL语句构建器类
- Logging
- 项目文档
- 项目总体信息
- 访问
- 提醒方法
- 项目依赖
- Dependency Information
- Overview
- 问题跟踪
- 项目授权
- 项目邮件列表
- Project Plugin Management
- Project Build Plugins
- Project Report Plugins
- 团队
- Web访问
- 匿名访问
- 开发者访问
- 通过防火墙访问
- 项目概要
- 生成报表
- MyBatis Generator 用户手册
- MyBatis Generator介绍
- MyBatis Generator新增功能
- MyBatis Generator 快速入门指南
- 运行 MyBatis Generator
- 从命令行运行 MyBatis Generator
- 使用Ant运行 MyBatis Generator
- 通过Maven运行 MyBatis Generator
- 使用Java运行 MyBatis Generator
- 运行 MyBatis Generator 后的任务
- Migrating from Ibator
- Migrating from Abator
- MyBatis Generator XML 配置参考
- &lt;classPathEntry&gt; 元素
- &lt;columnOverride&gt; 元素
- &lt;columnRenamingRule&gt; 元素
- &lt;commentGenerator&gt; 元素
- &lt;context&gt; 元素
- &lt;generatedKey&gt; 元素
- &lt;generatorConfiguration&gt; 元素
- &lt;ignoreColumn&gt; 元素
- &lt;javaClientGenerator&gt; 元素
- The &lt;javaModelGenerator&gt; Element
- The &lt;javaTypeResolver&gt; Element
- &lt;jdbcConnection&gt; 元素
- &lt;plugin&gt; 元素
- &lt;properties&gt; 元素
- &lt;property&gt; 元素
- &lt;sqlMapGenerator&gt; 元素
- &lt;table&gt; 元素
- 使用生成的对象
- JAVA实体对象
- SQL映射文件
- Java客户端对象
- Example类使用说明
- 扩展Example类
- 使用注意事项
- DB2 使用注意事项
- MySql 使用注意事项
- Oracle 使用注意事项
- PostgreSQL 使用注意事项
- 参考资料
- 从源码构建
- 扩展MyBatis Generator
- 开发插件
- 日志信息
- 提供的插件
- 设计理念
- Velocity 中文文档
- 1. 关于
- 2. 什么是Velocity?
- 3. Velocity 可以做什么?
- 3.1. Mud Store 示例
- 4. Velocity模板语言(VTL): 介绍
- 5. Hello Velocity World!
- 6. 注释
- 7. 引用
- 7.1. 变量Variables
- 7.2. 属性
- 7.3. 方法
- 8. 形式引用符Formal Reference Notation
- 9. 安静引用符Quiet Reference Notation
- 11. Case Substitution
- 12. 指令
- 12.1. #set
- 12.2. 字面字符串
- 12.3. 条件
- 12.3.1 If / ElseIf / Else
- 12.3.2 关系和逻辑操作符
- 12.4. 循环
- 12.4.1. Foreach 循环
- 12.5. 包含
- 12.6. 解析
- 12.7. 停止
- 12.10. 宏
- 12.10.1. Velocimacro 参数
- 12.10.2. Velocimacro 属性
- 12.10.3. Velocimacro Trivia
- 13. Getting literal
- 13.1. 货币字符
- 13.2. 转义 有效的 VTL 指令
- 13.3. 转义 无效的 VTL 指令
- 14. VTL 格式化问题
- 15. 其它特征和杂项
- 15.1. 数学特征
- 15.2. 范围操作符
- 15.3. 进阶:转义和!
- 15.4. Velocimacro 杂记
- 15.5. 字符串联
- Google Guava官方教程(中文版)
- 1-基本工具
- 1.1-使用和避免null
- 1.2-前置条件
- 1.3-常见Object方法
- 1.4-排序: Guava强大的”流畅风格比较器”
- 1.5-Throwables:简化异常和错误的传播与检查
- 2-集合
- 2.1-不可变集合
- 2.2-新集合类型
- 2.3-强大的集合工具类:java.util.Collections中未包含的集合工具
- 2.4-集合扩展工具类
- 3-缓存
- 4-函数式编程
- 5-并发
- 5.1-google Guava包的ListenableFuture解析
- 5.2-Google-Guava Concurrent包里的Service框架浅析
- 6-字符串处理:分割,连接,填充
- 7-原生类型
- 8-区间
- 9-I/O
- 10-散列
- 11-事件总线
- 12-数学运算
- 13-反射
- JFreeChart 开发者指南
- 1 简介
- 1.1 什么是JFreeChart
- 1.2 使用文档
- 1.3 感谢
- 1.4 建议
- 2 图表实例
- 2.1 介绍
- 2.2 饼图(Pie Charts)
- 2.3 直方条形图(Bar Charts)
- 2.4 折线图(Line Charts)
- 2.5 XY(散点图)
- 2.6 时序图
- 2.7 柱状图
- 2.8 面积图
- 2.9 差异图
- 2.10 梯形图
- 2.11 甘特图
- 2.12 多轴图
- 2.13 复合/覆盖图
- 2.14 开发远景
- 3 下载和安装JFreeChart 1.0.6
- 3.1 简介
- 3.2 下载
- 3.3 解包
- 3.4 运行演示实例
- 3.5 编译源代码
- 3.6 产生javadoc文档
- 4 使用JFreeChart1.0.6
- 4.1 概述
- 4.2 创建第一个图表
- 5 饼图(Pie Charts)
- 5.1 简介
- 5.2 创建一个简单的饼图(Pie Charts)
- 5.3 片区颜色
- 5.4 片区外廓
- 5.5 空置、零值和负值
- 5.6 片区和图例标签
- 5.7 “取出”某个片区
- 5.8 3D饼图
- 5.9 多饼图
- 5.10 实例讲解
- 6 直方条形图(Bar Charts)
- 6.1 简介
- 6.2 创建一个直方条形图
- 6.3 ChartFactory类
- 6.4 直方条形图的简单定制
- 6.5 定制外观
- 6.6 示例代码解读
- 7 折线图
- 7.1 简介
- 7.2 使用categoryDataset数据集创建折线图
- 7.3 使用XYDataset数据集创建折线图
- 8 时序图
- 8.1 简介
- 8.2 创建时序图
- 9 定制图表(Customising Charts)
- 9.1 简介
- 9.2 图表属性
- 9.3 图区属性
- 9.4 轴属性
- 9.5 心得体会
- 10 动态图(Dynamic Charts)
- 10.1 简介
- 10.2 知识背景
- 10.3 实例应用
- 11 图表工具条(Tooltips)
- 11.1 概述
- 11.2 创建图表工具条
- 11.3 收集图表工具条
- 11.4 显示图表工具条
- 11.5 隐藏图表工具条
- 11.6 定制图表工具条
- 12 图表条目标签(Item Label)
- 12.1 简介
- 12.2 显示条目标签
- 12.3 条目标签外观
- 12.4 条目标签位置
- 12.5 定制条目标签文本
- 12.6 实例1
- 12.7 实例2
- 13 多轴和数据源图表(Multi Axis and Dataset)
- 13.1 简介
- 13.2 实例
- 13.3 建议和技巧
- 14 组合图表(Combined Charts)
- 14.1 简介
- 14.2 组合X种类图区
- 14.3 组合Y种类图区
- 14.4 组合X-XY图区
- 14.5 组合Y-XY图区
- 15 数据源和JDBC(Dataset And JDBC)
- 15.1 简介
- 15.2 关于JDBC
- 15.3 样本数据
- 15.4 PostgreSQL
- 15.5 JDBC驱动
- 15.6 应用演示
- 16 导出图表为PDF格式
- 16.1 简介
- 16.2 什么是Acrobat PDF
- 16.3 IText
- 16.4 Graphics2D
- 16.5 开始导出
- 16.6 实例应用
- 16.7 查看PDF 文件
- 16.8 Unicode字符问题
- 17 导出图表为SVG格式
- 17.1 简介
- 17.2 背景
- 17.3 实例代码
- 18 Applet
- 18.1 简介
- 18.2 问题
- 18.3 实例应用
- 19 Servlets
- 19.1 介绍
- 19.2 编写一个简单的Servlet应用
- 19.3 编译实例Servlet
- 19.4 部署实例Servlet
- 19.5 在HMTL页面种嵌入图表
- 19.6 支持文件
- 19.7 部署Servlets
- 20 JFreeChart相关技术
- 20.1 简介
- 20.2 X11/Headless Java
- 20.3 JSP
- 20.4 加载图片
- 21 包
- 21.1 概述