Java中的集合框架(2)
为了更好的帮助大家便利的学习java这门编程语言，和更好的巩固java语言学习中的基础知识，我们特意为大家精心制作了java程序设计精编教程。
本教程精选java核心内容，结合实例，循序渐进的向大家介绍Java语言。以零基础讲解为基础，用实例引导大家学习，深入浅出的向大家介绍java的相关知识和实战技能。
Java入门(32)
Java中的集合框架(2)
JDK提供的处理键值对数据的集合类
键值对数据---一个独立的键值对数据是由键和值两部分组成
例如：书的目录就是一中典型的键值对结构
1.Map接口是处理键值对数据的*集合接口。
HashMap类
Hashtable类
HashMap类
1.可以处理键值对数据
2.保存键值对数据的存储空间会自动扩展。
3.所保存的键值对数据可以为null.[1.null=”sss” 2. “sss”=null 3. null=null]
4.保存的键值对数据是无序的。
5.不能有重复的键【重复的键算一个数据】
标题=页码
【键】=【值】
构造方法：
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map m) 将实现Map接口的集合类转换成HashMap
例如：
package com.click369.test1;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
public static void main(String[] args) {
//HashMap的构造方法--创建对象
//HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap map1=new HashMap();
//HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap map2=new HashMap(20);
//HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap map3=new HashMap(30,0.5f);
//HashMap(Map m) 将实现Map接口的集合类转换成HashMap
HashMap map4=new HashMap(map1);
//可以利用Map接口
Map map11=new HashMap();
Map map22=new HashMap(20);
Map map33=new HashMap(30,0.5f);
Map map44=new HashMap(map33);
}
}
HashMap常用的实例方法：
put(K key, V value) 添加键值对数据。
size() 得到集合中键值对元素的个数。
isEmpty() 判断集合书否为空
clear() 清空集合。
containsKey(Object key) 判断指定的键数据在集合中是否存在。
containsValue(Object value) 判断指定的值数据在集合中是否存在 。
get(Object key)根据指定的键数据得到与这个键对应的值数据。
remove(Object key)根据指定的键数据删除整个键值对数据。
replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
例如：
package com.click369.test2;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
public static void main(String[] args) {
//HashMap的实例方法
HashMap map1=new HashMap();
//1.put(K key, V value) 添加键值对数据。
//键或者值都可以是任意数据类型
map1.put("hello", 1001);
map1.put(1002,"world");
map1.put(true, 12.5);
map1.put(120.5, false);
//所保存的键值对数据可以为null.
//map1.put(null, "test"); //键为null，值不为null
//map1.put("test",null); //键不为null，值为null
//map1.put(null,null); ///键为null，值为null
//不能有重复的键【重复的键算一个数据】
//map1.put("java","test1");
//map1.put("java","test2");
//2.size() 得到集合中键值对元素的个数。
System.out.println("map1集合键值对元素的个数=="+map1.size());
//3.isEmpty() 判断集合是否为空
System.out.println("map1集合判断集合是否为空=="+map1.isEmpty());
//4.clear() 清空集合。
//5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
System.out.println("判断指定的键数据在集合中是否存在=="+map1.containsKey("hello"));
//6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
System.out.println("判断指定的值数据在集合中是否存在=="+map1.containsValue("hello"));
//7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get("hello"));
//8.remove(Object key)根据指定的键数据删除整个键值对数据。
//map1.remove(true);
//System.out.println("map1集合键值对元素的个数=="+map1.size());
//System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(true));
//9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
map1.replace(1002, "world", "hello");
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
}
}
遍历键值对对集合：
Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
例如：
public static void main(String[] args) {
HashMap map=new HashMap();
map.put(100,"zhangsan");
map.put(12.5,true);
map.put("test",1000);
map.put(false,168.5);
//Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Set keyset=map.keySet();
for(Object objkey:keyset){
System.out.println("key==="+objkey);
}
//Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
Collection vals=map.values();
for(Object objvalue:vals){
System.out.println("value==="+objvalue);
}
//Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
Set k_v_set=map.entrySet();
for(Object obj:k_v_set){
System.out.println(obj);
}
//遍历Map集合的方法
HashMap<String,String> testmap=new HashMap<String,String>();
testmap.put("name","zhangsan");
testmap.put("pass","123456");
testmap.put("address","西安");
for(Map.Entry<String,String> entry:testmap.entrySet()){
//System.out.println("mykey=="+entry.getKey());
//System.out.println("myvalue=="+entry.getValue());
System.out.println("k-v=="+entry.getKey()+":"+entry.getValue());
}
}
Hashtable类
1.可以处理键值对数据
2.保存键值对数据的存储空间会自动扩展。
3.不允许null出现
4.不能有重复的键【重复的键算一个数据】
5.保存的键值对数据是无序的。
构造方法：
Hashtable() 构造一个空的 Hashtable，默认初始容量（11）和默认负载系数（0.75）。
Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable
例如：
package com.click369.test1;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class TestMain {
public static void main(String[] args) {
//Hashtable的构造方法--创建对象
//Hashtable() 构造一个空的 Hashtable ，默认初始容量（11）和默认负载系数（0.75）。
Hashtable table1=new Hashtable();
//Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
Hashtable table2=new Hashtable(20);
//Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
Hashtable table3=new Hashtable(30,0.5f);
//Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable
HashMap map4=new HashMap();
Hashtable table4=new Hashtable(map4);
//可以利用Map接口
Map table11=new Hashtable();
Map table22=new Hashtable(20);
Map table33=new Hashtable(30,0.5f);
Map table44=new Hashtable(table33);
}
}
实例方法：
put(K key, V value) 添加键值对数据。
size() 得到集合中键值对元素的个数。
isEmpty() 判断集合书否为空
clear() 清空集合。
containsKey(Object key) 判断指定的键数据在集合中是否存在。
containsValue(Object value) 判断指定的值数据在集合中是否存在 。
get(Object key)根据指定的键数据得到与这个键对应的值数据。
remove(Object key)根据指定的键数据删除整个键值对数据。
replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
例如：
package com.click369.test2;
import java.util.Hashtable;
public class TestMain {
public static void main(String[] args) {
//Hashtable的实例方法
Hashtable table1=new Hashtable();
//1.put(K key, V value) 添加键值对数据。
//键或者值都可以是任意数据类型
table1.put("hello", 1001);
table1.put(1002,"world");
table1.put(true, 12.5);
table1.put(120.5, false);
//不允许null出现
//table1.put(null, "test");
//table1.put("test",null);
//不能有重复的键【重复的键算一个数据】
//table1.put("java","test1");
//table1.put("java","test2");
//2.size() 得到集合中键值对元素的个数。
System.out.println("table1集合键值对元素的个数=="+table1.size());
//3.isEmpty() 判断集合是否为空
System.out.println("table1集合判断集合是否为空=="+table1.isEmpty());
//4.clear() 清空集合。
//5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
System.out.println("判断指定的键数据在集合中是否存在=="+table1.containsKey("hello"));
//6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
System.out.println("判断指定的值数据在集合中是否存在=="+table1.containsValue("hello"));
//7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get("hello"));
//8.remove(Object key)根据指定的键数据删除整个键值对数据。
table1.remove(true);
System.out.println("table1集合键值对元素的个数=="+table1.size());
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(true));
//9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
table1.replace(1002, "world", "hello");
System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
}
}
遍历兼职对集合：
Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
例如：
package com.click369.test3;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestMain {
public static void main(String[] args) {
//Hashtable的遍历
Hashtable<Object,Object> table1=new Hashtable<Object,Object>();
table1.put("hello", 1001);
table1.put(1002,"world");
table1.put(true, 12.5);
table1.put(120.5, false);
//遍历所有的键数据
//Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Set set1=table1.keySet();
for(Object obj:set1){
System.out.println("key=="+obj);
}
//使用迭代器遍历键数据对饮的set集合
Iterator keyit=set1.iterator();
while(keyit.hasNext()){
System.out.println("keyit=="+keyit.next());
}
//遍历所有的值数据
//Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
Collection coll=table1.values();
for(Object val:coll){
System.out.println("value=="+val);
}
//使用迭代器遍历键数据对饮的set集合
Iterator valit=coll.iterator();
while(valit.hasNext()){
System.out.println("valit=="+valit.next());
}
//遍历所有的键和值数据
//Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
//注意：HashMap<Object,Object> map1=new HashMap<Object,Object>();
for(Map.Entry<Object,Object> entry : table1.entrySet()){
Object k=entry.getKey();
Object v=entry.getValue();
System.out.println(k+"="+v);
}
}
}
Collections类 【集合操作类的辅助类】
提供对集合进行操作的查询，复制，排序，线程安全操作的一系列静态方法
集合操作类的辅助类，与数组的辅助类【Arrays】相似。
例如：
package com.click369.test1;
import java.util.ArrayList;
import java.util.Collections;
public class TestMain {
public static void main(String[] args) {
//Collections类
//是集合操作类的辅助类
//提供了一组操作集合的静态方法【查询集合元素，复制集合中的元素进入另一个集合，为集合中的元素排序...】
ArrayList list1=new ArrayList();
list1.add("zhangsan");
list1.add("lisi");
list1.add("Lisi");
list1.add("zhaoliu");
//static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 返回给定集合的最大元素。
Object max=Collections.max(list1);
System.out.println(max);
//static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 返回给定集合的最小元素。
Object min=Collections.min(list1);
System.out.println(min);
System.out.println("------------------------");
System.out.println("没有排序之前");
for(Object obj:list1){
System.out.println("没有排序之前=="+obj);
}
System.out.println("------------------------");
// sort(List<T> list) 对指定的列表进行排序。
Collections.sort(list1);
System.out.println("排序之后");
for(Object obj:list1){
System.out.println("排序之后=="+obj);
}
//static <T> void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中,会覆盖目标列表中的对应数据元素。
//注意：目标集合的元素个数 >= 源集合的元素个数 ，否则java.lang.IndexOutOfBoundsException: Source does not fit in dest
ArrayList list2=new ArrayList();
list2.add(234);
list2.add(547);
list2.add(13);
list2.add(464);
list2.add(4565);
list2.add(6579823);
Collections.copy(list2, list1);
for(Object obj:list2){
System.out.println("list2=="+obj);
}
}
}
作业：
1.Collection接口与Map接口的区别？
2.HashMap与Hashtable的区别？
3.HashMap和ConcurrentHashMap的区别?
HashMap是非线程安全的，因此多线程操作时需要格外小心。
ConcurrentHashMap线程安全的。
4.Collection接口与Collections类的区别？