Set（ ） ， （ ， ） ， ， ， ， ， ， ，
## 1. Collection的Set接口
回顾一下上一张的collection类属关系， （ ） ， ，
> The Set interface extends the Collection interface. It does not introduce new methods or constants, but it stipulates that an instance of Set contains no duplicate elements. The concrete classes that implement Set must ensure that no duplicate elements can be added to the set. That is no two elements e1 and e2 can be in the set such that e1.equals(e2) is true.
>
> Set 接口由Collection接口扩展而来， ， ，
总之一句话，
从上图中可以看到类和接口的关系， ， ， ，
```java
import java.util.*;
public class TestHashSet {
public static void main(String[] args) {
// Create a hash set
Set< String > set = new HashSet< String > (); // 变量是Set类型，
// Add strings to the set
set.add("London");
set.add("Paris");
set.add("New York");
set.add("San Francisco");
set.add("Beijing");
set.add("New York");
System.out.println(set);
// Display the elements in the hash set
for (String s : set) {
System.out.print(s.toUpperCase() + ":");
}
}
}
```
可以看到`New York`虽然被添加了两次， ， （ ， ， ）
当然，如果写成：
```java
AbstractSet< String > set = new HashSet< String > ();
HashSet set = new HashSet< String > ();
Collection< String > set = new HashSet< String > ();
```
也是可以了，引用变量只是能力申明。
另外需要注意： ， ， ， ，
到现在我们发现， ， ， （ ， ） ， ： ， ， ， ，
### 1.1. 统计关键词总数量
```java
import java.util.*;
import java.io.*;
public class CountKeywords {
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
System.out.print("Enter a Java source file: ");
String filename = input.nextLine();
File file = new File(filename);
if (file.exists()) {
System.out.println("The number of keywords in " + filename + " is " + countKeywords(file));
} else {
System.out.println("File " + filename + " does not exist");
}
}
public static int countKeywords(File file) throws Exception {
// Array of all Java keywords + true, false and null
String[] keywordString = { "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class",
"const", "continue", "default", "do", "double", "else", "enum", "extends", "for", "final", "finally",
"float", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native",
"new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super",
"switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while",
"true", "false", "null" };
Set< String > keywordSet = new HashSet< String > (Arrays.asList(keywordString));
int count = 0;
Scanner input = new Scanner(file);
while (input.hasNext()) {
String word = input.next();
if (keywordSet.contains(word))
count++;
}
return count;
}
}
```
上面这个例子作为了解，可以分析一下这个程序到底要做什么？
## 2. Map接口
> The Map interface maps keys to the elements. The keys are like indexes. In List, the indexes are integer. In Map, the keys can be any objects.
>
> Map 接口中， ， （ ） ， ， （ ）
>
>
> An instance of Map represents a group of objects, each of which is associated with a key. You can get the object from a map using a key, and you have to use a key to put the object into the map.
>
> 每一个Map的实例都代表一系列的对象组， ， ，
引用网上一个比较完整的类图：[容器框架概述](https://blog.csdn.net/WZD2012/article/details/73245493)
下图是Map接口的基本定义，
下图是Map接口的其他实现， ， ， ，
### 2.1. HashMap
```java
import java.util.*;
public class TestMap {
public static void main(String[] args) {
// Create a HashMap
Map< String , Integer > hashMap = new HashMap< String , Integer > ();
hashMap.put("Smith", 30);
hashMap.put("Anderson", 31);
hashMap.put("Lewis", 29);
hashMap.put("Cook", 29);
hashMap.put("Cook", 31); // 修改 Cooke 的值为 31，
System.out.println("Display entries in HashMap");
System.out.println(hashMap + "\n");
// Create a TreeMap from the preceding HashMap
Map< String , Integer > treeMap = new TreeMap< String , Integer > (hashMap);
System.out.println("Display entries in ascending order of key");
System.out.println(treeMap);
// Create a LinkedHashMap
Map< String , Integer > linkedHashMap = new LinkedHashMap< String , Integer > (16, 0.75f, true);
linkedHashMap.put("Smith", 30);
linkedHashMap.put("Anderson", 31);
linkedHashMap.put("Lewis", 29);
linkedHashMap.put("Cook", 29);
// Display the age for Lewis
System.out.println("\nThe age for " + "Lewis is " + linkedHashMap.get("Lewis"));
System.out.println("Display entries in LinkedHashMap");
System.out.println(linkedHashMap);
}
}
```
输入结果是：
```java
Display entries in HashMap
{Lewis=29, Smith=30, Cook=31, Anderson=31}
Display entries in ascending order of key
{Anderson=31, Cook=31, Lewis=29, Smith=30}
The age for Lewis is 29
Display entries in LinkedHashMap
{Smith=30, Anderson=31, Cook=29, Lewis=29}
```
这里一共3个Map的实现， ，
`HashMap<String, Integer>()`
Map的put方法是向Map中增加一个Key-Value的值， ，
### 2.2. 统计单词出现次数
```java
import java.util.*;
public class CountOccurrenceOfWords {
public static void main(String[] args) {
String text = "Good morning. Have a good class. Afternoon. Have a good time. " + "Have a good visit. Have fun!";
Map< String , Integer > map = new TreeMap< String , Integer > ();
String[] words = text.split("[ \n\t\r.,;:!?(){}]");
for (int i = 0; i < words.length ; i + + ) {
String key = words[i].toLowerCase();
if (key.length() > 0) {
if (!map.containsKey(key)) {
map.put(key, 1);
} else {
int value = map.get(key);
value++;
map.put(key, value);
}
}
}
for (String i : map.keySet()) {
int v = map.get(i);
System.out.printf("%s\t%d\n", i, v);
}
}
}
```
## 3. 本章重点
1. 掌握Set的概念和接口基本使用；
2. 结合HashMap类，
