1.集合框架
集合框架---java做好的用来管理乱七八糟的一对数据的java类库
集合---【乱七八糟的一堆】
框架---做好的java类库
java中的集合框架总体被分为2个大部分
第一个大部分是用来处理单列数据的集合，最大的接口就是Collection接口
例如： 100 "hello"
Collection接口之下有两个子接口：List接口/Set接口
List接口是用来处理有序的单列数据，可以有重复的元素。
ArrayList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.动态数组结构，查询速度快，添加删除速度慢
linkedList类
1.用来处理处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.双向链表结构，查询速度慢，添加删除速度快
Set接口是用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
HashSet类
用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
linkedHashSet类
用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
第二个大部分是用来处理键值对的数据集合，最大的接口是Map接口
例如：name【键】=zhangsan【值】 书的目录
HashMap类
1.用来处理键值对数据的集合
2.匀速有null【键--null 值--null】
Hashtable类
1.用来处理键值对数据的集合
2.不允许有null
ConcurrentHashMap类
支持检索的完全并发性和更新的高预期并发性的哈希表
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 o)用指定的元素替换此列表中指定位置的元素
int size()返回此列表中的元素数。
boolean isEmpty()如果此列表中不包含元素，则返回true
void clear()从列表中删除所有元素。
Iterator
例如：
package com.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTtest {
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(list1);
//ArrayList(int initialCapacity)构造具有指定初始容量的空列表
ArrayList list3=new ArrayList(30);
List list33=new ArrayList();
//实例方法：
//boolean add(Object o)将指定的元素追加到此列表的末尾。
System.out.println(list1.add("zhangsan"));
list1.add(22);
list1.add(12.3);
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("zhangsan"));
//Object get(int index)返回此列表中指定位置的元素。
System.out.println("get=="+list1.get(0));
//int indexOf(Objct o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，侧返回-1
System.out.println("indexOf=="+list1.indexOf("23"));
//int lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含匀
System.out.println("lastindexOf=="+list1.lastIndexOf(22));
//Object remove(int index)删除该列表中指定位置的元素。
//System.out.println("remove(int index)=="+list1.remove(0));
//System.out.println("size=="+list1.size());
//boolean remove(Object o)从列表中删除指定元素的第一个出现（如果存在）
//System.out.println("remove(Object o)=="+list1.remove("zhangsan"));
//System.out.println("size=="+list1.size());
//Object set(int index,Object element)用指定的元素替换此列表中指定位置的元素
System.out.println(list1.set(0, "李四"));
System.out.println("get=="+list1.get(0));
//int size()返回此列表中的元素数。
System.out.println("size=="+list1.size());
//boolean isEmpty()如果此列表不包含元素，则返回true
System.out.println(list1.isEmpty());
//void clear()从列表中删除所有元素。
//list1.clear();
//System.out.println(list1.isEmpty());
//Iterator iterator()以正确的顺序返回该列表中的元素的迭代器。
//遍历集合
Iterator it=list1.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println("Iterator迭代器---"+obj);
}
//普通for
for(int i=0;i
2.linkedList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展
3.双向链表结构，查询速度慢，添加删除速度快
构造方法：
linkedList()构造一个空列表
linkedList(Collection c)通过实现一个Collection接口的子类/子接口对象创建一个列表
实例方法：
booelan add(Object o)将指定的元素追加到此列表的末尾
boolean get(int index)返回此列表中指定位置的元素。
int intdexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
int lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
Object remove(int index)删除该列表中指定位置的元素
Object remove(Object o)从列表中删除指定元素的第一个出现（如果存在）
Object set(int index,Object element)用指定的元素替换此列表中指定位置的元素
int size()返回此列表中的元素数
boolean isEmpty()如果此列表不包含元素，则返回true
coid clear()从列表中删除所有元素
Iterator iterator()以正确的顺序返回该裂变中的元素迭代器
多出一组对第一个元素和最后一个元素的操作方法
void addFirst(Object e)在该列表开头插入指定的元素。
void addLast(Object e)将指定的元素追加到此列表的末尾。
Object getFirst()返回此列表中的第一个元素
Object getLast()返回此列表中的最后一个元素
Object removeFirst()从此列表中删除并返回第一个元素。
Object removeLast()从此列表中删除并返回最后一个元素
为什么linkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？
因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时候很麻烦，而linkedList采用的双向链表结构，这种结构在查找第一个元素和最后一个元素的手是最快的。就像一列火车在我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。
3.关于Set接口的常用类
1.HashSet类
用来处理无序的单列数据，没有重复的元素，重复的元素算一个。
构造方法：
HashSet()构造一个新的空集合；默认初始容量(16)和负载因子（0.75）。
HashSet(Collection c)构造一个包含指定集合中元素的新集合
HashSet(int initialCapacity)构造一个新的空集合；具有指定的初始容量和默认负载因子(0.75)
HashSet(int initialCapacity,float loadFactor)具有指定的初始容量和指定的负载因子。
实例方法
booelan add(Object o)将指定的元素添加到此集合（如果尚未存在）
void clear()从此集合中删除所有元素
boolean contains(Object o)如果此集合包含指定的元素，则返回true
booelan isEmpty()如果此集合不包含元素，则返回true
Iterator iterator()返回此集合中的元素迭代器
boolean remove(Object o)如果存在，则从该集合中删除指定的元素
int size()返回此集合中的元素数（其基数）
例如：
package com.test2;
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(25);
set1.add(176.2);
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("zhangsan"));
//void clear()从此集合中删除所有元素。
//set1.clear();
//booelan isEmpty()如果此集合不包含元素，则返回true
System.out.println(set1.isEmpty());
//Iterator iterator()返回此集合中元素的迭代器
//增强的for
for(Object obj:set1){
System.out.println(obj);
}
Iterator it=set1.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println("Iterator迭代器---"+obj);
}
}
}
2.LikedHashSet类
LikedHashSet类是HashSet类的子类
构造方法：
linkedHashSet()苟傲一个新的空集合，默认初始容量(16)和负载因子（0.75）
linkedHashSet(Collection c)构造一个包含指定集合中的元素的新集合。
linkedHashSet(int initialCapacity)构造一个新的空集合，具有指定的初始容量和默认负载因子（0.75）
linkedHashSet(int initialCapacity,float loadFactor)具有指定的初始容量和指定的负载因子
实例方法
boolean add(Object e)将指定的元素添加到此集合(如果尚未存在)
void clear() 从此集合中删除所有元素
booelan contains(Object o)如果此集合包含指定的元素，则返回true
booelan isEmpty()如果此集合不包含元素，则返回true
Iterator iterator()返回此集合中的元素迭代器
booelan remove(Object o)如果存在，侧从该集合中删除指定的元素
int size() 返回此集合中的元素数（其基数）
例如：
package com.test2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.linkedHashSet;
public class linkedHashSetTest {
public static void main(String[] args) {
//构造方法
//linkedHashSet()构造一个新的空集合，默认初始容量(16)和负载因子
linkedHashSet set1=new linkedHashSet();
//linkedHashSet(Collection c)构造一个包含指定集合中的元素的新集合
linkedHashSet set2=new linkedHashSet(new ArrayList());
//linkednHashSet(int initialCapacity)构造一个新的空集合，具有指定的初始容量和默认负载因子(0.75)
linkedHashSet set3=new linkedHashSet(20);
//linkedHanshSet(int initialCapacity,float loadFactor)具有指定的初始容量和指定的负载因子。
linkedHashSet set4=new linkedHashSet(20,0.9f);
//实例方法
//boolean add(Object e)将指定的元素添加到此集合(如果尚未存在)
set1.add("zhangsan");
set1.add(23);
set1.add(16.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("zhangsan"));
//void clear()从此集合中删除所有元素
//set1.clear();
//boolean isEmpty()如果此集合不包含元素，则返回true
System.out.println(set1.isEmpty());
//Iterator iterator()返回此集合中的元素迭代器
//增强for
for(Object obj:set1){
System.out.println("增强for--"+obj);
}
//Iterator 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 initialCpacity)构造一个空的HashMap具有指定的初始容量和默认负载因子（0.75）
HashMap(int initialCapacity,float loadFactor)构造一个空的HashMap具有指定的初始容量和负载因子
HashMap(Map m)构造一个新的HasgMap与指定的相同的映射Map
实例方法
void clear()清空集合
Object put(Object key,Object value)向集合中添加键值对数据
boolean containsKey(Object key)判断集合中是否包含指定的键
boolean containsValue(Object vlaue)判断集合中是否包含指定的值
Object get(Object key)根据指定的键得到该键对应的值
boolean isEmpty()判断集合是否为空
int size()得到集合中键值对元素的个数
void remove(Object key)根据指定的键删除对应的键值对数据值
set keySet()得到集合中的所有键保存到Set集合中
Collection vlaues()得到集合中所有的值保存到Collection集合中
Set> entrySet()得到集合中所有的键值对数据保存到Set集合中
例如：
package com.test3;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
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)构造一个空的 HashMao具有指定的初始容量和默认负载因子(0.75)
HashMap map2=new HashMap(20);
Map map22=new HashMap(20);
//HashMap(int initialCapacity,float lodaFactor)构造一个空的HashMap具有指定的初始容量和负载因子
HashMap map3=new HashMap(20,0.45f);
Map map33=new HashMap(20,0.45f);
//HashMap(Map m)构造一个新的HashMap与指定的相同的映射Map。
//实例方法
//Object put(Object key,Object value)向集合中添加键值对数据
map1.put("name", "zhangsan");
map1.put(1001,"id");
map1.put(true,168.5);
map1.put(null,false);
map1.put("test",null);
map1.put(null, null);
//int size() 得到集合中键值对元素的个数
System.out.println("size==="+map1.size());
//boolean containsKey(Object key)判断集合中是否包含指定的键
System.out.println("containsKey=="+map1.containsKey("name"));
//boolean containValue(Object value)判断集合中是否包含指定的值
System.out.println("containsValue=="+map1.containsValue("zhangsan"));
//Object get(Object key)根据指定的键得到改建对应的值
System.out.println("get=="+map1.get("name"));
//V remove(Object key)根据指定的键删除对应的键值对数据
map1.remove(null);
System.out.println("size=="+map1.size());
//void clear()清空集合
//map1.clear();
//boolean isEmpty()判断集合是否为空
//System.out.println(map1.isEmpty());
//Set keyset()得到集合中所有的键保存到Set集合中
Set setkey=map1.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=map1.values();
for(Object obj1:coll){
System.out.println("value=="+obj1);
}
Iterator itvalue=setkey.iterator();
while(itvalue.hasNext()){
Object obj=itvalue.next();
System.out.println("Iterator=key--"+obj);
}
//Set> entrySet()得到集合中所有键值对数据Set集合中
Set> set1=map1.entrySet();
for(Map.Entry entry:set1){
System.out.println("Keyvalue--"+entry.getValue());
}
}
}
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> entrySet()得到集合中所有的键值对数据保存到Set集合中
Enumeration keys()返回此散列表中键的枚举。
Enumeration elements()返回此散列表中值的枚举。
例如：
package com.test3;
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)构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子
Hashtable table2=new Hashtable(20);
//Hashtable(int initialCapacity,float loadFactor)构造一个新的，空的哈希表，具有指定的初始容量和负载因子
Hashtable table3=new Hashtable(20,0.85f);
//Hashtable(Map t)构造一个与给定的相同映射的哈希表
Hashtable table4=new Hashtable(table1);
//实例方法
//Object put(Object key,Object value)向集合中添加键值对数据
table1.put("name", "zhangsan");
table1.put("id", 1001);
table1.put(1001,"stuid");
table1.put(true, 168.5);
//table1.put(null, false);
//Student stu1=new Student();
//table1.put(stu1, "student对象");
//boolean containsKey(Object key)判断集合中是否包含指定的键
System.out.println("containsKey=="+table1.containsKey("name"));
//boolean containsValue(Object value)判断集合中是否包含指定的值
System.out.println("containsValue=="+table1.containsValue("zhangsan"));
//Object get(Object key)根据指定的键得到该键对应的值
System.out.println("get=="+table1.get("name"));
//booelan isEmpty()判断集合是否为空
System.out.println(table1.isEmpty());
//int clear()//清空集合
//table1.clear();
//System.out.println(table1.isEmpty());
//int size()得到集合中键值对的元素个数
System.out.println("size=="+table1.size());
//V remove(Object key)根据指定的键删除对应的键值对数据
System.out.println("remove=="+table1.remove("name"));
//Set keySet()得到集合中所有的键保存到Set集合中
Set setkey=table1.keySet();
for(Object obj:setkey){
System.out.println(obj);
}
Iterator itkey=setkey.iterator();
while(itkey.hasNext()){
Object obj=itkey.next();
System.out.println(obj);
}
//Collection values()得到集合中所有的值保存到Collection集合中
Collection ct=table1.values();
for(Object obj:ct){
System.out.println("vlaue=="+obj);
}
Iterator itvalue=setkey.iterator();
while(itvalue.hasNext()){
Object obj=itvalue.next();
System.out.println("Iterator=="+obj);
}
//Set> entrySet()得到集合中所有的键值对数据保存到Set集合中
Set> set1=table1.entrySet();
for(Map.Entry entry:set1){
System.out.println("keyvalue=="+entry.getValue());
}
}
}
3.TreeMap类---红黑数基于NavigableMap实现【有序】
1.按照键的字母顺序排列
2.键不能为null
3.重复的键被算作一个数据
4.非线程安全
构造方法
TreeMap()使用其键的自然排序构造一个新的空树桩图。
TreeMap(Mapm)构造一个新的树状图，其中包含指定与给定的相同的映射，根据其键的自然顺序进行排序。
实例方法：
void clear()清空集合
Object put(Object key,Object value)向集合中添加键值对数据
boolean containsKey(Object key)判断集合中是否包含指定的键
boolean containsValue(Object value)判断集合中是否包含指定的值
Object get(Object key)根据指定的键得到该键对应的值
booelan isEmpty()判断集合是否为空
int size()得到集合中键值对元素的个数
V remove(Object key)根据指定的键删除对应的键值对数据
Set keySet()得到集合中所有的键保存到Set集合中
Collection values()得到集合中所有的值保存到Collection集合中
Set> entrySet()得到集合中所有的键值对海事局与保存到Set集合中
例如：
package com.test3;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest {
public static void main(String[] args) {
//TreeMap()使用其键的自然排序构造一个新的空树桩图
TreeMap tree1=new TreeMap();
//TreeMap(Map m)
//构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序排序
//实例方法
//Object put(Object key,Object value)向集合中添加键值对数据
tree1.put("name", "zhangsan");
tree1.put("id", 1001);
tree1.put("stuid", 1001);
tree1.put("age",18 );
tree1.put("address", "xian");
tree1.put("address", null);
//boolean containsKey(Object key)判断集合中是否包含指定的键
System.out.println("containskey=="+tree1.containsKey("name"));
//boolean containsValue(Object value)判断集合中是否包含指定的值
System.out.println("containsvalue=="+tree1.containsValue("zhangsan"));
//Object get(Object key)根据指定的键得到该键对应的值
System.out.println("get---"+tree1.get("name"));
//V remove(Object key)根据指定的键删除对应的键值对数据
tree1.remove("name");
System.out.println("size=="+tree1.size());
//void clear()清空集合
//tree1.clear();
//boolean isEmpty()判断集合是否为空。
System.out.println(tree1.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);
}
//Collenction 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=="+obj);
}
//Set> entrySet()得到集合中所有的键值对数据保存到Set集合中
Set> set1=tree1.entrySet();
for(Map.Entry entry:set1){
System.out.println("keyvalue--"+entry.getKey()+","+entry.getValue());
}
}
}
4.ConcurrentHashMap类与HashMap相似
ConcurrentHashMap类线程完全支出检索是高并发处理，如果需要线程安全并发实现，name建议使用ConcurrentHashMap代替HashMap。
