集合Map接口
/*
* 1、集合分为两大家族:
* (1)Collection:一组对象,单身party
* List和Set
* (2)Map:一组键值对,映射关系,情侣party
*
* 2、Map接口
* (1)API
* put(Object key, Object value)
* putAll(Map m):将另一个m中是所有的映射关系都添加到当前map中
*
* boolean containsKey(Object key) :是否包含某个key
* boolean containsValue(Object value) :是否包含某个value
* boolean isEmpty():是否为空
*
* Object get(Object key):根据key获取它的value
*
* void clear() :清空所有
* Object remove(Object key) :根据key删除一对映射关系,并且返回其中的value
*
* int size()
*
* 遍历map:
* Map接口没有继承java.lang.Iterable接口,所以不支持直接使用foreach循环进行遍历。
* Map接口中也没有提供Iterator iterator()方法返回迭代器对象。
*
* (1)Set keySet()
* 获取所有的key,然后遍历它们
* 这里所有的key组成了一个Set集合,因为它们不可重复
*
* (2)Collection values()
* 获取所有的value,然后遍历它们
* 这里所有的value组成了一个Collection系列的集合,可能重复,也可能不重复
*
* (3)Set entrySet()
* 获取所有的映射关系,然后遍历它们。此时把一对映射关系(key,value)看成一个整体,是Entry类型的对象。
* 因为key不可重复,那么所有的组合也就唯一了,所以所有的映射关系也是set集合
*
* (2)说明:任意的引用数据类型都可以作为key和value。
* 虽然key也可以是任意类型的对象,但是习惯上,或者说我们遇到的最多的key的类型是:String和Integer。
* 因为String和Integer比较简洁,而且对象不可变。
*
*/
@SuppressWarnings("all")
public class TestMap {
@Test
public void test08(){
Map map = new HashMap();
String[] girls = {"翠花","凤姐","石榴"};
map.put("杨洪强", girls);
ArrayList list = new ArrayList();
list.add("小红");
list.add("小蓝");
list.add("小紫");
map.put("崔志恒", list);
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test07(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.put("苏海波", "翠花");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test06(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.put("苏海波", "翠花");
Collection values = map.values();
for (Object value : values) {
System.out.println(value);
}
}
@Test
public void test05(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
Set keys = map.keySet();
for (Object key : keys) {
System.out.println(key + "->" + map.get(key));//通过key得到value
}
}
@Test
public void test04(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
Set keys = map.keySet();
for (Object key : keys) {
System.out.println(key);
}
}
@Test
public void test03(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.remove("杨洪强");
System.out.println("对数:" + map.size());
}
@Test
public void test02(){
Map map = new HashMap();
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
System.out.println(map.containsKey("崔志恒"));
System.out.println(map.containsValue("凤姐"));
System.out.println(map.get("甄玉禄"));
}
@Test
public void test01(){
Map map = new HashMap();//HashMap是Map的一个实现类
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
System.out.println("情侣的对数:" + map.size());
}
}
Map接口的实现类们
/*
* 一、Map接口的实现类们:
* 1、HashMap
* 2、Hashtable
* 3、TreeMap
* 4、LinkedHashMap
* 5、Properties
*
* 二、HashMap和Hashtable 哈希表
* Hashtable:旧版。线程安全的。它的key和value不能为null。
* HashMap:相对Hashtable它来说新一点。线程不安全。它允许key和value为null值。
*
* StringBuffer和StringBuilder
* Vector和ArrayList
* Hashtable和HashMap
*
* 三、HashMap和LinkedHashMap
* LinkedHashMap是HashMap的子类,比HashMap多维护了映射关系的添加顺序。
*
* HashMap:无序的。
* LinkedHashMap:可以记录添加顺序。
*
* LinkedHashMap比HashMap要做的事多,效率低。只在需要维护顺序时再使用它。
*
* 四、HashMap和TreeMap
* HashMap:无序的。
* TreeMap:按照key排大小顺序。
*
* 五、Properties
* Properties是Hashtable的子类,不允许key和value是null,并且它的key和value的类型都是String。
* 通常用于存储配置属性。
* 而且为了可读性更好,还增加了两个方法:
* setProperty(key,value)
* String getProperty(key)
*
* 六、所有的map的key不能重复,如何实现不重复?
* HashMap、Hashtable、LinkedHashMap、Properties:依据key的hashCode和equals方法
* TreeMap:依据key的大小,认为大小相等的两个key就是重复的
*
* 如果key重复了,那么后面的value会替换原来的value。
*
* TreeMap要让key排大小,要么key类型本身实现了java.lang.Comparable接口,要么在创建TreeMap时,指定一个java.util.Comparator接口的实现类对象。
*
*/
@SuppressWarnings("all")
public class TestMapImpl {
//key不可重复
@Test
public void test7(){
Map map = new HashMap();
map.put("杨洪强", "翠花");//被覆盖了
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.put("杨洪强", "冰冰");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test6() throws IOException{
Properties pro = System.getProperties();//获取系统属性配置
Set entrySet = pro.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test5() throws IOException{
Properties pro = new Properties();
pro.load(TestMapImpl.class.getClassLoader().getResourceAsStream("jdbc.properties"));
String user = pro.getProperty("user");
String password = pro.getProperty("password");
System.out.println(user);
System.out.println(password);
}
@Test
public void test4(){
Properties pro = new Properties();
pro.setProperty("user", "chailinyan");
pro.setProperty("pwd", "123456");
String user = pro.getProperty("user");
String password = pro.getProperty("pwd");
System.out.println(user);
System.out.println(password);
}
@Test
public void test3(){
Map map = new TreeMap();//按照key排大小顺序。
map.put("yanghongqiang", "翠花");
map.put("cuizhiheng", "如花");
map.put("zhenyulu", "凤姐");
map.put("suhaibo", "翠花");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test2(){
Map map = new LinkedHashMap();//按照添加顺序
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.put("苏海波", "翠花");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
@Test
public void test1(){
Map map = new HashMap();//完全无序
map.put("杨洪强", "翠花");
map.put("崔志恒", "如花");
map.put("甄玉禄", "凤姐");
map.put("苏海波", "翠花");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
System.out.println(entry);
}
}
}
Set集合的底层实现
/*
* Set的底层实现是什么?
* 1、HashSet : HashMap
* 2、TreeSet : TreeMap
* 3、LinkedHashSet: LinkedHashMap
*
* Set添加元素时用add(元素),而Map添加元素put(key,value)。
* 发现添加到Set中的元素,是作为底层的Map的key,那么value它们选用了一个Object类型的常量对象PRESENT。
* 所有的HashSet共用同一个PRESENT对象。
* 所有的TreeSet共用同一个PRESENT对象。
* 所有的LinkedHashSet共用同一个PRESENT对象。
*
*/
public class TestSetSource {
}
HashMap的底层实现
/*
* Map的底层实现是什么?
* 1、哈希表系列:
* 数组 + 链表
* 数组 + 链表/红黑树
* 2、TreeMap:红黑树
*
* HashMap的底层实现:
* JDK1.7以及之前:数组 + 链表
* JDK1.8以及之后:数组 + 链表/红黑树
*
* 数组的优点:访问速度快,因为可以根据下标直接定位到某个元素
* 链表的优点:不需要元素是挨着存储,不需要连续空间,在添加和删除元素时不需要移动元素,只需要修改前后元素的引用关系就可以。
* HashMap:会根据key的hashCode-->公式/算法-->[index]
* 因为不同的hashCode值,可能得到的[index]是相同的,那么此时就冲突了,那么只能把[index]的多个映射关系用链表连接起来
* 二叉树的优点:查找的速度比链表快
* 旧版的HashMap,如果key的hashCode算出了[index]相同的话(我们称为冲突)都在一个table[index]下面,
* 如果严重的话,会导致[index]下面的链表很长,就会导致查询速度减慢。当链表长到一定程度时,就需要把链表变为二叉树,以提高我们查询速度。
*
*/
public class TestMapSource {
}