集合
1.集合框架
集合可以看作是一种容器，用来存储对象信息。所有集合类都位于java.util包下，但支持多线程的集合类位于java.util.concurrent包下。
Java集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列），因此Java集合大致也可分成List、Set、Queue、Map四种接口体系，（注意：Map不是Collection的子接口）。
其中List代表了有序可重复集合，可直接根据元素的索引来访问；Set代表无序不可重复集合，只能根据元素本身来访问；Queue是队列集合；Map代表的是存储key-value对的集合，可根据元素的key来访问value。
集合框架—java做好的用来管理乱七八糟的一堆数据的java类库
框架—做好的java类库
java中的集合框架总体被分为2个大部分
第一个大部分是用来处理单列数据的集合,最大的接口是Collection接口
Collection接口之下有两个子接口:List接口/Set接口
List集合代表一个有序、可重复集合，集合中每个元素都有其对应的顺序索引。List集合默认按照元素的添加顺序设置元素的索引，可以通过索引（类似数组的下标）来访问指定位置的集合元素。
List接口是用来处理有序的单列数据，可以有重复的元素。
ArrayList类
ArrayList是一个动态数组，也是我们最常用的集合，是List类的典型实现。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.动态数组结构，查询速度快，添加删除速度慢
LinkedList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.双向链表结构，查询速度慢，添加删除速度快
Set接口是用来处理无序的单列数据，没有重复的元素,重复的元素算一个。
Set集合与Collection的方法相同，由于Set集合不允许存储相同的元素，所以如果把两个相同元素添加到同一个Set集合，则添加操作失败，新元素不会被加入，add()方法返回false。
HashSet类
HashSet是Set集合最常用实现类，是其经典实现。HashSet是按照hash算法来存储元素的，因此具有很好的存取和查找性能。
用来处理无序的单列数据，没有重复的元素,重复的元素算一个。
LinkedHashSet类
LinkedHashSet是HashSet的一个子类，具有HashSet的特性，也是根据元素的hashCode值来决定元素的存储位置。但它使用链表维护元素的次序，元素的顺序与添加顺序一致。由于LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时由很好的性能。
用来处理无序的单列数据，没有重复的元素,重复的元素算一个。
Map集合
Map接口采用键值对Map<K,V>的存储方式，保存具有映射关系的数据，因此，Map集合里保存两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value可以是任意引用类型的数据。key值不允许重复，可以为null。如果添加key-value对时Map中已经有重复的key，则新添加的value会覆盖该key原来对应的value。常用实现类有HashMap、LinkedHashMap、TreeMap等。
第二个大部分是用来处理键值对数据的集合,最大的接口是Map接口
例如: name[键]=zhangsan[值] 输的目录
HashMap类
1.用来处理键值对数据的集合
2.允许有null【键–null 值–null】
Hashtable类
1.用来处理键值对数据的集合
2.不允许有null
ConcurrentHashMap类
支持检索的完全并发性和更新的高预期并发性的哈希表
TreeMap
TreeMap是SortedMap的实现类，是一个红黑树的数据结构，每个key-value对作为红黑树的一个节点。TreeMap存储key-value对时，需要根据key对节点进行排序。
2.关于List接口下的常用类
1.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 iterator() 以正确的顺序返回该列表中的元素的迭代器。
例如:
package com.wangxing.zyb;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTest {
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表
ArrayList list1=new ArrayList();
List list11=new ArrayList();
//ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
ArrayList list2=new ArrayList(list1);
List list22=new ArrayList();
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表
ArrayList list3=new ArrayList(30);
List list33=new ArrayList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾
list1.add("zhangsan");
list1.add(23);
list1.add(168.5);
list1.add(true);
list1.add("zhangsan");
//int size() 返回此列表中的元素数
System.out.println("size=="+list1.size());
//boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
System.out.println("contains=="+list1.contains("list"));
//Object get(int index) 返回此列表中指定位置的元素
System.out.println("gei=="+list1.get(1));
//int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
System.out.println("indexOf=="+list1.indexOf("zhangsanfen"));
//int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此 列表不包含元素，则返回-1
System.out.println("lastLndexOf=="+list1.lastIndexOf("zhangsan"));
//Object remove(int index) 删除该列表中指定位置的元素。
//System.out.println("remove=="+list1.remove(4));
//boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）
//System.out.println("remove=="+list1.remove("zhangsan"));
//System.out.println("size=="+list1.size());
//Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素
//list1.set(4, "lisi");
//System.out.println("get=="+list1.get(4));
//System.out.println("isEmpty=="+list1.isEmpty());
//list1.clear();
//System.out.println("isEmpty=="+list1.isEmpty());
//循环遍历
//1.普通for
for(int i=0;i<list1.size();i++) {
System.out.println("普通for=="+list1.get(i));
}
//2.增强的for
for(Object obj:list1) {
System.out.println("增强的for=="+obj);
}
//3.Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=list1.iterator();
while(it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
2.LinkedList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.双向链表结构，查询速度慢，添加删除速度快
构造方法:
LinkedList() 构造一个空列表。
LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
实例方法:
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 iterator() 以正确的顺序返回该列表中的元素的迭代器。
多出一组对第一个元素和最后一个元素的操作方法
void addFirst(Object e) 在该列表开头插入指定的元素。
void addLast(Object e) 将指定的元素追加到此列表的末尾。
Object getFirst() 返回此列表中的第一个元素。
Object getLast() 返回此列表中的最后一个元素。
Object removeFirst() 从此列表中删除并返回第一个元素。
Object removeLast() 从此列表中删除并返回最后一个元素。
为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？
因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而 LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的 。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第 一时间看清第一节与最后一节车厢位置。
package com.wangxing.zyb;
import java.util.ArrayList;
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 list11=new LinkedList();
// LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
ArrayList list2=new ArrayList(list1);
List list22=new LinkedList();
// boolean add(Object o) 将指定的元素追加到此列表的末尾
list1.add("zhangsan");
list1.add(23);
list1.add(168.5);
list1.add(true);
list1.add("zhangsan");
// int size() 返回此列表中的元素数。
System.out.println("size=="+list1.size());
// boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
System.out.println("contains=="+list1.contains("lisi"));
// Object get(int index) 返回此列表中指定位置的元素
System.out.println("get=="+list1.get(1));
// int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
System.out.println("indexOf=="+list1.indexOf("zhangsanfeng"));
// int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此 列表不包含元素，则返回-1
//System.out.println("lastIndexOf=="+list1.lastIndexOf("zhangsan"));
// Object remove(int index) 删除该列表中指定位置的元素。
//System.out.println("remove=="+list1.remove(4));
//System.out.println("size=="+list1.size());
// boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）
list1.set(4, "lisi");
System.out.println("get=="+list1.get(4));
// boolean isEmpty() 如果此列表不包含元素，则返回 true
//System.out.println("isEmpty=="+list1.isEmpty());
// void clear() 从列表中删除所有元素。
//list1.clear();
//System.out.println("isEmpty=="+list1.isEmpty());
//void addFirst(Object e) 在该列表开头插入指定的元素。 list1.addFirst("hello");
list1.addFirst("hello");
//void addLast(Object e) 将指定的元素追加到此列表的末尾。 list1.addLast("world");
list1.addLast("world");
//Object getFirst() 返回此列表中的第一个元素。
list1.getFirst();
System.out.println("list1=="+list1.getFirst());//Object getLast()
//返回此列表中的最后一个元素。
System.out.println(list1.getLast()); //Object
//removeFirst() 从此列表中删除并返回第一个元素。
list1.removeFirst();
System.out.println(list1.getFirst());
//从此列表中删除并返回最后一个元素。
// 遍历集合
// 1.普通for
for(int i=0;i<list1.size();i++) {
System.out.println("普通for=="+list1.get(i));
}
for(Object obj:list1) {
System.out.println("增强的for=="+obj);
}
Iterator it=list1.iterator();
while(it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
3.关于Set接口的常用类
1.HashSet类
用来处理无序的单列数据，没有重复的元素,重复的元素算一个。
构造方法:
HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。
HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。
实例方法
boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）。
void clear() 从此集合中删除所有元素。
boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean isEmpty() 如果此集合不包含元素，则返回 true 。
Iterator iterator() 返回此集合中元素的迭代器。
boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
int size() 返回此集合中的元素数（其基数）。
例如:
package com.wangxing.zyb2;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetTest {
public static void main(String[] args) {
// HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）
HashSet set1=new HashSet();
Set set11=new HashSet();
// HashSet(Collection c) 构造一个包含指定集合中的元素的新集合
HashSet set2=new HashSet(new ArrayList());
Set set22=new HashSet(new ArrayList());
// HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）
HashSet set3=new HashSet(20);
Set set33=new HashSet(20);
// HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子
HashSet set4=new HashSet(20,0.5f);
Set set44=new HashSet(20,0.5f);
// 实例方法
// boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）
set1.add("zhangsan");
set1.add(23);
set1.add(168.5);
set1.add(true);
set1.add("zhangsan");
// int size() 返回此集合中的元素数（其基数）。
System.out.println("size=" + set1.size());
// boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
set1.remove("zhangsan");
System.out.println("size=" + set1.size());
// boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
System.out.println("contains==" + set1.contains("lisi"));
// void clear() 从此集合中删除所有元素
//set1.clear();
// boolean isEmpty() 如果此集合不包含元素，则返回 true
System.out.println("isEmpty==" + set1.isEmpty());
// Iterator iterator() 返回此集合中元素的迭代器。
//1.增强的for
for(Object obj:set1) {
System.out.println("增强的for=="+obj);
}
//2.Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=set1.iterator();
while(it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
2.LikedHashSet类
LikedHashSet类是HashSet类的子类
构造方法:
LikedHashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。
LikedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
LikedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。
LikedHashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。
实例方法
boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）。
void clear() 从此集合中删除所有元素。
boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean isEmpty() 如果此集合不包含元素，则返回 true 。
Iterator iterator() 返回此集合中元素的迭代器。
boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
int size() 返回此集合中的元素数（其基数）。
例如:
package com.wangxing.zyb2;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetTest {
public static void main(String[] args) {
// HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）
LinkedHashSet set1=new LinkedHashSet();
Set set11=new LinkedHashSet();
// HashSet(Collection c) 构造一个包含指定集合中的元素的新集合
LinkedHashSet set2=new LinkedHashSet(new ArrayList());
Set set22=new LinkedHashSet(new ArrayList());
// HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）
LinkedHashSet set3=new LinkedHashSet(20);
Set set33=new LinkedHashSet(20);
// HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子
LinkedHashSet set4=new LinkedHashSet(20,0.5f);
Set set44=new LinkedHashSet(20,0.5f);
// 实例方法
// boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）
set1.add("zhangsan");
set1.add(23);
set1.add(168.5);
set1.add(true);
set1.add("zhangsan");
// int size() 返回此集合中的元素数（其基数）。
System.out.println("size=" + set1.size());
// boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
set1.remove("zhangsan");
System.out.println("size=" + set1.size());
// boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
System.out.println("contains==" + set1.contains("lisi"));
// void clear() 从此集合中删除所有元素
//set1.clear();
// boolean isEmpty() 如果此集合不包含元素，则返回 true
System.out.println("isEmpty==" + set1.isEmpty());
// Iterator iterator() 返回此集合中元素的迭代器。
//1.增强的for
for(Object obj:set1) {
System.out.println("增强的for=="+obj);
}
//2.Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=set1.iterator();
while(it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
4.关于Map接口的常用类
Map接口用来处理键值对数据的集合
1.HashMap类
1.允许null的值和null键
2.数据保存是无序的
3.重复的键被算作是一个数据。
构造方法:
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负 载因子。
HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射 Map 。
实例方法:
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集合中
例如:
package com.wangxing.zyb2;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetTest {
public static void main(String[] args) {
// HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）
LinkedHashSet set1=new LinkedHashSet();
Set set11=new LinkedHashSet();
// HashSet(Collection c) 构造一个包含指定集合中的元素的新集合
LinkedHashSet set2=new LinkedHashSet(new ArrayList());
Set set22=new LinkedHashSet(new ArrayList());
// HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）
LinkedHashSet set3=new LinkedHashSet(20);
Set set33=new LinkedHashSet(20);
// HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子
LinkedHashSet set4=new LinkedHashSet(20,0.5f);
Set set44=new LinkedHashSet(20,0.5f);
// 实例方法
// boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）
set1.add("zhangsan");
set1.add(23);
set1.add(168.5);
set1.add(true);
set1.add("zhangsan");
// int size() 返回此集合中的元素数（其基数）。
System.out.println("size=" + set1.size());
// boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
set1.remove("zhangsan");
System.out.println("size=" + set1.size());
// boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
System.out.println("contains==" + set1.contains("lisi"));
// void clear() 从此集合中删除所有元素
//set1.clear();
// boolean isEmpty() 如果此集合不包含元素，则返回 true
System.out.println("isEmpty==" + set1.isEmpty());
// Iterator iterator() 返回此集合中元素的迭代器。
//1.增强的for
for(Object obj:set1) {
System.out.println("增强的for=="+obj);
}
//2.Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=set1.iterator();
while(it.hasNext()) {
Object obj=it.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
2.Hashtable类
1.数据保存是无序的
2.不能有null键/null值
3.用作键的对象必须实现hashCode方法和equals方法。
4.重复的键被算作是一个数据。
5.线程安全
构造方法:
Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。
Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子（0.75 ）。
Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始 容量和指定的负载因子。
Hashtable(Map t) 构造一个与给定地图相同的映射的新哈希表。
实例方法:
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 keys() 返回此散列表中键的枚举。
Enumeration elements() 返回此散列表中值的枚举。
例如:
package com.wangxing.zyb3;
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() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）
Hashtable table1=new Hashtable();
//Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75
//Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子
//Hashtable(Map t) 构造一个与给定地图相同的映射的新哈希表
table1.put("name","zhangsan");
table1.put(1001,"id");
table1.put(1001,"stuid");
table1.put(true,168.5);
//table1.put(null,false);
//table1.put("test",null);
Student stu1=new Student();
table1.put(stu1,"student对象");
//int size() 得到集合中键值对元素的个数
System.out.println("size=="+table1.size());
//Set keySet() 得到集合中所有的键保存到Set集合中
//boolean containsKey(Object key) 判断集合中是否包含指定的键
System.out.println("containsKey=="+table1.containsKey("name"));
//boolean containsValue(Object value) 判断集合中是否包含指定的值
System.out.println("containsValue=="+table1.containsValue("hello"));
//Object get(Object key) 根据指定的键得到该键对应的值
System.out.println("get=="+table1.get(true));
//V remove(Object key) 根基指定的键删除对应的键值对数据值
table1.remove("name");
System.out.println("size=="+table1.size());
//清空集合
table1.clear();
System.out.println("clear=="+table1.size());
//boolean isEmpty() 判断集合是否为空
System.out.println("isEmpty=="+table1.isEmpty());
//Set keySet() 得到集合中所有的键保存到Set集合中
Set setkey=table1.keySet();
for(Object obj:setkey){
System.out.println("key--"+obj);
}
Iterator itkey=setkey.iterator();
while(itkey.hasNext()){
Object obj=itkey.next();
System.out.println("Iterator=key--"+obj);
}
//Collection values() 得到集合中所有的值保存到Collection集合中
Collection coll=table1.values();
for(Object obj:coll){
System.out.println("value=="+obj);
}
Iterator itvalue=coll.iterator();
while(itvalue.hasNext()){
Object obj=itvalue.next();
System.out.println("Iterator=value--"+obj);
}
//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("keyvalue--"+entry.getKey()+":"+entry.getValue());
}
}
}
package com.wangxing.zyb3;
public class Student {
@Override
public int hashCode() {
// TODO Auto-generated method stub
return super.hashCode();
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
}
3.TreeMap类–红黑树基于NavigableMap实现【有序】
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集合中
例如:
package com.wangxing.zyb3;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest {
public static void main(String[] args) {
// TreeMap() 使用其键的自然排序构造一个新的空树状图。
TreeMap tree1 = new TreeMap();
// TreeMap(Map<? extends K,? extends V> m)
// 构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序 。
tree1.put("name", "zhangsan");
tree1.put("id", 1001);
tree1.put("age", 23);
// tree1.put(null,false);
tree1.put("test", null);
tree1.put("test", "西安");
System.out.println(tree1.size());
// boolean containsKey(Object key) 判断集合中是否包含指定的键
System.out.println("containsKey---" + tree1.containsKey("name"));
// boolean containsValue(Object value) 判断集合中是否包含指定的值
System.out.println("containsValue---" + tree1.containsValue("hello"));
// Object get(Object key) 根据指定的键得到该键对应的值
System.out.println("get---" + tree1.get("test"));
// V remove(Object key) 根基指定的键删除对应的键值对数据值
tree1.remove("test");
System.out.println("size==" + tree1.size());
// void clear() 清空集合。
// boolean isEmpty() 判断集合是否为空。
// Set keySet() 得到集合中所有的键保存到Set集合中
Set setkey = tree1.keySet();
for (Object obj : setkey) {
System.out.println("key--" + obj);
}
Iterator itkey = setkey.iterator();
while (itkey.hasNext()) {
Object obj = itkey.next();
System.out.println("Iterator=key--" + obj);
}
// Collection values() 得到集合中所有的值保存到Collection集合中
Collection coll = tree1.values();
for (Object obj : coll) {
System.out.println("value==" + obj);
}
Iterator itvalue = coll.iterator();
while (itvalue.hasNext()) {
Object obj = itvalue.next();
System.out.println("Iterator=value--" + obj);
}
// Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
Set<Map.Entry<Object, Object>> set1 = tree1.entrySet();
for (Map.Entry<Object, Object> entry : set1) {
System.out.println("keyvalue--" + entry.getKey() + ":" + entry.getValue());
}
}
}
4.ConcurrentHashMap类与HashMap相似
ConcurrentHashMap类线程安全支出检索是的高并发处理。
如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable。
Hashmap本质是数组加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。
ConcurrentHashMap：在hashMap的基础上，ConcurrentHashMap将数据分为多个segment(段)，默认16个（concurrency level），然后每次操作对一个segment(段)加锁，避免多线程锁的几率，提高并发效率。
HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。