# Java 集合
原文：http://zetcode.com/lang/java/collections/
在本章中，我们将处理集合。 Java 提供了用于数据存储和检索的专门类。 在前面的章节中，我们描述了数组。 集合是对数组的增强。
Java 5 引入了通用集合。 通用集合更灵活，它们是使用数据的首选方式。 通用集合可增强代码重用性，类型安全性和性能。
集合框架中有许多类。 其中一些，例如`ArrayBlockingQueue`或`IdentityHashMap`，是在特定情况下使用的专用容器。 我们将提到一些通用容器。
## Java `ArrayList`
`ArrayList`是可调整大小的动态数组。 它提供对元素的随机访问。 随机访问意味着我们可以在恒定时间内获取任何元素。 `ArrayList`随着添加数据而自动扩展。 与`array`不同，`ArrayList`可以保存多种数据类型的数据。 `ArrayList`中的元素通过整数索引访问。 索引从零开始。 在`ArrayList`的末尾元素的索引以及插入和删除需要固定的时间。
在动态数组的中间插入或删除元素的成本更高。 它要求将所有后面的元素转移过来。 该过程需要线性时间。
您可以在 [Java `ArrayList`教程](/articles/javaarraylist/)中找到有关 Java `ArrayList`的更多信息。
`ArrayListSimpleEx.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayListSimpleEx {
public static void main(String[] args) {
List<String> distros = new ArrayList<String>();
distros.add("Manjaro");
distros.add("Xubuntu");
distros.add("Fedora");
distros.add("elementary");
for (String distro : distros) {
System.out.println(distro);
}
List<String> capitals = Arrays.asList("Prague", "Bratislava", "Warsaw",
"Budapest", "Washington");
for (String capital : capitals) {
System.out.println(capital);
}
}
}
```
该示例创建两个列表并打印其内容。
```java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
```
必要的类位于`java.util`包中。
```java
List<String> distros = new ArrayList<String>();
```
创建一个新的`ArrayList`。 该列表可以包含字符串。 列表可以包含的类型在菱形括号之间给出。
```java
distros.add("Manjaro");
distros.add("Xubuntu");
distros.add("Fedora");
distros.add("elementary");
```
使用`add()`方法，我们将四个条目添加到列表中。
```java
for (String distro : distros) {
System.out.println(distro);
}
```
我们使用`for-each`循环遍历列表。
```java
List<String> capitals = Arrays.asList("Prague", "Bratislava", "Warsaw",
"Budapest", "Washington");
```
我们可以使用`Arrays.asList()`方法来初始化列表。
`ArrayList`可以包含多种数据类型。
`ArrayListMultipleEx.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
class Base { }
public class ArrayListMultipleEx {
public static void main(String[] args) {
List da = new ArrayList();
da.add("Java");
da.add(3.5);
da.add(55);
da.add(new Base());
for (Object el : da) {
System.out.println(el);
}
}
}
```
该示例创建一个`ArrayList`集合。 它包含各种数据类型。
```java
import java.util.ArrayList;
```
从`java.util`包中，导入`ArrayList`类。
```java
List da = new ArrayList();
```
创建一个`ArrayList`集合。
```java
da.add("Java");
da.add(3.5);
da.add(55);
da.add(new Base());
```
我们使用`add()`方法向数组添加四个元素。
```java
for (Object el : da) {
System.out.println(el);
}
```
我们遍历数组列表，并将其元素打印到控制台。
```java
$ java com.zetcode.ArrayListMultipleEx
Java
3.5
55
com.zetcode.Base@1535ac
```
在这里，我们可以看到`com.zetcode.ArrayListMultipleEx`的输出。
下一个示例将介绍一些`ArrayList`方法。
`ArrayListMethodsEx.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListMethodsEx {
public static void main(String[] args) {
List<String> names = new ArrayList<String>();
names.add("Jane");
names.add("Thomas");
names.add("Robin");
names.add("David");
names.add("Becky");
System.out.println(names);
names.set(1, "Tom");
System.out.println(names);
System.out.format("There are %d elements in the collection%n",
names.size());
names.remove(1);
System.out.format("There are %d elements in the collection%n",
names.size());
System.out.println(names.get(3));
System.out.println("************");
Iterator<String> it = names.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
```
在示例中，我们介绍了`ArrayList`容器的一些有用方法。
```java
List<String> names = new ArrayList<String>();
```
将创建一个通用的`ArrayList`。 我们将元素的数据类型限制为`String`数据类型。 这是通过在`<>`字符之间写入数据类型来完成的。
```java
names.add("Jane");
names.add("Thomas");
names.add("Robin");
names.add("David");
names.add("Becky");
```
我们将五个字符串元素添加到数组列表中。
```java
System.out.println(names);
```
将容器作为`println()`方法的参数将调用容器的`toString()`方法。 它将集合转换为字符串。
```java
names.set(1, "Tom");
```
`set()`方法用给定元素替换指定索引处的元素。 `"Tomas"`替换为`"Tom"`。
```java
System.out.format("There are %d elements in the collection%n",
names.size());
```
`ArrayList`的大小由`size()`方法确定。
```java
names.remove(1);
```
我们从集合中删除第二个元素。 参数是集合的索引。
```java
System.out.println(names.get(3));
```
`get()`方法检索容器的第四个元素。
```java
Iterator<String> it = names.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
```
我们使用`Iterator`对象浏览容器。 `hasNext()`方法检查是否还剩下一些元素，`next()`方法检索迭代中的下一个元素。
```java
$ java com.zetcode.ArrayListMethodsEx
[Jane, Thomas, Robin, David, Becky]
[Jane, Tom, Robin, David, Becky]
There are 5 elements in the collection
There are 4 elements in the collection
Becky
************
Jane
Robin
David
Becky
```
这是`com.zetcode.ArrayListMethodsEx`示例的示例输出。
在下一个示例中，我们继续介绍`ArrayList`的方法。
`ArrayListMethodsEx2.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
public class ArrayListMethodsEx2 {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Jane");
names.add(0, "Thomas");
names.add(1, "Robin");
names.add("David");
names.add("Becky");
System.out.println(names);
System.out.println(names.isEmpty());
System.out.println(names.contains("Jane"));
System.out.println(names.contains("Robert"));
System.out.println(names.indexOf("Jane"));
System.out.println(names.subList(1, 4));
names.clear();
System.out.println(names.isEmpty());
System.out.println(names);
}
}
```
我们展示了可以用于`ArrayList`的另外五种方法。
```java
List<String> names = new ArrayList<>();
```
从 Java 7 开始，可以在对通用类的构造器调用中省略显式类型参数。 编译器为通用类的构造器推断参数类型。
```java
names.add("Jane");
names.add(0, "Thomas");
```
`add()`方法将新项目添加到容器。 重载的第二个选项指定将放置项目的索引。 最后，`"Thomas"`字符串位于`"Jane"`字符串之前。
```java
System.out.println(names.isEmpty());
```
`empty()`方法检查容器是否为空。 该行返回`false`。 目前，容器中有五个字符串。
```java
System.out.println(names.contains("Jane"));
```
`contains()`方法确定容器中是否存在指定的元素。
```java
System.out.println(names.indexOf("Jane"));
```
`indexOf()`方法返回指定元素首次出现的索引，如果列表不包含该元素，则返回 -1。
```java
System.out.println(names.subList(1, 4));
```
`subList()`方法返回指定索引之间的列表切片。 切片中包括第一个索引处的元素，不包括第二个索引处的元素。
```java
names.clear();
```
`clear()`方法从容器中删除所有元素。
```java
$ java com.zetcode.ArrayListMethodsEx2
[Thomas, Robin, Jane, David, Becky]
false
true
false
2
[Robin, Jane, David]
true
[]
```
这是`com.zetcode.ArrayListMethodsEx2`的输出。
我们可以将其他列表添加到列表中。
`ListOfLists.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
public class ListOfLists {
public static void main(String[] args) {
List<Integer> l1 = new ArrayList<>();
l1.add(1);
l1.add(2);
l1.add(3);
List<Integer> l2 = new ArrayList<>();
l2.add(4);
l2.add(5);
l2.add(6);
List<Integer> l3 = new ArrayList<>();
l3.add(7);
l3.add(8);
l3.add(9);
List<List<Integer>> nums = new ArrayList<>();
nums.add(l1);
nums.add(l2);
nums.add(l3);
System.out.println(nums);
for (List<Integer> list : nums) {
for (Integer n : list) {
System.out.printf("%d ", n);
}
System.out.println();
}
}
}
```
该示例创建三个整数列表。 以后，这些列表将添加到另一个第四列表中。
```java
List<Integer> l1 = new ArrayList<>();
l1.add(1);
l1.add(2);
l1.add(3);
```
将创建一个整数列表。
```java
List<List> nums = new ArrayList<>();
nums.add(l1);
nums.add(l2);
nums.add(l3);
```
创建列表列表。
```java
for (List<Integer> list : nums) {
for (Integer n : list) {
System.out.printf("%d ", n);
}
System.out.println();
}
```
我们使用两个 for 循环遍历所有元素。
```java
$ java com.zetcode.ListOfListsEx
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1 2 3
4 5 6
7 8 9
```
这是`com.zetcode.ListOfListsEx`的输出。
## Java 遍历列表
在下一节中，我们将展示如何遍历 Java 中的列表。
`TraversingList.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
public class TraversingList {
public static void main(String[] args) {
List<String> martialArts = new ArrayList<>();
martialArts.add("Silat");
martialArts.add("Wing chun");
martialArts.add("Karate");
martialArts.add("Judo");
martialArts.add("Aikido");
for (int i=0; i < martialArts.size(); i++) {
System.out.printf("%s ", martialArts.get(i));
}
System.out.print("\n");
for (String e: martialArts) {
System.out.printf("%s ", e);
}
System.out.print("\n");
martialArts.forEach((e) -> System.out.printf("%s ", e));
System.out.print("\n");
}
}
```
我们有一个字符串列表； 我们展示了三种遍历 Java 列表的方法。
```java
for (int i=0; i < martialArts.size(); i++) {
System.out.printf("%s ", martialArts.get(i));
}
```
使用传统的`for`循环遍历列表。
```java
for (String e: martialArts) {
System.out.printf("%s ", e);
}
```
在这里，列表通过`for-each`循环进行遍历。
```java
martialArts.forEach((e) -> System.out.printf("%s ", e));
```
第三种方法使用`forEach`方法和 lambda 表达式。
```java
$ java com.zetcode.TraversingList
Silat Wing chun Karate Judo Aikido
Silat Wing chun Karate Judo Aikido
Silat Wing chun Karate Judo Aikido
```
这是输出。
## Java `LinkedList`
`LinkedList`是 Java 中的双链表。 元素的插入和移除需要固定的时间。 链表提供对元素的顺序访问，这意味着抓取元素需要花费线性时间。 由于链表需要额外的存储空间以供参考，因此对于诸如字符之类的小型数据项列表来说，它们是不切实际的。
将`ArrayList`与`LinkedList`进行比较时，`ArrayList`用于访问特定元素的速度很快，但是添加到任一端的速度可能很慢，尤其是在中间删除时，速度特别慢。 `LinkedList`快速添加和删除元素，但是访问特定元素却很慢。
`LinkedListEx.java`
```java
package com.zetcode;
import java.util.LinkedList;
public class LinkedListEx {
public static void main(String[] args) {
LinkedList<Integer> nums = new LinkedList<>();
nums.add(5);
nums.add(10);
nums.add(13);
nums.add(12);
nums.add(15);
nums.add(23);
System.out.println(nums);
nums.removeFirst();
nums.removeLast();
nums.addFirst(17);
nums.addLast(77);
System.out.println(nums);
}
}
```
这是一个`LinkedList`示例，其中包含一些方法。
```java
LinkedList<Integer> nums = new LinkedList<>();
```
该`LinkedList`具有整数。
```java
nums.add(5);
nums.add(10);
```
我们将数字添加到列表中。 自动装箱将原始`int`类型包装到`Integer`对象。
```java
nums.removeFirst();
nums.removeLast();
```
这两种方法从容器中删除第一个和最后一个元素。
```java
nums.addFirst(17);
nums.addLast(77);
```
我们在列表的开头和结尾添加一个元素。
```java
$ java com.zetcode.LinkedListEx
[5, 10, 13, 12, 15, 23]
[17, 10, 13, 12, 15, 77]
```
链表中包含的元素将两次打印到控制台。
## Java `HashMap`
`HashMap`是一个存储键/值对的容器。 每个键与一个值关联。 键必须是唯一的。 这种容器类型在其他编程语言中称为关联数组或字典。 `HashMap`占用更多内存，因为对于每个值还有一个键。
删除和插入操作需要固定的时间。 `HashMap`可以存储空值。
`HashMapEx.java`
```java
package com.zetcode;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapEx {
public static void main(String[] args) {
Map<String, String> domains = new HashMap<>();
domains.put("de", "Germany");
domains.put("sk", "Slovakia");
domains.put("us", "United States");
domains.put("ru", "Russia");
domains.put("hu", "Hungary");
domains.put("pl", "Poland");
System.out.println(domains.get("pl"));
for (String item : domains.values()) {
System.out.println(item);
}
Set keys = domains.keySet();
System.out.println(keys);
}
}
```
我们有一个`HashMap`，将域名映射到其国家名称。
```java
Map<String, String> domains = new HashMap<>();
```
我们用字符串键和值创建一个`HashMap`。
```java
domains.put("de", "Germany");
domains.put("sk", "Slovakia");
domains.put("us", "United States");
...
```
我们将一些数据放入`HashMap`。 第一个字符串是键。 第二是值。
```java
System.out.println(domains.get("pl"));
```
我们通过其键检索特定值。 对于检索操作，我们使用`get`方法。
```java
for (String item : domains.values()) {
System.out.println(item);
}
```
`values()`方法返回域`HashMap`中包含的值的集合。 我们使用`for`循环遍历这些值，并将它们打印到控制台。
```java
Set keys = domains.keySet();
```
`keySet()`方法返回`Set`集合中`HashMap`的键。 `Set`是唯一元素的集合。
```java
System.out.println(keys);
```
该集合的元素将打印到控制台。
```java
$ java com.zetcode.HashMapEx
Poland
Germany
Slovakia
Hungary
Poland
United States
Russia
[de, sk, hu, pl, us, ru]
```
这是示例的输出。
在下一个示例中，我们创建一个自定义颜色对象的映射。
`HashMapEx2.java`
```java
package com.zetcode;
import java.util.HashMap;
import java.util.Map;
class Colour {
private String name;
private String code;
public Colour(String name, String code) {
this.name = name;
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
public class HashMapEx2 {
public static void main(String[] args) {
Map<Integer, Colour> cols = new HashMap<>();
cols.put(1, new Colour("AliceBlue", "#f0f8ff"));
cols.put(2, new Colour("GreenYellow", "#adff2f"));
cols.put(3, new Colour("IndianRed", "#cd5c5c"));
cols.put(4, new Colour("khaki", "#f0e68c"));
System.out.printf("The size of the map is %d%n", cols.size());
int key = 4;
if (cols.containsKey(key)) {
System.out.printf("The map contains key %d%n", key);
}
cols.remove(1);
System.out.printf("The size of the map is %d%n", cols.size());
cols.replace(3, new Colour("VioletRed", "#d02090"));
Colour col = cols.get(3);
System.out.printf("Colour name:%s colour code:%s %n",
col.getName(), col.getCode());
}
}
```
在此示例中，我们提出以下三种方法：`containsKey()`，`remove()`和`replace()`。
```java
class Colour {
private String name;
private String code;
public Colour(String name, String code) {
this.name = name;
this.code = code;
}
...
}
```
自定义颜色对象包含颜色名称和颜色代码属性。
```java
Map<Integer, Colour> cols = new HashMap<>();
```
创建一个映射，其中键是整数，值是`Colour`对象。
```java
if (cols.containsKey(key)) {
System.out.printf("The map contains key %d%n", key);
}
```
`containsKey()`方法确定键是否在映射中。
```java
cols.remove(1);
```
`remove()`方法从映射中删除具有指定键的对象。
```java
cols.replace(3, new Colour("VioletRed", "#d02090"));
```
`replace()`方法替换指定键的条目。
```java
$ java com.zetcode.HashMapEx2
The size of the map is 4
The map contains key 4
The size of the map is 3
Colour name:VioletRed colour code:#d02090
```
This is the output of the example.
## 单词计数
在下面的示例中，我们计算文本文件中单词的出现次数。 我们使用`HashMap`存储单词及其出现。
`thermopylae.txt`
```java
The Battle of Thermopylae was fought between an alliance of Greek city-states,
led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the
course of three days, during the second Persian invasion of Greece.
It took place simultaneously with the naval battle at Artemisium, in August
or September 480 BC, at the narrow coastal pass of Thermopylae.
The Persian invasion was a delayed response to the defeat of the first Persian
invasion of Greece, which had been ended by the Athenian victory at the Battle
of Marathon in 490 BC. Xerxes had amassed a huge army and navy, and set out to
conquer all of Greece.
```
我们从`thermopylae.txt`文件中读取内容。 该文件位于`src/resources/`目录中。
`CountingWordsEx.java`
```java
package com.zetcode;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CountingWordsEx {
public static void main(String[] args) throws IOException {
Map<String, Integer> wordCount = new HashMap<>();
String fileName = "src/resources/thermopylae.txt";
List<String> lines = Files.readAllLines(Paths.get(fileName),
StandardCharsets.UTF_8);
for (String line : lines) {
String[] words = line.split("\\s+");
for (String word : words) {
if (word.endsWith(".") || word.endsWith(",")) {
word = word.substring(0, word.length()-1);
}
if (wordCount.containsKey(word)) {
wordCount.put(word, wordCount.get(word) + 1);
} else {
wordCount.put(word, 1);
}
}
}
for (String key : wordCount.keySet()) {
System.out.println(key + ": " + wordCount.get(key));
}
}
}
```
该示例从文件中读取文本，将句子拆分为单词并计算其在文本中的出现频率。
```java
Map<String, Integer> wordCount = new HashMap<>();
```
`wordCount`是一个映射，其中键是单词，频率是整数。
```java
String fileName = "src/resources/thermopylae.txt";
List<String> lines = Files.readAllLines(Paths.get(fileName),
StandardCharsets.UTF_8);
```
我们使用`Files.readAllLines()`方法一次读取所有内容。
```java
for (String line : lines) {
String[] words = line.split("\\s+");
...
```
我们遍历这些行，将它们分成单词； 单词之间用空格隔开。
```java
if (word.endsWith(".") || word.endsWith(",")) {
word = word.substring(0, word.length()-1);
}
```
我们删除尾随点和逗号。
```java
if (wordCount.containsKey(word)) {
wordCount.put(word, wordCount.get(word) + 1);
} else {
wordCount.put(word, 1);
}
```
如果单词已经在映射中，则增加其频率； 否则，我们将其插入映射并将其频率设置为 1。
```java
for (String key : wordCount.keySet()) {
System.out.println(key + ": " + wordCount.get(key));
}
```
我们遍历映射并打印其键/值对。
```java
$ java com.zetcode.CountingWordsEx
been: 1
Athenian: 1
alliance: 1
navy: 1
fought: 1
led: 1
delayed: 1
had: 2
during: 1
three: 1
second: 1
Greece: 3
Leonidas: 1
...
```
这是示例的部分输出。
## Java `TreeMap`
`TreeMap`是根据其键的自然顺序排序的映射。 尽管`HashMap`更省时，但`TreeMap`更节省空间。
`TreeMapEx.java`
```java
package com.zetcode;
import java.util.TreeMap;
public class TreeMapEx {
public static void main(String[] args) {
TreeMap<String, String> domains = new TreeMap<>();
domains.put("de", "Germany");
domains.put("sk", "Slovakia");
domains.put("us", "United States");
domains.put("ru", "Russia");
domains.put("hu", "Hungary");
domains.put("pl", "Poland");
System.out.println(domains);
System.out.println(domains.descendingMap());
}
}
```
在示例中，我们创建一个`TreeMap`并将域名及其国家/地区放入其中。
```java
TreeMap<String, String> domains = new TreeMap<>();
```
创建了`TreeMap`。
```java
System.out.println(domains);
```
这将按键/值的自然排序顺序（升序）打印。
```java
System.out.println(domains.descendingMap());
```
`descendingMap()`方法返回此映射中包含的映射的逆序视图。
```java
$ java com.zetcode.TreeMapEx
{de=Germany, hu=Hungary, pl=Poland, ru=Russia, sk=Slovakia, us=United States}
{us=United States, sk=Slovakia, ru=Russia, pl=Poland, hu=Hungary, de=Germany}
```
`com.zetcode.TreeMapEx`程序按升序和降序打印键值。
## Java `HashSet`
`HashSet`是一个不包含重复元素的集合。 此类为基本操作（添加，删除，包含和调整大小）提供恒定的时间性能。 `HashSet`不提供元素的排序。
`HashSetEx.java`
```java
package com.zetcode;
import java.util.HashSet;
import java.util.Set;
public class HashSetEx {
public static void main(String[] args) {
Set<String> brands = new HashSet<>();
brands.add("Pepsi");
brands.add("Amazon");
brands.add("Volvo");
brands.add("IBM");
brands.add("IBM");
System.out.println(brands);
System.out.println(brands.isEmpty());
System.out.println(brands.contains("Volvo"));
brands.remove("Volvo");
System.out.println(brands.contains("Volvo"));
brands.clear();
System.out.println(brands);
}
}
```
名称下只能注册一个品牌。 因此，品牌名称是`HashSet`的一个很好的例子。
```java
Set<String> brands = new HashSet<>();
brands.add("Pepsi");
brands.add("Amazon");
brands.add("Volvo");
brands.add("IBM");
brands.add("IBM");
```
我们创建一个`HashSet`并添加新元素。 IBM 品牌被添加两次。 但是，IBM 在容器中仅存在一次。
```java
System.out.println(brands);
```
一键打印所有元素。
```java
System.out.println(brands.isEmpty());
```
`isEmpty()`方法检查容器是否为空。
```java
System.out.println(brands.contains("Volvo"));
```
使用`contains()`方法，我们检查品牌容器中是否存在沃尔沃品牌。 该行打印`true`。
```java
brands.remove("Volvo");
System.out.println(brands.contains("Volvo"));
```
我们从品牌容器中删除了沃尔沃品牌。 第二行打印`false`。
```java
brands.clear();
```
`clear()`方法从集合中删除所有元素。
```java
$ java com.zetcode.HashSetEx
[IBM, Pepsi, Volvo, Amazon]
false
true
false
[]
```
这是`com.zetcode.HashSetEx`程序的输出。
## Java `TreeSet`
`TreeSet`是具有使用自然顺序排序的元素的集合。 `TreeSet`比`HashSet`慢。 `HashSet`可以包含空值，而`TreeSet`不能包含空值。
`TreeSetEx.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
public class TreeSetEx {
public static void main(String[] args) {
List<String> brands = new ArrayList<>();
brands.add("Pepsi");
brands.add("Amazon");
brands.add("Volvo");
brands.add("IBM");
brands.add("HP");
brands.add("Apple");
brands.add("Starbucks");
TreeSet<String> brands2 = new TreeSet<>();
brands2.addAll(brands);
System.out.println(brands2);
System.out.println(brands2.descendingSet());
System.out.println(brands2.first());
System.out.println(brands2.last());
System.out.println(brands2.headSet("IBM", true));
System.out.println(brands2.tailSet("IBM", false));
System.out.println(brands2.subSet("Apple", true, "Starbucks", true));
}
}
```
在此示例中，我们使用`TreeSet`。
```java
List<String> brands = new ArrayList<>();
brands.add("Pepsi");
brands.add("Amazon");
brands.add("Volvo");
brands.add("IBM");
brands.add("HP");
brands.add("Apple");
brands.add("Starbucks");
```
创建了各种品牌的`ArrayList`。
```java
TreeSet<String> brands2 = new TreeSet<>();
brands2.addAll(brands);
```
借助`addAll()`方法，从`ArrayList`容器中创建了一个新的`TreeSet`。
```java
System.out.println(brands2);
System.out.println(brands2.descendingSet());
```
容器的元素按升序和降序打印到控制台。
```java
System.out.println(brands2.first());
System.out.println(brands2.last());
```
我们打印容器的第一个和最后一个元素。
```java
System.out.println(brands2.headSet("IBM", true));
```
`headSet()`方法返回其元素小于指定元素的集合的一个切片。 第二个参数控制是否包含指定的元素。
```java
System.out.println(brands2.tailSet("IBM", false));
```
`tailSet()`方法返回其元素大于指定元素的集合的一个切片。
```java
System.out.println(brands2.subSet("Apple", true, "Starbucks", true));
```
`subSet()`方法返回容器的一部分，其元素范围从第一个指定元素到第二个指定元素。
```java
$ java com.zetcode.TreeSetEx
[Amazon, Apple, HP, IBM, Pepsi, Starbucks, Volvo]
[Volvo, Starbucks, Pepsi, IBM, HP, Apple, Amazon]
Amazon
Volvo
[Amazon, Apple, HP, IBM]
[Pepsi, Starbucks, Volvo]
[Apple, HP, IBM, Pepsi, Starbucks]
```
这是`com.zetcode.TreeSetEx`示例的输出。
## Java `Collections`类
`Collections`是一个工具类，提供了许多使用容器的有用方法。 它仅由静态方法组成。 某些方法不适用于所有集合类型。 例如，不可能在`HashSet`上使用`sort()`方法，因为此容器不支持有序元素。
`CollectionsEx.java`
```java
package com.zetcode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CollectionsEx {
public static void main(String[] args) {
Integer[] nums = { 4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1 };
List<Integer> ns = new ArrayList<>(Arrays.asList(nums));
System.out.println("Default order:");
System.out.println(ns);
System.out.println("Ascending order:");
Collections.sort(ns);
System.out.println(ns);
System.out.println("Descending order:");
Collections.reverse(ns);
System.out.println(ns);
System.out.println("Swapping the first and the last elements:");
Collections.swap(ns, 0, ns.size()-1);
System.out.println(ns);
System.out.println("Replacing all 4s with 0s:");
Collections.replaceAll(ns, 4, 0);
System.out.println(ns);
System.out.println("Random order:");
Collections.shuffle(ns);
System.out.println(ns);
System.out.println(Collections.max(ns));
System.out.println(Collections.min(ns));
}
}
```
在示例中，我们使用`Collections`类的几种方法。
```java
Integer[] nums = { 4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1 };
ArrayList<Integer> ns = new ArrayList<>(Arrays.asList(nums));
```
`ArrayList`由整数数组创建。 `Arrays`类的`asList()`方法用于将数组转换为列表，然后将其传递给构造器。
```java
Collections.sort(ns);
```
`sort()`方法以升序对元素进行排序。
```java
Collections.reverse(ns);
```
`reverse()`方法反转列表中元素的顺序。
```java
Collections.swap(ns, 0, ns.size()-1);
```
`swap()`方法交换两个元素。 在我们的案例中，第一个元素与最后一个元素。
```java
Collections.replaceAll(ns, 4, 0);
```
该行用 0 替换所有出现的数字 4。
```java
Collections.shuffle(ns);
```
`shuffle()`方法随机重新排序容器中的元素。
```java
System.out.println(Collections.max(ns));
System.out.println(Collections.min(ns));
```
在这里，我们打印列表的最大值和最小值。
```java
$ java com.zetcode.CollectionsEx
Default order:
[4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1]
Ascending order:
[0, 1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 8, 9]
Descending order:
[9, 8, 7, 6, 5, 4, 4, 4, 3, 2, 2, 1, 0]
Swapping the first and the last elements:
[0, 8, 7, 6, 5, 4, 4, 4, 3, 2, 2, 1, 9]
Replacing all 4s with 0s:
[0, 8, 7, 6, 5, 0, 0, 0, 3, 2, 2, 1, 9]
Random order:
[1, 6, 2, 8, 0, 2, 0, 9, 5, 0, 7, 3, 0]
9
0
```
这是`com.zetcode.CollectionsEx`程序的示例输出。
Java 教程的这一部分专门用于 Java 集合。
- ZetCode 数据库教程
- MySQL 教程
- MySQL 简介
- MySQL 安装
- MySQL 的第一步
- MySQL 快速教程
- MySQL 存储引擎
- MySQL 数据类型
- 在 MySQL 中创建，更改和删除表
- MySQL 表达式
- 在 MySQL 中插入，更新和删除数据
- MySQL 中的SELECT语句
- MySQL 子查询
- MySQL 约束
- 在 MySQL 中导出和导入数据
- 在 MySQL 中连接表
- MySQL 函数
- MySQL 中的视图
- MySQL 中的事务
- MySQL 存储过程
- MySQL Python 教程
- MySQL Perl 教程
- MySQL & Perl DBI
- 使用 Perl 连接到 MySQL 数据库
- MySQL 中的 Perl 错误处理
- 使用 Perl 进行 MySQL 查询
- 在 MySQL 中使用 Perl 绑定参数&列
- 在 MySQL 中使用 Perl 处理图像
- 使用 Perl 获取 MySQL 元数据
- Perl 的 MySQL 事务
- MySQL C API 编程教程
- MySQL Visual Basic 教程
- MySQL PHP 教程
- MySQL Java 教程
- MySQL Ruby 教程
- MySQL C# 教程
- SQLite 教程
- SQLite 简介
- sqlite3 命令行工具
- 在 SQLite 中创建，删除和更改表
- SQLite 表达式
- SQLite 插入，更新，删除数据
- SQLite SELECT语句
- SQLite 约束
- SQLite 连接表
- SQLite 函数
- SQLite 视图，触发器，事务
- SQLite C 教程
- SQLite Python 教程
- SQLite Perl 教程
- Perl DBI
- 使用 Perl 连接到 SQLite 数据库
- SQLite Perl 错误处理
- 使用 Perl 的 SQLite 查询
- 使用 Perl 绑定 SQLite 参数&列
- 使用 Perl 在 SQLite 中处理图像
- 使用 Perl 获取 SQLite 元数据
- 使用 Perl 进行 SQLite 事务
- SQLite Ruby 教程
- 连接到 SQLite 数据库
- 在 SQLite 中使用 Ruby 进行 SQL 查询
- 绑定参数
- 处理图像
- 使用 Ruby 获取 SQLite 元数据
- Ruby 的 SQLite 事务
- SQLite C# 教程
- SQLite C# 简介
- 使用SqliteDataReader检索数据
- ADO.NET 数据集
- 使用 C# 在 SQLite 中处理图像
- 使用 C# 获取 SQLite 元数据
- 使用 C# 的 SQLite 事务
- SQLite Visual Basic 教程
- SQLite Visual Basic 简介
- 使用SqliteDataReader检索数据
- ADO.NET 的数据集
- 使用 Visual Basic 在 SQLite 中处理图像
- 使用 Visual Basic 获取 SQLite 元数据
- 使用 Visual Basic 的 SQLite 事务
- PostgreSQL C 教程
- PostgreSQL Ruby 教程
- PostgreSQL PHP 教程
- PostgreSQL PHP 编程简介
- 在 PostgreSQL 中使用 PHP 检索数据
- 在 PostgreSQL 中使用 PHP 处理图像
- 用 PHP 获取 PostgreSQL 元数据
- 在 PostgreSQL 中使用 PHP 进行事务
- PostgreSQL Java 教程
- Apache Derby 教程
- Derby 简介
- Derby 的安装&配置
- Derby 工具
- ij 工具
- Derby 中的 SQL 查询
- 在 Derby 中使用 JDBC 进行编程
- Derby 安全
- 使用 Derby & Apache Tomcat
- NetBeans 和 Derby
- SQLAlchemy 教程
- SQLAlchemy 简介
- 原始 SQL
- 模式定义语言
- SQL 表达式语言
- SQLAlchemy 中的对象关系映射器
- MongoDB PHP 教程
- MongoDB JavaScript 教程
- MongoDB Ruby 教程
- Spring JdbcTemplate 教程
- JDBI 教程
- MyBatis 教程
- Hibernate Derby 教程
- ZetCode .NET 教程
- Visual Basic 教程
- Visual Basic
- Visual Basic 语法结构
- 基本概念
- Visual Basic 数据类型
- Visual Basic 中的字符串
- 运算符
- 控制流
- Visual Basic 数组
- Visual Basic 中的过程&函数
- 在 Visual Basic 中组织代码
- 面向对象编程
- Visual Basic 中的面向对象编程 II
- Visual Basic 中的集合
- 输入和输出
- C# 教程
- C# 语言
- C# 语法结构
- C# 基础
- C# 数据类型
- C# 中的字符串
- C# 运算符
- C# 中的流控制
- C# 数组
- C# 面向对象编程
- C# 中的方法
- C# 面向对象编程 II
- C# 属性
- C# 结构
- C# 委托
- 命名空间
- C# 集合
- C# 输入和输出
- C# 目录教程
- C# 字典教程
- 在 C# 中读取文本文件
- C# 中的日期和时间
- 在 C# 中读取网页
- C# HttpClient教程
- ASP.NET Core 教程
- ZetCode 图形教程
- Java 2D 游戏教程
- Java 游戏基础
- 动画
- 移动精灵
- 碰撞检测
- Java 益智游戏
- Java Snake
- Breakout 游戏
- Java 俄罗斯方块
- Java 吃豆人
- Java 太空侵略者
- Java 扫雷
- Java 推箱子
- Java 2D 教程
- 介绍
- 基本绘图
- 形状和填充
- 透明度
- 合成
- 剪裁
- 变换
- 特效
- 图像
- 文字和字体
- 命中测试，移动物体
- 俄罗斯方块
- Cario 图形教程
- Cario 图形库
- Cario 定义
- Cairo 后端
- Cairo 基本图形
- 形状和填充
- 渐变
- 透明度
- 合成
- 剪裁和遮罩
- 变换
- Cairo 文字
- Cairo 中的图像
- 根窗口
- PyCairo 教程
- PyCairo 简介
- PyCairo 后端
- PyCairo 中的基本绘图
- PyCairo 形状和填充
- PyCairo 渐变
- PyCairo 剪裁&遮罩
- PyCairo 的透明度
- PyCairo 中的变换
- PyCairo 中的文字
- PyCairo 中的图像
- 根窗口
- HTML5 画布教程
- 介绍
- HTML5 画布中的直线
- HTML5 画布形状
- HTML5 画布填充
- HTML5 画布中的透明度
- HTML5 画布合成
- HTML5 canvas 中的变换
- HTML5 画布中的文字
- HTML5 画布中的动画
- HTML5 画布中的 Snake
- ZetCode GUI 教程
- Windows API 教程
- Windows API 简介
- Windows API main函数
- Windows API 中的系统函数
- Windows API 中的字符串
- Windows API 中的日期和时间
- Windows API 中的一个窗口
- UI 的第一步
- Windows API 菜单
- Windows API 对话框
- Windows API 控件 I
- Windows API 控件 II
- Windows API 控件 III
- Windows API 中的高级控件
- Windows API 中的自定义控件
- Windows API 中的 GDI
- PyQt4 教程
- PyQt4 简介
- PyQt4 中的第一个程序
- PyQt4 中的菜单和工具栏
- PyQt4 中的布局管理
- PyQt4 中的事件和信号
- PyQt4 中的对话框
- PyQt4 小部件
- PyQt4 小部件 II
- PyQt4 中的拖放
- PyQt4 中的绘图
- PyQt4 中的自定义小部件
- PyQt4 中的俄罗斯方块游戏
- PyQt5 教程
- PyQt5 简介
- PyQt5 日期和时间
- PyQt5 中的第一个程序
- PyQt5 中的菜单和工具栏
- PyQt5 中的布局管理
- PyQt5 中的事件和信号
- PyQt5 中的对话框
- PyQt5 小部件
- PyQt5 小部件 II
- PyQt5 拖放
- PyQt5 中的绘图
- PyQt5 中的自定义小部件
- PyQt5 中的俄罗斯方块
- Qt4 教程
- Qt4 工具包简介
- Qt4 工具类
- Qt4 中的字符串
- Qt4 中的日期和时间
- 在 Qt4 中使用文件和目录
- Qt4 中的第一个程序
- Qt4 中的菜单和工具栏
- Qt4 中的布局管理
- Qt4 中的事件和信号
- Qt4 小部件
- Qt4 小部件 II
- Qt4 中的绘图
- Qt4 中的自定义小部件
- Qt4 中的打砖块游戏
- Qt5 教程
- Qt5 工具包简介
- Qt5 中的字符串
- Qt5 中的日期和时间
- Qt5 中的容器
- 在 Qt5 中处理文件和目录
- Qt5 中的第一个程序
- Qt5 中的菜单和工具栏
- Qt5 中的布局管理
- Qt5 中的事件和信号
- Qt5 小部件
- Qt5 小部件 II
- Qt5 中的绘图
- Qt5 中的自定义小部件
- Qt5 中的贪食蛇
- Qt5 中的打砖块游戏
- PySide 教程
- PySide 工具包简介
- PySide 中的第一个程序
- PySide 中的菜单和工具栏
- PySide 中的布局管理
- PySide 中的事件和信号
- PySide 中的对话框
- PySide 小部件
- PySide 小部件 II
- 在 PySide 中拖放
- 在 PySide 中绘图
- PySide 中的自定义小部件
- PySide 中的俄罗斯方块游戏
- Tkinter 教程
- Tkinter 简介
- Tkinter 中的布局管理
- Tkinter 标准小部件属性
- Tkinter 小部件
- Tkinter 中的菜单和工具栏
- Tkinter 中的对话框
- Tkinter 中的绘图
- Tkinter 中的贪食蛇
- Tcl/Tk 教程
- Tcl/Tk 简介
- Tcl/Tk 中的布局管理
- Tcl/Tk 小部件
- Tcl/Tk 中的菜单和工具栏
- Tcl/Tk 中的对话框
- Tcl/Tk 绘图
- 贪食蛇
- Qt 快速教程
- Java Swing 教程
- Java Swing 简介
- Java Swing 首个程序
- Java Swing 中的菜单和工具栏
- Swing 布局管理
- GroupLayout管理器
- Java Swing 事件
- 基本的 Swing 组件
- 基本的 Swing 组件 II
- Java Swing 对话框
- Java Swing 模型架构
- Swing 中的拖放
- Swing 中的绘图
- Java Swing 中的可调整大小的组件
- Java Swing 中的益智游戏
- 俄罗斯方块
- JavaFX 教程
- JavaFX 简介
- JavaFX 首个程序
- JavaFX 布局窗格
- 基本的 JavaFX 控件
- 基本 JavaFX 控件 II
- JavaFX 事件
- JavaFX 效果
- JavaFX 动画
- JavaFX 画布
- JavaFX 图表
- Java SWT 教程
- Java SWT 简介
- Java SWT 中的布局管理
- Java SWT 中的菜单和工具栏
- Java SWT 中的小部件
- Table小部件
- Java SWT 中的对话框
- Java SWT 绘图
- Java SWT 中的贪食蛇
- wxWidgets 教程
- wxWidgets 简介
- wxWidgets 助手类
- wxWidgets 中的第一个程序
- wxWidgets 中的菜单和工具栏
- wxWidgets 中的布局管理
- wxWidgets 中的事件
- wxWidgets 中的对话框
- wxWidgets 小部件
- wxWidgets 小部件 II
- wxWidgets 中的拖放
- wxWidgets 中的设备上下文
- wxWidgets 中的自定义小部件
- wxWidgets 中的俄罗斯方块游戏
- wxPython 教程
- wxPython 简介
- 第一步
- 菜单和工具栏
- wxPython 中的布局管理
- wxPython 中的事件
- wxPython 对话框
- 小部件
- wxPython 中的高级小部件
- wxPython 中的拖放
- wxPython 图形
- 创建自定义小部件
- wxPython 中的应用框架
- wxPython 中的俄罗斯方块游戏
- C# Winforms Mono 教程
- Mono Winforms 简介
- Mono Winforms 中的第一步
- Mono Winforms 中的布局管理
- Mono Winforms 中的菜单和工具栏
- Mono Winforms 中的基本控件
- Mono Winforms 中的高级控件
- 对话框
- Mono Winforms 中的拖放
- Mono Winforms 中的绘图
- Mono Winforms 中的贪食蛇
- Java Gnome 教程
- Java Gnome 简介
- Java Gnome 的第一步
- Java Gnome 中的布局管理
- Java Gnome 中的布局管理 II
- Java Gnome 中的菜单
- Java Gnome 中的工具栏
- Java Gnome 中的事件
- Java Gnome 中的小部件
- Java Gnome 中的小部件 II
- Java Gnome 中的高级小部件
- Java Gnome 中的对话框
- Java Gnome 中的 Pango
- 在 Java Gnome 中用 Cairo 绘图
- Cario 绘图 II
- Java Gnome 中的贪食蛇
- QtJambi 教程
- QtJambi 简介
- QtJambi 中的布局管理
- QtJambi 中的小部件
- QtJambi 中的菜单和工具栏
- QtJambi 对话框
- QtJambi 中的绘图
- QtJambi 中的自定义小部件
- 贪食蛇
- GTK+ 教程
- GTK+ 简介
- GTK+ 中的第一个程序
- GTK+ 中的菜单和工具栏
- GTK+ 布局管理
- GTK+ 事件和信号
- GTK+ 对话框
- GTK+ 小部件
- GTK+ 小部件 II
- GtkTreeView小部件
- GtkTextView小部件
- 自定义 GTK+ 小部件
- Ruby GTK 教程
- Ruby GTK 简介
- Ruby GTK 中的布局管理
- Ruby GTK 中的小部件
- Ruby GTK 中的菜单和工具栏
- Ruby GTK 中的对话框
- Ruby GTK Cario 绘图
- Ruby GTK 中的自定义小部件
- Ruby GTK 中的贪食蛇
- GTK# 教程
- GTK# 简介
- GTK 的第一步
- GTK# 中的布局管理
- GTK 中的菜单
- GTK# 中的工具栏
- GTK# 中的事件
- GTK# 中的小部件
- GTK 中的小部件 II
- GTK# 中的高级小部件
- GTK# 中的对话框
- Pango
- GTK# 中的 Cario 绘图
- GTK# 中的 Cario 绘图 II
- GTK# 中的自定义小部件
- Visual Basic GTK# 教程
- Visual Basic GTK# 简介
- 布局管理
- 小部件
- 菜单和工具栏
- 对话框
- Cario 绘图
- 自定义小部件
- 贪食蛇
- PyGTK 教程
- PyGTK 简介
- PyGTK 的第一步
- PyGTK 中的布局管理
- PyGTK 中的菜单
- PyGTK 中的工具栏
- PyGTK 中的事件和信号
- PyGTK 中的小部件
- PyGTK 中的小部件 II
- PyGTK 中的高级小部件
- PyGTK 中的对话框
- Pango
- Pango II
- PyGTK 中的 Cario 绘图
- Cario 绘图 II
- PyGTK 中的贪食蛇游戏
- PyGTK 中的自定义小部件
- PHP GTK 教程
- PHP GTK 简介
- PHP GTK 中的布局管理
- PHP GTK 中的小部件
- PHP GTK 中的菜单和工具栏
- 对话框
- Cario 绘图
- 自定义小部件
- 贪食蛇
- C# Qyoto 教程
- Qyoto 介绍
- 布局管理
- Qyoto 中的小部件
- Qyoto 中的菜单和工具栏
- Qyoto 对话框
- Qyoto 中的绘图
- Qyoto 中的绘图 II
- Qyoto 中的自定义小部件
- 贪食蛇
- Ruby Qt 教程
- Ruby Qt 简介
- Ruby Qt 中的布局管理
- Ruby Qt 中的小部件
- 菜单和工具栏
- Ruby Qt 中的对话框
- 用 Ruby Qt 绘图
- Ruby Qt 中的自定义小部件
- Ruby Qt 中的贪食蛇
- Visual Basic Qyoto 教程
- Qyoto 介绍
- 布局管理
- Qyoto 中的小部件
- Qyoto 中的菜单和工具栏
- Qyoto 对话框
- Qyoto 中的绘图
- Qyoto 中的自定义小部件
- 贪食蛇
- Mono IronPython Winforms 教程
- 介绍
- IronPython Mono Winforms 中的第一步
- 布局管理
- 菜单和工具栏
- Mono Winforms 中的基本控件
- Mono Winforms 中的基本控件 II
- Mono Winforms 中的高级控件
- 对话框
- Mono Winforms 中的拖放
- 绘图
- IronPython Mono Winforms 中的绘图 II
- IronPython Mono Winforms 中的贪食蛇
- IronPython Mono Winforms 中的俄罗斯方块游戏
- FreeBASIC GTK 教程
- Jython Swing 教程
- Jython Swing 简介
- Jython Swing 中的布局管理
- Jython Swing 中的组件
- Jython Swing 中的菜单和工具栏
- Jython Swing 中的对话框
- Jython Swing 中的绘图
- Jython Swing 中的半字节
- JRuby Swing 教程
- JRuby Swing 简介
- JRuby Swing 中的布局管理
- JRuby Swing 中的组件
- 菜单和工具栏
- JRuby Swing 中的对话框
- 在 JRuby Swing 中绘图
- JRuby Swing 中的贪食蛇
- Visual Basic Winforms 教程
- Visual Basic Winforms 简介
- 布局管理
- 基本控制
- 进阶控件
- 菜单和工具栏
- 对话框
- 绘图
- 拖放
- 贪食蛇
- JavaScript GTK 教程
- JavaScript GTK 简介
- 布局管理
- JavaScript GTK 中的小部件
- JavaScript GTK 中的菜单和工具栏
- JavaScript GTK 中的对话框
- JavaScript GTK 中的 Cario 绘图
- ZetCode Java 教程
- Java 教程
- Java 语言
- Java 语法结构
- Java 基础
- Java 数据类型
- Java 数据类型 II
- Java 字符串
- Java 数组
- Java 表达式
- Java 控制流程
- Java 面向对象的编程
- Java 方法
- Java 面向对象编程 II
- Java 包
- Java 中的异常
- Java 集合
- Java 流
- Java Future 教程
- Java Comparable和Comparator
- Java DOM 教程
- Java MVC 教程
- Java SAX 教程
- Java JAXB 教程
- Java JSON 处理教程
- Java H2 教程
- MongoDB Java 教程
- Java 正则表达式教程
- Java PDFBox 教程
- Java 文件教程
- Java Files.list教程
- Java Files.walk教程
- Java DirectoryStream教程
- Java 外部与内部迭代器
- Java 文件大小
- 用 Java 创建目录
- 用 Java 创建文件
- Java Log4j 教程
- Gson 教程
- Java RequestDispatcher
- Java HTTP GET/POST 请求
- Java InputStream教程
- Java FileOutputStream教程
- Java FileInputStream教程
- Java ZipInputStream教程
- Java FileWriter教程
- EJB 简介
- Java forEach教程
- Jetty 教程
- Tomcat Derby 教程
- Stripes 介绍
- 使用 Stripes 的 Java webapp，MyBatis，& Derby
- EclipseLink 简介
- Java 中的数据源
- JSTL 中的 SQL 查询标记
- Java 验证过滤器
- Hibernate 验证器
- 用 Java 显示图像
- Play 框架简介
- Spark Java 简介
- Java ResourceBundle教程
- Jtwig 教程
- Java Servlet 教程
- Java 套接字教程
- FreeMarker 教程
- Android 教程
- Java EE 5 教程
- JSoup 教程
- JFreeChart 教程
- ImageIcon教程
- 用 Java 复制文件
- Java 文件时间教程
- 如何使用 Java 获取当前日期时间
- Java 列出目录内容
- Java 附加到文件
- Java ArrayList教程
- 用 Java 读写 ICO 图像
- Java int到String的转换
- Java HashSet教程
- Java HashMap教程
- Java static关键字
- Java 中的HashMap迭代
- 用 Java 过滤列表
- 在 Java 中读取网页
- Java 控制台应用
- Java 集合的便利工厂方法
- Google Guava 简介
- OpenCSV 教程
- 用 Java8 的StringJoiner连接字符串
- Java 中元素迭代的历史
- Java 谓词
- Java StringBuilder
- Java 分割字串教学
- Java NumberFormat
- Java TemporalAdjusters教程
- Apache FileUtils教程
- Java Stream 过滤器
- Java 流归约
- Java 流映射
- Java InputStreamReader教程
- 在 Java 中读取文本文件
- Java Unix 时间
- Java LocalTime
- Java 斐波那契
- Java ProcessBuilder教程
- Java 11 的新功能
- ZetCode JavaScript 教程
- Ramda 教程
- Lodash 教程
- Collect.js 教程
- Node.js 简介
- Node HTTP 教程
- Node-config 教程
- Dotenv 教程
- Joi 教程
- Liquid.js 教程
- faker.js 教程
- Handsontable 教程
- PouchDB 教程
- Cheerio 教程
- Axios 教程
- Jest 教程
- JavaScript 正则表达式
- 用 JavaScript 创建对象
- Big.js 教程
- Moment.js 教程
- Day.js 教程
- JavaScript Mustache 教程
- Knex.js 教程
- MongoDB JavaScript 教程
- Sequelize 教程
- Bookshelf.js 教程
- Node Postgres 教程
- Node Sass 教程
- Document.querySelector教程
- Document.all教程
- JSON 服务器教程
- JavaScript 贪食蛇教程
- JavaScript 构建器模式教程
- JavaScript 数组
- XMLHttpRequest教程
- 从 JavaScript 中的 URL 读取 JSON
- 在 JavaScript 中循环遍历 JSON 数组
- jQuery 教程
- Google 图表教程
- ZetCode Kotlin 教程
- Kotlin Hello World 教程
- Kotlin 变量
- Kotlin 的运算符
- Kotlin when表达式
- Kotlin 数组
- Kotlin 范围
- Kotlin Snake
- Kotlin Swing 教程
- Kotlin 字符串
- Kotlin 列表
- Kotlin 映射
- Kotlin 集合
- Kotlin 控制流程
- Kotlin 写入文件
- Kotlin 读取文件教程
- Kotlin 正则表达式
- ZetCode 其它教程
- TCL 教程
- Tcl
- Tcl 语法结构
- Tcl 中的基本命令
- Tcl 中的表达式
- Tcl 中的控制流
- Tcl 中的字符串
- Tcl 列表
- Tcl 中的数组
- Tcl 中的过程
- 输入&输出
- AWK 教程
- Vaadin 教程
- Vaadin 框架介绍
- Vaadin Grid教程
- Vaadin TextArea教程
- Vaadin ComboBox教程
- Vaadin Slider教程
- Vaadin CheckBox教程
- Vaadin Button教程
- Vaadin DateField教程
- Vaadin Link教程
- ZetCode PHP 教程
- PHP 教程
- PHP
- PHP 语法结构
- PHP 基础
- PHP 数据类型
- PHP 字符串
- PHP 运算符
- PHP 中的控制流
- PHP 数组
- PHP 数组函数
- PHP 中的函数
- PHP 正则表达式
- PHP 中的面向对象编程
- PHP 中的面向对象编程 II
- PHP Carbon 教程
- PHP Monolog 教程
- PHP 配置教程
- PHP Faker 教程
- Twig 教程
- Valitron 教程
- Doctrine DBAL QueryBuilder 教程
- PHP Respect 验证教程
- PHP Rakit 验证教程
- PHP PDO 教程
- CakePHP 数据库教程
- PHP SQLite3 教程
- PHP 文件系统函数
- ZetCode Python 教程
- Python 教程
- Python 语言
- 交互式 Python
- Python 语法结构
- Python 数据类型
- Python 字符串
- Python 列表
- Python 字典
- Python 运算符
- Python 关键字
- Python 函数
- Python 中的文件
- Python 中的面向对象编程
- Python 模块
- Python 中的包
- Python 异常
- Python 迭代器和生成器
- Python 内省
- Python Faker 教程
- Python f 字符串教程
- Python bcrypt 教程
- Python 套接字教程
- Python smtplib教程
- OpenPyXL 教程
- Python pathlib教程
- Python YAML 教程
- Python 哈希教程
- Python ConfigParser教程
- Python 日志教程
- Python argparse 教程
- Python SQLite 教程
- Python Cerberus 教程
- Python PostgreSQL 教程
- PyMongo 教程
- PyMySQL 教程
- Peewee 教程
- pyDAL 教程
- pytest 教程
- Bottle 教程
- Python Jinja 教程
- PrettyTable 教程
- BeautifulSoup 教程
- pyquery 教程
- Python for循环
- Python 反转
- Python Lambda 函数
- Python 集合
- Python 映射
- Python CSV 教程-读写 CSV
- Python 正则表达式
- Python SimpleJson 教程
- SymPy 教程
- Pandas 教程
- Matplotlib 教程
- Pillow 教程
- Python FTP 教程
- Python Requests 教程
- Python Arrow 教程
- Python 列表推导式
- Python 魔术方法
- PyQt 中的QPropertyAnimation
- PyQt 中的QNetworkAccessManager
- ZetCode Ruby 教程
- Ruby 教程
- Ruby
- Ruby 语法结构
- Ruby 基础
- Ruby 变量
- Ruby 中的对象
- Ruby 数据类型
- Ruby 字符串
- Ruby 表达式
- Ruby 控制流
- Ruby 数组
- Ruby 哈希
- Ruby 中的面向对象编程
- Ruby 中的面向对象编程 II
- Ruby 正则表达式
- Ruby 输入&输出
- Ruby HTTPClient教程
- Ruby Faraday 教程
- Ruby Net::HTTP教程
- ZetCode Servlet 教程
- 从 Java Servlet 提供纯文本
- Java Servlet JSON 教程
- Java Servlet HTTP 标头
- Java Servlet 复选框教程
- Java servlet 发送图像教程
- Java Servlet JQuery 列表教程
- Servlet FreeMarker JdbcTemplate 教程-CRUD 操作
- jQuery 自动补全教程
- Java servlet PDF 教程
- servlet 从 WAR 内读取 CSV 文件
- Java HttpServletMapping
- EasyUI datagrid
- Java Servlet RESTFul 客户端
- Java Servlet Log4j 教程
- Java Servlet 图表教程
- Java ServletConfig教程
- Java Servlet 读取网页
- 嵌入式 Tomcat
- Java Servlet 分页
- Java Servlet Weld 教程
- Java Servlet 上传文件
- Java Servlet 提供 XML
- Java Servlet 教程
- JSTL forEach标签
- 使用 jsGrid 组件
- ZetCode Spring 教程
- Spring @Bean注解教程
- Spring @Autowired教程
- Spring @GetMapping教程
- Spring @PostMapping教程
- Spring @DeleteMapping教程
- Spring @RequestMapping教程
- Spring @PathVariable教程
- Spring @RequestBody教程
- Spring @RequestHeader教程
- Spring Cookies 教程
- Spring 资源教程
- Spring 重定向教程
- Spring 转发教程
- Spring ModelAndView教程
- Spring MessageSource教程
- Spring AnnotationConfigApplicationContext
- Spring BeanFactoryPostProcessor教程
- Spring BeanFactory教程
- Spring context:property-placeholder教程
- Spring @PropertySource注解教程
- Spring @ComponentScan教程
- Spring @Configuration教程
- Spring C 命名空间教程
- Spring P 命名空间教程
- Spring bean 引用教程
- Spring @Qualifier注解教程
- Spring ClassPathResource教程
- Spring 原型作用域 bean
- Spring Inject List XML 教程
- Spring 概要文件 XML 教程
- Spring BeanDefinitionBuilder教程
- Spring 单例作用域 bean
- 独立的 Spring 应用
- 经典 Spring 应用中的JdbcTemplate
- Spring EmbeddedDatabaseBuilder教程
- Spring HikariCP 教程
- Spring Web 应用简介
- Spring BeanPropertyRowMapper教程
- Spring DefaultServlet教程
- Spring WebSocket 教程
- Spring WebJars 教程
- Spring @MatrixVariable教程
- Spring Jetty 教程
- Spring 自定义 404 错误页面教程
- Spring WebApplicationInitializer教程
- Spring BindingResult教程
- Spring FreeMarker 教程
- Spring Thymeleaf 教程
- Spring ResourceHandlerRegistry教程
- SpringRunner 教程
- Spring MockMvc 教程
- ZetCode Spring Boot 教程
- Spring Boot 发送电子邮件教程
- Spring Boot WebFlux 教程
- Spring Boot ViewControllerRegistry教程
- Spring Boot CommandLineRunner教程
- Spring Boot ApplicationReadyEvent 教程
- Spring Boot CORS 教程
- Spring Boot @Order教程
- Spring Boot @Lazy教程
- Spring Boot Flash 属性
- Spring Boot CrudRepository 教程
- Spring Boot JpaRepository 教程
- Spring Boot findById 教程
- Spring Boot Data JPA @NamedQuery教程
- Spring Boot Data JPA @Query教程
- Spring Boot Querydsl 教程
- Spring Boot Data JPA 排序教程
- Spring Boot @DataJpaTest教程
- Spring Boot TestEntityManager 教程
- Spring Boot Data JPA 派生的查询
- Spring Boot Data JPA 查询示例
- Spring Boot Jersey 教程
- Spring Boot CSV 教程
- SpringBootServletInitializer教程
- 在 Spring Boot 中加载资源
- Spring Boot H2 REST 教程
- Spring Boot RestTemplate
- Spring Boot REST XML 教程
- Spring Boot Moustache 教程
- Spring Boot Thymeleaf 配置
- Spring Boot 自动控制器
- Spring Boot FreeMarker 教程
- Spring Boot Environment
- Spring Boot Swing 集成教程
- 在 Spring Boot 中提供图像文件
- 在 Spring Boot 中创建 PDF 报告
- Spring Boot 基本注解
- Spring Boot @ResponseBody教程
- Spring Boot @PathVariable教程
- Spring Boot REST Data JPA 教程
- Spring Boot @RequestParam教程
- Spring Boot 列出 bean
- Spring Boot @Bean
- Spring Boot @Qualifier教程
- 在 Spring Boot 中提供静态内容
- Spring Boot Whitelabel 错误
- Spring Boot DataSourceBuilder 教程
- Spring Boot H2 教程
- Spring Boot Web JasperReports 集成
- Spring Boot iText 教程
- Spring Boot cmd JasperReports 集成
- Spring Boot RESTFul 应用
- Spring Boot 第一个 Web 应用
- Spring Boot Groovy CLI
- Spring Boot 上传文件
- Spring Boot @ExceptionHandler
- Spring Boot @ResponseStatus
- Spring Boot ResponseEntity
- Spring Boot @Controller
- Spring Boot @RestController
- Spring Boot @PostConstruct
- Spring Boot @Component
- Spring Boot @ConfigurationProperties教程
- Spring Boot @Repository
- Spring Boot MongoDB 教程
- Spring Boot MongoDB Reactor 教程
- Spring Boot PostgreSQL 教程
- Spring Boot @ModelAttribute
- Spring Boot 提交表单教程
- Spring Boot Model
- Spring Boot MySQL 教程
- Spring Boot GenericApplicationContext
- SpringApplicationBuilder教程
- Spring Boot Undertow 教程
- Spring Boot 登录页面教程
- Spring Boot RouterFunction 教程
- ZetCode Symfony 教程
- Symfony DBAL 教程
- Symfony 表单教程
- Symfony CSRF 教程
- Symfony Vue 教程
- Symfony 简介
- Symfony 请求教程
- Symfony HttpClient教程
- Symfony Flash 消息
- 在 Symfony 中发送邮件
- Symfony 保留表单值
- Symfony @Route注解教程
- Symfony 创建路由
- Symfony 控制台命令教程
- Symfony 上传文件
- Symfony 服务教程
- Symfony 验证教程
- Symfony 翻译教程