Java 集合框架3
一、集合框架分类
二、 关于Map接口的常用类
1.HashMap
HashMap类是Map接口的子类，是处理无序键值对集合的
| HashMap特征 | |
| 1.允许有null键和null值 | |
| 2.数据保存是无序的 | |
| 3.重复的键被算作一个数据 |
i.HashMap构造方法
//HashMap() 构造一个初始存储空间为16，负载因子为0.75的空HashMap集合
HashMap hashMap = new HashMap();
//HashMap(int initialCapacity) 构造一个初始空间为自定义，负载因子为0.75的空的HashMap
HashMap hashMap1 = new HashMap(20);
//HashMap(int initialCapacity,float loadFactor) 构造一个初始空间为自定义，负载因子也为自定义的空的HashMap集合
HashMap hashMap2 = new HashMap(34,0.5f);
//HashMap(Map) 将通过实现Map接口的类型，转换为HashMap类
Hashtable hashtable = new Hashtable();
HashMap hashMap3 = new HashMap(hashtable);ii.实例方法
/*
HashMap类的常用方法
1.Object put(Object) 向HashMap集合中添加元素
2.boolean containsKey(Object obj) 集合中是否包含指定键
3.boolean containsValue(Object obj) 集合中是否包含指定值
4.Object get(key) 得到指定键的值
5.boolean isEmpty() 集合是否为空
6.void clear() 清空集合
7.int size() 得到集合的键值对个数
8.Value remove(Object key) 根据指定的键删除对应的键值对数据值,返回被删除键的value值
*/
HashMap hashMap = new HashMap();
hashMap.put("id",972);
hashMap.put("name","张全蛋");
hashMap.put("age",25);
hashMap.put(null,34);
hashMap.put("address",null);
hashMap.put(null,null);
System.out.println(hashMap);
System.out.println(hashMap.size());
System.out.println(hashMap.containsKey(null));
System.out.println(hashMap.containsValue(25)); System.out.println(hashMap.get("address"));
System.out.println(hashMap.isEmpty());
System.out.println(hashMap.remove(null));
System.out.println(hashMap.remove("id"));
hashMap.put("id",972);
System.out.println(hashMap);
//遍历集合
//Set keySet() 得到集合中所有的键保存到Set集合中
Set set = hashMap.keySet();
for (Object objectkey:set){
System.out.println(objectkey);
}
// Collection values() 得到集合中所有的值保存到Collection集合中
Collection collection = hashMap.values();
for (Object objectvalue:collection){
System.out.println(objectvalue);
}
// Set> entrySet() 得到集合中所有的键值对数据Set集合中
HashMap hashMap4 = new HashMap();
hashMap4.put("class",238);
hashMap4.put("soc",78);
hashMap4.put(23,90);
// Set> set1 = hashMap4.entrySet();
for (Object object:hashMap4.entrySet()){
System.out.println(object);
}
2.Hashtable
| Hashtable特征 |
| 1.不允许nul键/null值 |
| 2.数据保存是无序的 |
| 3.重复的数据被算组一个 |
| 4.线程安全 |
| 5.用作键的对象必须实现hashCode方法和equals方法 |
i.构造方法
//Hashtable类 是Map接口的子类，是无序集合，处理键值对的集合
/*
Hashtable类的构造特征
1.不允许null键和null值
2.数据保存是无序的
3.用作键的对象必须实现hashCode方法和equals方法
4.重复的键被视为一个数据
5.线程安全
*/
//Hashtable类的构造方法
//1.Hashtable() 构造一个初始容量为11，负载因子为0.75的空集合
Hashtable hashtable = new Hashtable();
//2.Hashtable(int initialCapacity) 构造一个自定义初始容量，负载因子为0.75的空集合
Hashtable hashtable1 = new Hashtable(35);
//3.Hashtable(int initialCapacity,float loadFactor) 构造一个自定义初始容量，负载因子也为自定义的空集合
Hashtable hashtable2 = new Hashtable(40,0.5f);
//4.Hashtable(Map) 将通过Map实现的类，转换为Hashtable
HashMap hashMap = new HashMap();
Hashtable hashtable3 = new Hashtable(hashMap);ii.实例方法
/*
Hashtable类的实例方法
1.Object put(key,value) 向Hashtable集合中添加键值对
2.int size() 得到集合中的键值对个数
3.boolean containsKey() 是否包含键
4.boolean containsValue() 是否包含值
5.Value get(key) 根据键得到值
6.boolean isEmpty() 是否为空
7.void clear() 清空
8.Value remove(key) 删除指定键的键值对,返回被删除键的值
*/
hashtable.put("id",837);
hashtable.put("name","文秀");
hashtable.put("age",33);
// hashtable.put(null,83);
// hashtable.put(67,null);
// hashtable.put(null,null);
System.out.println(hashtable);
System.out.println(hashtable.size());
System.out.println(hashtable.containsKey("name"));
System.out.println(hashtable.containsValue(34));
System.out.println(hashtable.get("id"));
System.out.println(hashtable.isEmpty());
hashtable.put("asdf",232);
System.out.println(hashtable.remove("asdf"));
System.out.println(hashtable);
//遍历
//Set keySet() 根据键遍历
Set set = hashtable.keySet();
for (Object objectkey:set){
System.out.println(objectkey);
}
//Collection values() 根据值遍历
Collection collection = hashtable.values();
for (Object objectvalue:collection){
System.out.println(objectvalue);
}
//Set> entrySet() 根据键值遍历
Hashtable hashtable4 = new Hashtable();
hashtable4.put("learn","java");
hashtable4.put("time",1999);
hashtable4.put("soc",89);
hashtable4.put("sex","男");
Set> set1 = hashtable4.entrySet();
for (Object object:set1){
System.out.println(object);
} 3.TreeMap
| TreeMap特征 |
| 1.按照键的字母/数字顺序排列---有序 |
| 2.键不能为null，值可以为null |
| 3.重复的键被算作一个数据 |
| 5.非线程安全 |
i.构造方法
//TreeMap是有序集合，是Map的子类
/*
TreeMap类的特征
1.按照字母或数字顺序排列
2.不能有null键，可以有null值
3.重复的键被算作一个数据
4.非线程安全
*/
//TreeMap构造方法
//1.TreeMap() 构造一个空的集合
TreeMap treeMap = new TreeMap();
//2.TreeMap(Map) 将其他实现Map的类，转换为TreeMap类
HashMap hashMap = new HashMap();
TreeMap treeMap1 = new TreeMap(hashMap);ii.实例方法
/*
TreeMap类的实例方法
1.Object put(key,value) 添加键值对
2.int size() 返回键值对的个数
3.boolean containsKey() 是否包含键
4.boolean containsValue() 是否包含值
5.Value get(key) 根据指定键，获取其值
6.Value remove(key) 根据指定键，删除键值对，返回值
7.void clear()清空集合
8.boolean isEmpty() 集合是否为空
*/
treeMap.put("id",238);
treeMap.put("name","张全蛋");
treeMap.put("class","java");
treeMap.put("address","雁塔区");
// treeMap.put(1,1);
System.out.println(treeMap);
System.out.println(treeMap.size());
System.out.println(treeMap.containsKey("class"));
System.out.println(treeMap.containsValue(238));
System.out.println(treeMap.get("address"));
System.out.println(treeMap.isEmpty());
treeMap.put("jhjhd",23);
System.out.println(treeMap.remove("jhjhd"));
System.out.println(treeMap);
//遍历TreeMap集合
//1.Set keySet() 根据键值遍历
Set set = treeMap.keySet();
for (Object objectkey:set){
System.out.println(objectkey);
}
//2.Collection values() 根据值遍历
Collection collection =treeMap.values();
for (Object objectvalue:collection){
System.out.println(objectvalue);
}
//Set> entrySet() 根据键值遍历
TreeMap treeMap2 = new TreeMap();
treeMap2.put("ces",2323);
treeMap2.put("123",123);
treeMap2.put("user",23233);
Set> set1 = treeMap2.entrySet();
for (Map.Entry entry:set1){
String key = entry.getKey();
Integer values = entry.getValue();
int value = values;
System.out.println(value+1);
} 4.ConcurrentHashMap
| ConcurrentHashMap特征 |
| 1.数据保存是无序的 |
| 2.不允许null键和null值 |
| 3.重复的键被算作一个数据 |
| 4.线程安全 |
| 5.支持高并发处理 |
i.构造方法
//ConcurrentHashMap类是无序集合，是Map的子类
//ConcurrentHashMap类的特征
//1.不允许null的值和null键
//2.数据保存是无序的
//3.重复的键被算作是一个数据。
//4.线程安全
//5.支持高并发处理
//构造方法
//ConcurrentHashMap() 创建一个新的，空的地图与默认的初始表大小（16）。
ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
//ConcurrentHashMap(int initialCapacity)创建一个新的空的地图，其初始表格大小适应指定数量的元素，而不需要动态调整大小
ConcurrentHashMap conmap2=new ConcurrentHashMap(26);
//ConcurrentHashMap(int initialCapacity, float loadFactor) 根据给定的元素数量（ initialCapacity ）和初始表密度（ loadFactor ）
ConcurrentHashMap conmap3=new ConcurrentHashMap(20,0.5f);
//ConcurrentHashMap(Map m) 创建与给定地图相同的映射的新地图。
Hashtable hashtable = new Hashtable();
ConcurrentHashMap concurrentHashMap1 = new ConcurrentHashMap(hashtable);ii.实例方法
/*
实例方法
1.Object put(Object key, Object value) 向集合中添加键值对数据
2.int size() 返回键值对的个数
3.boolean containsKey(key)是否包含键
4.boolean contaninsValue(value)是否包含值
5.void clear()清空集合
6.value get(key) 根据键，得到值
7.value remove(key) 根据键删除键值对，返回被删除键的值
8.boolean isEmpty() 集合是否为空
*/
concurrentHashMap.put("id",1234);
concurrentHashMap.put("name","张三");
concurrentHashMap.put("age",32);
concurrentHashMap.put("school","北京大学");
System.out.println(concurrentHashMap.size());
System.out.println(concurrentHashMap.isEmpty());
System.out.println(concurrentHashMap.containsKey("age"));
System.out.println(concurrentHashMap.containsValue(32));
System.out.println(concurrentHashMap.get("school"));
concurrentHashMap.put("asdf",23);
System.out.println(concurrentHashMap.remove("asdf"));
//遍历
//Set keySet()按照键遍历
Set set = concurrentHashMap.keySet();
for (Object objectkey:set){
System.out.println(objectkey);
}
//Collection values() 按照值遍历
Collection collection = concurrentHashMap.values();
for (Object objectvalue:collection){
System.out.println(objectvalue);
}
//Set> entrySet() 根据键和值遍历
ConcurrentHashMap concurrentHashMap2 = new ConcurrentHashMap();
concurrentHashMap2.put("id",238);
concurrentHashMap2.put("name",232);
concurrentHashMap2.put("address",248);
concurrentHashMap2.put("cool",38);
for (Map.Entry entry:concurrentHashMap2.entrySet()){
String str_key = entry.getKey();
Integer int_value = entry.getValue();
// int value = int_value;
// System.out.println(value+1);
System.out.println(str_key+"="+int_value);
} 5.Collections类
| 1.Collections类是操作集合中元素的帮助类 |
| 2.Collections类中的方法都是静态的【对集合元素的检索，排序，线程安全操作】 |
i.常用方法
//Collections.copy(复制到的列表,被复制的列表)将所有元素从一个列表复制到另一个列表中
ArrayList arrayList = new ArrayList();
arrayList.add("id");
arrayList.add("name");
arrayList.add("age");
ArrayList arrayList1 = new ArrayList();
arrayList1.add(123);
arrayList1.add(234);
arrayList1.add(734);
arrayList1.add(5239);
Collections.copy(arrayList1,arrayList);
for (Object ob:arrayList1){
System.out.println(ob);
}
for (Object ob:arrayList){
System.out.println(ob);
}
//static void fill(List list, T obj)用指定的元素代替指定列表的所有元素
Collections.fill(arrayList1,"java");
System.out.println(arrayList1);
//static T max(Collection coll)根据其元素的自然顺序返回给定集合的最大元素
ArrayList arrayList3 = new ArrayList();
arrayList3.add(123);
arrayList3.add(24);
arrayList3.add(7342323);
System.out.println(Collections.max(arrayList3));
//static T min(Collection coll)根据其元素的自然顺序返回给定集合的最小元素
System.out.println(Collections.min(arrayList3));
//static boolean replaceAll(List list, T oldVal, T newVal)将列表中一个指定值的所有出现替换为另一个
//将arrayList3中的24替换成189
Collections.replaceAll(arrayList3,24,189);
System.out.println(arrayList3);
//static void reverse(List list)反转指定列表中元素的顺序
// Collections.reverse(arrayList3);
// System.out.println(arrayList3);
//static void sort(List list)根据其元素的natural ordering对指定的列表进行排序
Collections.sort(arrayList3);//从小到大
System.out.println(arrayList3);
Collections.sort(arrayList3);//排序
Collections.reverse(arrayList3);//反转
System.out.println(arrayList3);//从大到小