14.集合框架
集合框架是java做好的用来管理一堆各种类型数据的java类库
1.集合框架结构
集合框架分为2大部分，Collection接口和Map接口。
第一部分Collection接口是用来处理单列数据的集合，最大接口是Collection。Collection接口之下又有两个子接口：List接口和Set接口。List接口下子类ArrayList类和LinkedList类。Set接口下子类HashSet类，再下LinkedHashSet类。
第二部分Map接口是用来处理键值对数据的集合，最大接口是Map接口。Map接口下有HashMap类和Hashtable类。
1.1 Collection接口
用来处理单列数据的集合
1.1.1 List接口
List接口是用来处理有序的单列数据，可以有重复的元素
1.1.1.1 ArrayList类
- 用来处理有序的单列数据，可以有重复的元素
- 添加的元素会自动扩展
- 动态数组结构，查询速度快，添加删除速度慢
1.1.1.2 LinkedList类
- 用来处理有序的单列数据，可以有重复的元素
- 添加的元素会自动扩展
- 双向链表结构，查询速度慢，添加删除速度快
1.1.2 Set接口
Set接口是用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
1.1.2.1 Hashset类
是用来处理无序的单列数据，没有重复的元素，重复的元素算一个
1.1.2.1.1 LinkedHashSet
是用来处理无序的单列数据，没有重复的元素，重复的元素算一个
1.2 Map接口
用来处理键值对数据的集合，例如: name[键]=zhangsan[值]
1.2.1 HashMap类
- 用来处理键值对数据的集合
- 允许有null，键和值都可以为null
1.2.2 Hashtable类
- 用来处理键值对数据的集合
- 不允许有null
1.2.3 TreeMap类
红黑树基于NavigableMap实现【有序】
1.按照键的字母顺序排列
2.键不能为null
3.重复的键被算作是一个数据。
4.非线程安全
1.2.4 ConcurrentHashMap
支持检索的完全并发性和更新的高预期并发性的哈希表。 这个类服从相同功能规范如Hashtable ，并且包括对应于每个方法的方法版本Hashtable 。
2.ArrayList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.动态数组结构，查询速度快，添加删除速度慢
构造方法：
| ArrayList() | 构造一个初始容量为10的空列表 |
| ArrayList(Collection c) | 通过实现Collection 接口的子类/子接口对象创建一个列表 |
| ArrayList(int initialCapacity) | 构造具有指定初始容量的空列表 |
实例方法：
| Boolean add(Object o) | 将指定的元素追加到此列表的末尾 |
| Boolean contains(Object o) | 如果此列表包含指定的元素，则返回 true |
| Object get(int index) | 返回此列表中指定位置的元素 |
| int indexOf(Object o) | 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。 |
| int lastIndexOf(Object o) | 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 |
| Object remove(int index) | 删除该列表中指定位置的元素 |
| boolean remove(Object o) | 从列表中删除指定元素的第一个出现（如果存在）【如果删数字，需要把数字封装】 |
| Object set(int index,Object element) | 用指定的元素替换此列表中指定 |
| int size() | 返回此列表中的元素数 |
| boolean isEmpty() | 如果此列表不包含元素，则返回 true |
| void clear() | 从列表中删除所有元素 |
| Iterator<E> iterator() | 以正确的顺序返回该列表中的元素的迭代器 |
最后一个迭代器方法
Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=list1.iterator();
while (it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器---"+obj);
}
hasNext()是有下一个，判断是否有下一个，为true执行next（），拿出下一个的值。
例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTest {
public static void main(String[] args) {
/*
* ArrayList构造方法 ArrayList() 构造一个初始容量为10的空列表 ArrayList(Collection c)
* 通过实现Collection 接口的子类/子接口对象创建一个列表 ArrayList(int initialCapacity)
* 构造具有指定初始容量的空列表
*/
List list1 = new ArrayList();// 这是接口回调对象
// 或者
ArrayList alist1 = new ArrayList();
// ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
ArrayList alist2 = new ArrayList(list1);
List list2 = new ArrayList(list1);
// ArrayList(int initialCapacity) 构造具有指定初始容量的空列表
ArrayList alist3 = new ArrayList(30);
List list3 = new ArrayList(30);
// 实例方法
// Boolean add(Object o) 将指定的元素追加到此列表的末尾
list1.add("zhangjing");
list1.add(666);
list1.add(true);
list1.add("zhangsan");
list1.add("zhangjing");
list1.add(56.98);
// int size() 返回此列表中的元素数
System.out.println(list1.size());
// Boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
System.out.println(list1.contains(56.98));
// Object get(int index) 返回此列表中指定位置的元素
System.out.println(list1.get(4));
// int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(list1.indexOf(666));
System.out.println(list1.indexOf("weiwei"));// -1
// int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(list1.lastIndexOf("zhangjing"));
// Object remove(int index) 删除该列表中指定位置的元素
System.out.println(list1.remove(2));
System.out.println(list1.size());
// boolean remove(Object o)从列表中删除指定元素的第一个出现（如果存在）
System.out.println(list1.remove("zhangjing"));
// Object set(int index,Object element) 用指定的元素替换此列表中指定
System.out.println(list1.size());
// boolean isEmpty() 如果此列表不包含元素，则返回 true
System.out.println(list1.isEmpty());// false
// void clear() 从列表中删除所有元素
list1.clear();
System.out.println(list1.size());
list2.add("zhangjing");
list2.add(666);
list2.add(true);
list2.add("zhangsan");
list2.add("zhangjing");
list2.add(56.98);
// 遍历集合for循环，增强for循环，迭代器
// Iterator<E> iterator() 以正确的顺序返回该列表中的元素的c
Iterator diedai = list2.iterator();
while (diedai.hasNext()) {
Object obj = diedai.next();
System.out.println("iterator迭代器----" + obj);
}
// for循环，因为是有序的，所以可以用
for (int i = 0; i < list2.size(); i++) {
System.out.println("for循环---"+list2.get(i));
}
//增强for循环
for(Object jihe:list2){
System.out.println("增强for循环---"+jihe);
}
}
}遍历输出结果：
iterator迭代器----zhangjing
iterator迭代器----666
iterator迭代器----true
iterator迭代器----zhangsan
iterator迭代器----zhangjing
iterator迭代器----56.98
for循环---zhangjing
for循环---666
for循环---true
for循环---zhangsan
for循环---zhangjing
for循环---56.98
增强for循环---zhangjing
增强for循环---666
增强for循环---true
增强for循环---zhangsan
增强for循环---zhangjing
增强for循环---56.983.LinkedList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.双向链表结构，查询速度慢，添加删除速度快
构造方法：
| LinkedList() | 构造一个空列表 |
| LinkedList (Collection c) | 通过实现Collection 接口的子类/子接口对象创建一个列表 |
第2行意思是可以转换，比如把ArrayList转换为LinkedList
实例方法：
| Boolean add(Object o) | 将指定的元素追加到此列表的末尾 |
| Boolean contains(Object o) | 如果此列表包含指定的元素，则返回 true |
| Object get(int index) | 返回此列表中指定位置的元素 |
| int indexOf(Object o) | 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。 |
| int lastIndexOf(Object o) | 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 |
| Object remove(int index) | 删除该列表中指定位置的元素 |
| boolean remove(Object o) | 从列表中删除指定元素的第一个出现（如果存在） |
| Object set(int index,Object element) | 用指定的元素替换此列表中指定 |
| int size() | 返回此列表中的元素数 |
| boolean isEmpty() | 如果此列表不包含元素，则返回 true |
| void clear() | 从列表中删除所有元素 |
| Iterator<E> iterator() | 以正确的顺序返回该列表中的元素的迭代器 |
多出一组对第一个元素和最后一个元素的操作方法。因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。
| void addFirst(Object e) | 在该列表开头插入指定的元素 |
| void addLast(Object e) | 将指定的元素追加到此列表的末尾 |
| Object getFirst() | 返回此列表中的第一个元素 |
| Object getLast() | 返回此列表中的最后一个元素 |
| Object removeFirst() | 从此列表中删除并返回第一个元素 |
| Object removeLast() | 从此列表中删除并返回最后一个元素 |
代码演示：
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class LinkedListTest {
public static void main(String[] args) {
// LinkedList() 构造一个空列表
LinkedList list1 = new LinkedList();
List list2=new LinkedList();//或者接口回调，因为上一级是List
// LinkedList (Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
// 假设把ArrayList转换为LinkedList
/*
* ArrayList list=new ArrayList(); LinkedList list2=new
* LinkedList(list);
*/
//Boolean add(Object o) 将指定的元素追加到此列表的末尾
list1.add("zhangjing");
list1.add(666);
list1.add(true);
list1.add("zhangsan");
list1.add("zhangjing");
list1.add(56.98);
// int size() 返回此列表中的元素数
System.out.println(list1.size());
// Boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
System.out.println(list1.contains(56.98));
// Object get(int index) 返回此列表中指定位置的元素
System.out.println(list1.get(4));
// int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(list1.indexOf(666));
System.out.println(list1.indexOf("weiwei"));// -1
// int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(list1.lastIndexOf("zhangjing"));
// Object remove(int index) 删除该列表中指定位置的元素
System.out.println(list1.remove(2));
System.out.println(list1.size());
// boolean remove(Object o)从列表中删除指定元素的第一个出现（如果存在）
System.out.println(list1.remove("zhangjing"));
// Object set(int index,Object element) 用指定的元素替换此列表中指定
System.out.println(list1.size());
// boolean isEmpty() 如果此列表不包含元素，则返回 true
System.out.println(list1.isEmpty());// false
// void clear() 从列表中删除所有元素
list1.clear();
System.out.println(list1.size());
list2.add("zhangjing");
list2.add(666);
list2.add(true);
list2.add("zhangsan");
list2.add("zhangjing");
list2.add(56.98);
// 遍历集合for循环，增强for循环，迭代器
// Iterator<E> iterator() 以正确的顺序返回该列表中的元素的c
Iterator diedai = list2.iterator();
while (diedai.hasNext()) {
Object obj = diedai.next();
System.out.println("iterator迭代器----" + obj);
}
// for循环，因为是有序的，所以可以用
for (int i = 0; i < list2.size(); i++) {
System.out.println("for循环---"+list2.get(i));
}
//增强for循环
for(Object jihe:list2){
System.out.println("增强for循环---"+jihe);
}
/*
* 多出一组对第一个元素和最后一个元素的操作方法
* void addFirst(Object e) 在该列表开头插入指定的元素。
* void addLast(Object e) 将指定的元素追加到此列表的末尾。
* Object getFirst() 返回此列表中的第一个元素。
* Object getLast() 返回此列表中的最后一个元素。
* Object removeFirst()从此列表中删除并返回第一个元素。
* Object removeLast() 从此列表中删除并返回最后一个元素
*/
//list2.addFirst();//报错，list2是父类的，而这个方法是它独有的，因此必须用LinkedList的构造
LinkedList list3 = new LinkedList();
list3.add("zhangjing");
list3.add(666);
list3.add(true);
list3.add("zhangsan");
list3.add("zhangjing");
list3.add(56.98);
list3.addFirst(1717);
list3.addLast("一起呀");
System.out.println(list3.getFirst());//1717
System.out.println(list3.getLast());//一起呀
list3.removeFirst();
list3.removeLast();
System.out.println(list3.size());//6
}
}4. HashSet类
用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
构造方法：
| HashSet（） | 构造一个新的空集合；默认初始容量（16）和负载因子（0.75） |
| HashSet (Collection c) | 构造一个包含指定集合中的元素的新集合 |
| HashSet（int initialCapacity） | 构造一个新的空集合；具有指定的初始容量和默认负载因子 |
| HashSet（int initialCapacity，float loadFactor） | 构造一个具有指定的初始容量和指定的负载因子 |
实例方法：因为无序，因此没有有序的操作方法
| boolean add(Object o) | 将指定的元素追加到此集合中（如果尚未存在） |
| void clear() | 从列表中删除所有元素 |
| boolean isEmpty() | 如果此列表不包含元素，则返回 true |
| Boolean contains(Object o) | 如果此集合包含指定的元素，则返回 true |
| Iterator<E> iterator() | 返回该列表中的元素的迭代器 |
| int size() | 返回此列表中的元素数（重复的算一个） |
| boolean remove(Object o) | 如果存在，则从该集合中删除指定的元素 |
例：
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest {
public static void main(String[] args) {
// 构造一个默认初始容量16的空集合
HashSet hashset = new HashSet();
hashset.add("吴");
hashset.add(66);
hashset.add(true);
hashset.add(98.9);
hashset.add(66);
hashset.add("吴");
hashset.add('K');
// int size()返回此列表中的元素数（重复的算一个）
System.out.println(hashset.size());// 5
// boolean isEmpty()如果此列表不包含元素，则返回 true
System.out.println(hashset.isEmpty());// false
// Boolean contains(Object o)如果此集合包含指定的元素，则返回 true
System.out.println(hashset.contains("吴"));// true
System.out.println(hashset.contains("张"));// false
/*
* void clear()从列表中删除所有元素 hashset.clear();
* System.out.println("删除后size==="+hashset.size());//0
*/
//boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
System.out.println(hashset.remove("吴"));
System.out.println(hashset.size());//4
//Iterator<E> iterator() 返回该列表中的元素的迭代器
Iterator iterator=hashset.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
System.out.println("iterator迭代器----"+obj);
}
//for循环不能使用，因为无序
//增强for循环
for(Object obj: hashset){
System.out.println("增强for循环=="+obj);
}
System.out.println(hashset);
}
}5.LinkedHashSet类
哈希表和链表实现了Set接口，具有可预测的迭代次序。这种实现不同于HashSet，它维持于所有条目的运行双向链表。因为LinkedHashSet类是HashSet类的子类，因此会从父类继承集合数据的操作方法，所以只要我们会HashSet类使用，那么LinkedHashSet类不用学也会用
构造方法：
| LikedHashSet（） | 构造一个新的空集合；默认初始容量（16）和负载因子（0.75） |
| LikedHashSet (Collection c) | 构造一个包含指定集合中的元素的新集合 |
| LikedHashSet（int initialCapacity） | 构造一个新的空集合；具有指定的初始容量和默认负载因子 |
| LikedHashSet（int initialCapacity，float loadFactor） | 构造一个具有指定的初始容量和指定的负载因子 |
实例方法：因为无序，因此没有有序的操作方法
| boolean add(Object o) | 将指定的元素追加到此集合中（如果尚未存在） |
| void clear() | 从列表中删除所有元素 |
| boolean isEmpty() | 如果此列表不包含元素，则返回 true |
| Boolean contains(Object o) | 如果此集合包含指定的元素，则返回 true |
| Iterator<E> iterator() | 返回该列表中的元素的迭代器 |
| int size() | 返回此列表中的元素数（重复的算一个） |
| boolean remove(Object o) | 如果存在，则从该集合中删除指定的元素 |
例：
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetTest {
public static void main(String[] args) {
// 构造一个默认初始容量16的空集合
LinkedHashSet linkedhashset = new LinkedHashSet();
linkedhashset.add("吴");
linkedhashset.add(66);
linkedhashset.add(true);
linkedhashset.add(98.9);
linkedhashset.add(66);
linkedhashset.add("吴");
linkedhashset.add('K');
// int size()返回此列表中的元素数（重复的算一个）
System.out.println(linkedhashset.size());// 5
// boolean isEmpty()如果此列表不包含元素，则返回 true
System.out.println(linkedhashset.isEmpty());// false
// Boolean contains(Object o)如果此集合包含指定的元素，则返回 true
System.out.println(linkedhashset.contains("吴"));// true
System.out.println(linkedhashset.contains("张"));// false
/*
* void clear()从列表中删除所有元素 linkedhashset.clear();
* System.out.println("删除后size==="+linkedhashset.size());//0
*/
//boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
System.out.println(linkedhashset.remove("吴"));
System.out.println(linkedhashset.size());//4
//Iterator<E> iterator() 返回该列表中的元素的迭代器
Iterator iterator=linkedhashset.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
System.out.println("iterator迭代器----"+obj);
}
//for循环不能使用，因为无序
//增强for循环
for(Object obj:linkedhashset){
System.out.println("增强for循环=="+obj);
}
System.out.println(linkedhashset);
}
}
6.HashMap类
（1）允许null值和null键
（2）数据的保存是无序的
（3）重复的键被算作是一个数据
（4）线程不安全
构造方法：
| HashMap（） | 构造一个新HashMap,默认初始容量（16）和负载因子（0.75） |
| HashMap (Map m) | 构造一个新的 HashMap与指定的相同的映射 Map |
| HashMap（int initialCapacity） | 构造一个新的空HashMap，具有指定的初始容量和默认负载因子 |
| HashMap（int initialCapacity，float loadFactor） | 构造一个HashMap具有指定的初始容量和指定的负载因子 |
实例方法：
| void clear() | 清空集合 |
| Object put(Object key,Object value) | 向集合中添加键值对数据 |
| boolean containsKey(Object key) | 判断集合中是否包含指定的键 |
| Boolean containsValue(Object value) | 判断集合中是否包含指定的值 |
| Object get(Object key) | 根据指定的键得到该键对应的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 得到集合中键值对元素的个数 |
| V remove(Object key) | 根据指定的键删除对应的键值对数据值 |
| Set keySet() | 得到集合中所有的键保存到Set集合中 |
| Collection values() | 得到集合中所有的值保存到Collection集合中 |
| Set<Map.Entry<K,V>> entrySet() | 得到集合中所有的键值对数据保存到Set集合中 |
例：
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapTest {
public static void main(String[] args) {
// HashMap（） 构造一个新HashMap,默认初始容量（16）和负载因子（0.75）
HashMap map1 = new HashMap();
Map map11 = new HashMap();
// HashMap（int initialCapacity） 构造一个新的空HashMap，具有指定的初始容量和默认负载因子
HashMap map2 = new HashMap(30);
Map map22 = new HashMap(30);
// HashMap（int initialCapacity，float loadFactor）
// 构造一个HashMap具有指定的初始容量和指定的负载因子
HashMap map3 = new HashMap(30, 0.8f);
Map map33 = new HashMap(30, 0.8f);
// HashMap (Map m) 构造一个新的 HashMap与指定的相同的映射 Map
HashMap map4 = new HashMap(map1);
Map map44 = new HashMap(map1);
/*
* void clear() 清空集合 Object put(Object key,Object value) 向集合中添加键值对数据
* boolean containsKey(Object key) 判断集合中是否包含指定的键 Boolean
* containsValue(Object value) 判断集合中是否包含指定的值 Object get(Object
* key)根据指定的键得到该键对应的值 boolean isEmpty() 判断集合是否为空 int size()
* 得到集合中键值对元素的个数 V remove(Object key) 根据指定的键删除对应的键值对数据值 Set keySet()
* 得到集合中所有的键保存到Set集合中 Collection values() 得到集合中所有的值保存到 Collection集合中
* Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据保存到Set集合中
*/
// Object put(Object key,Object value) 向集合中添加键值对数据
map1.put("name", "zhangsan");
map1.put(true, 9.9);
map1.put('B', 88);
map1.put(null, false);
map1.put(true, null);// 重复的键算作一个数据
// 上面说明HashMap键值对，键和值可以任意类型
System.out.println(map1);// {null=false, B=88, name=zhangsan, true=null}
System.out.println(map1.size());// 4
// boolean containsKey(Object key) 判断集合中是否包含指定的键
// Boolean containsValue(Object value) 判断集合中是否包含指定的值
System.out.println("key--hello存在---" + map1.containsKey("hello"));
System.out.println("key--true存在---" + map1.containsKey(true));
System.out.println("value--true存在---" + map1.containsValue(true));
System.out.println("value--88存在---" + map1.containsValue(88));
// Object get(Object key)根据指定的键得到该键对应的值
System.out.println("name===" + map1.get("name"));// 只能根据键得到值
// remove(Object key) 根据指定的键删除对应的键值对数据值
map1.remove(true);
System.out.println(map1);// {null=false, B=88, true=null}
// Set keySet() 得到集合中所有的键保存到Set集合中
Set setkey=map1.keySet();
System.out.println(setkey);//[null, B, name]
//遍历一下键的集合
for(Object obj:setkey){
System.out.println("增强for循环遍历键==="+obj);
}
//也可以迭代器，Set接口有迭代器
Iterator iterator1 = setkey.iterator();
while(iterator1.hasNext()){
Object obj1 = iterator1.next();
System.out.println("迭代器键==="+obj1);
}
// Collection values() 得到集合中所有的值保存到
Collection values = map1.values();
//遍历一下值的集合
for(Object obj1:values){
System.out.println("增强for循环遍历值==="+obj1);
}
Iterator iterator2 = values.iterator();
while(iterator2.hasNext()){
Object obj2 = iterator2.next();
System.out.println("迭代器值==="+obj2);
}
// Collection集合中 Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据保存到Set集合中
//此方法遍历键值对
Set<Map.Entry<Object,Object>> set1 = map1.entrySet();
for(Map.Entry<Object,Object> entry:set1){
System.out.println("键值对"+entry.getKey()+":"+entry.getValue());
}
Set set2 = map1.entrySet();
for(Object entry:set2){
System.out.println("键值对"+entry);
}
}
}
7.Hashtable类
（1）不允许null值和null键
（2）数据的保存是无序的
（3）重复的键被算作是一个数据
（4）用作键的对象必须实现hashCode方法和equals方法
（5）线程安全
构造方法：
| Hashtable（） | 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75） |
| Hashtable (Map m) | 构造一个与给定地图相同的映射的新哈希表 |
| Hashtable（int initialCapacity） | 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75 |
| Hashtable（int initialCapacity，float loadFactor） | 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。 |
实例方法：
| void clear() | 清空集合 |
| Object put(Object key,Object value) | 向集合中添加键值对数据 |
| boolean containsKey(Object key) | 判断集合中是否包含指定的键 |
| Boolean containsValue(Object value) | 判断集合中是否包含指定的值 |
| Object get(Object key) | 根据指定的键得到该键对应的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 得到集合中键值对元素的个数 |
| V remove(Object key) | 根据指定的键删除对应的键值对数据值 |
| Set keySet() | 得到集合中所有的键保存到Set集合中 |
| Collection values() | 得到集合中所有的值保存到Collection集合中 |
| Set<Map.Entry<K,V>> entrySet() | 得到集合中所有的键值对数据保存到Set集合中 |
| Enumeration<K> keys() | 返回此散列表中键的枚举 |
| Enumeration<V> elements() | 返回此散列表中值的枚举 |
例：
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashtableTest {
public static void main(String[] args) {
Hashtable table1 = new Hashtable();
/*
* void clear() 清空集合 Object put(Object key,Object value) 向集合中添加键值对数据
* boolean containsKey(Object key) 判断集合中是否包含指定的键 Boolean
* containsValue(Object value) 判断集合中是否包含指定的值 Object
* get(Objectkey)根据指定的键得到该键对应的值 boolean isEmpty() 判断集合是否为空 int size()
* 得到集合中键值对元素的个数 V remove(Object key) 根据指定的键删除对应的键值对数据值 Set keySet()
* 得到集合中所有的键保存到Set集合中 Collection values() 得到集合中所有的值保存到 Collection集合中
* Se<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据保存到Set集合中
*/
table1.put("name", "zhangsan");
table1.put(true, 9.9);
table1.put('B', 88);
// table1.put(null, false);不能有null
// table1.put(true, null);不能有null
table1.put('B', 66);
System.out.println(table1.size());// 3
System.out.println(table1);// {true=9.9, name=zhangsan, B=66}
// 遍历
// Set keySet() 得到集合中所有的键保存到Set集合中
Set setkey = table1.keySet();
System.out.println(setkey);//
// 遍历一下键的集合
for (Object obj : setkey) {
System.out.println("增强for循环遍历键===" + obj);
}
// 也可以迭代器，Set接口有迭代器
Iterator iterator1 = setkey.iterator();
while (iterator1.hasNext()) {
Object obj1 = iterator1.next();
System.out.println("迭代器键===" + obj1);
}
// Collection values() 得到集合中所有的值保存到
Collection values = table1.values();
// 遍历一下值的集合
for (Object obj1 : values) {
System.out.println("增强for循环遍历值===" + obj1);
}
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object obj2 = iterator2.next();
System.out.println("迭代器值===" + obj2);
}
// Collection集合中 Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据保存到Set集合中
// 此方法遍历键值对
Set<Map.Entry<Object, Object>> set1 = table1.entrySet();
for (Map.Entry<Object, Object> entry : set1) {
System.out.println("键值对" + entry.getKey() + ":" + entry.getValue());
}
Set set2 = table1.entrySet();
for (Object entry : set2) {
System.out.println("键值对" + entry);
}
}
}8.TreeMap类
1.输出是按照键的字母顺序排列
2.键不能为null
3.重复的键被算作是一个数据。
4.非线程安全
构造方法：
TreeMap() 使用其键的自然排序构造一个新的空树状图。
TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图，其中包含与给定地图相同的映射，根 据其键的自然顺序进行排序 。
实例方法:
void clear() 清空集合。
Object put(Object key, Object value) 向集合中添加键值对数据
boolean containsKey(Object key) 判断集合中是否包含指定的键
boolean containsValue(Object value) 判断集合中是否包含指定的值
Object get(Object key) 根据指定的键得到该键对应的值
boolean isEmpty() 判断集合是否为空。
int size() 得到集合中键值对元素的个数
V remove(Object key) 根基指定的键删除对应的键值对数据值
Set keySet() 得到集合中所有的键保存到Set集合中
Collection values() 得到集合中所有的值保存到Collection集合中
Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中 HashMap的方法TreeMap都可以
9.区别
9.1 ArrayList类与数组的区别
| ArrayList类 | 数组 |
| 元素类型没有限制 | 都是同一种类型 |
| 存储空间会自动扩展 | 数组的存储空间设置后是固定的 |
9.2 ArrayList类与LinkedList类的区别
| ArrayList类 | LinkedList类 |
| 动态数组结构 | 双向链表结构 |
| 添加删除速度慢，查询速度快 | 添加删除速度快，查询速度慢 |
| 没有提供对第一个元素和最后一个元素的操作 | 提供对第一个元素和最后一个元素的操作 |
| 适合大量查询操作 | 适合大量添加删除操作 |
| 有初始容量为10 | 没有初始容量 |
| 每次扩容后的大小为之前的1.5倍 | 没有扩容机制 |
9.3 HashSet和LinkedHashSet区别
HashSet在遍历输出的时候无序（不是按插入的顺序输出的），而LinkedHashSet在遍历输出的时候按照插入顺序输出。
9.4 List接口与Set接口区别
| List接口 | Set接口 |
| 有序 | 无序 |
| 可以有重复数据 | 重复的数据算一个 |
9.5 Collection接口与Map接口区别
| Collection接口 | Map接口 |
| 处理单列数据的顶级接口 | 处理键值对数据的顶级接口 |
| 可以使用迭代器接口iterator遍历 | 没有迭代器iterator接口 |
9.6 HashMap类和Hashtable类区别
| HashMap类 | Hashtable类 |
| 可以有null键和null值 | 不可以有null |
| 默认初始容量16 | 默认初始容量11 |
| 线程不安全 | 线程安全 |
9.7 HashMap类和Hashtable类、TreeMap类、ConcurrentHashMap类区别
| HashMap类 | Hashtable类 | TreeMap类 | ConcurrentHashMap类 |
| 无序 | 无序 | 输出是按字母顺序 | |
| 线程不安全 | 线程安全 | 线程不安全 | 线程安全 |
| 访问速度快 | 访问速度慢 | 访问速度快 | 访问速度慢 并发，分布式 |
5631
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
