2021-11-11

最新推荐文章于 2024-11-11 21:19:25 发布

m0_60165694

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量696

点赞数

文章标签： java 容器开发语言

本文链接：https://blog.csdn.net/m0_60165694/article/details/121275981

版权

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 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。