主要内容
- Map接口及其多个实现类的对比
- Map中存储key-value的特点
- HashMap底层实现原理
- LinkedHashMap底层实现原理
- Map常用方法
- TreeMap两种添加方式的使用
- Properties处理属性文件
Map接口
User.java
package Map;
import java.util.Objects;
/**
* ClassName: User
* Date: 2020/3/4 13:01
* author: Oh_MyBug
* version: V1.0
*/
public class User implements Comparable{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
// 按照姓名从小到大排列
@Override
public int compareTo(Object o) {
if (o instanceof User){
User user = (User) o;
// return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name);
if (compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age);
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
}MapTest.java
package Map;
import org.junit.Test;
import java.util.*;
/**
* ClassName: MapTest
* Date: 2020/3/4 14:33
* author: Oh_MyBug
* version: V1.0
*
* 一、Map的实现类的结构
* |----Map：双列数据，存储key-value对的数据 ---类似于高中的函数：y = f(x)
* |----HashMap：作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
* |----LinkedMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
* 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素，
* 对于频繁的遍历操作，此类执行效率高于HashMap
* |----TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序
* 底层使用红黑树
* |----Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value
* |----Properties：常用来处理配置文件。key和value都是String类型
*
* HashMap的底层：数组+链表 （jdk7及之前）
* 数组+链表+红黑树 （jdk8）
*
* 面试题：
* 1. HashMap的底层实现原理？
* 2. HashMap 和 Hashtable的异同？
* 3. CurrentHashMap 与 Hashtable的异同？
*
*
* 二、Map结构的理解
* Map中的key：无序的、不可重复的，使用Set存储所有的key ---> key所在的类要重写equals()和hashCode()（以HashMap为例）
* Map中的value：无序的、可重复的，使用Collection存储所有的value
* 一个键值对：key-value构成了一个Entry对象
* Map中的entry：无序的、不可重复的，使用Set存储所有的entry
*
* 三、HashMap的底层实现原理？以jdk7为例说明：
* HashMap map = new HashMap()：
* 在实例化以后，底层创建了长度是16的一维数组Entry[] table。
* ...可能已经执行过多次put...
* map.put(key1,value1)：
* 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
* 如果此位置上的数据为空，此时的key1-value1添加成功。 ---情况1
* 如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），
* 比较key1和已经存在的一个或多个数据的哈希值：
* 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。 ---情况2
* 如果key1的哈希值与已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals()方法，比较：
* 如果equals()返回false，此时key1-value1添加成功 ---情况3
* 如果equals()返回true：使用value1替换相同key的value2
*
* 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
*
* 在不断的添加的过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。
*
* jdk8 相较于jdk7在底层实现方面的不同：
* 1. new HashMap()：底层没有创建一个长度为16的数组
* 2. jdk 8底层的数组是：Node[]，而非Entry[]
* 3. 首次调用put方法时，底层创建长度为16的数组
* 4. jdk 7底层结构只有：数组+链表，jdk 8中底层结构：数组+链表+红黑树
* 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，
* 此时此索引位置上的所有数据改为使用红黑树存储
*
* DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16
* DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
* threshold：扩容的临界值 = 容量 × 填充因子：16 × 0.75 = 12
* TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
* MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64
*
* 四、LinkedHashMap的底层实现原理
* 源码中：
* static class Entry<K,V> extends HashMap.Node<K,V> {
* Entry<K,V> before, after; // 能够记录添加的元素的先后顺序
* Entry(int hash, K key, V value, Node<K,V> next) {
* super(hash, key, value, next);
* }
* }
*
* 五、Map中定义的方法
* 添加、删除、修改操作:
* Object put(Object key,Object value)：将指定key-value添加到（或修改）当前map对象中
* void putAll(Map m)：将m中的所有key-value对存放到当前map中
* Object remove(Object key)：移除指定key的key-value对，并返回value
* void clear()：清空当前map中的所有数据
* 元素查询的操作：
* Object get(Object key)：获取指定key对应的value
* boolean containsKey(Object key)：是否包含指定的key
* boolean containsValue(Object value)：是否包含指定的value
* int size()：返回map中key-value对的个数
* boolean isEmpty()：判断当前map是否为空
* boolean equals(Object obj)：判断当前map和参数对象obj是否相等
* 元视图操作的方法：
* Set keySet()：返回所有key构成的Set集合
* Collection values()：返回所有value构成的Collection集合
* Set entrySet()：返回所有key-value对构成的Set集合
*
* 总结：常用方法：
* 添加：put(Object key,Object value)
* 删除：remove(Object key)
* 修改：put(Object key,Object value)
* 查询：get(Object key)
* 长度：size()
* 遍历：keySet() / values() / entrySet()
*/
public class MapTest {
@Test
public void test1(){
Map map = new HashMap();
// 添加
map.put("AA", 123);
map.put(45, 123);
map.put("BB", 56);
// 修改
map.put("AA", 87);
System.out.println(map);
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);
// remove(Object key)
Object value = map.remove("CC");
System.out.println(value);
System.out.println(map);
// clear()
map.clear(); // 与map = null; 操作不同
System.out.println(map.size());
System.out.println(map);
/*
输出：
{AA=87, BB=56, 45=123}
{AA=87, BB=56, CC=123, DD=123, 45=123}
123
{AA=87, BB=56, DD=123, 45=123}
0
{}
*/
}
@Test
public void test2(){
Map map = new HashMap();
map.put("AA", 123);
map.put(45, 123);
map.put("BB", 56);
// Object get(Object key)
System.out.println(map.get(45));
// containsKey(Object key)
boolean isExist = map.containsKey("BB");
System.out.println(isExist);
// containsValue(Object value)
isExist = map.containsValue(123);
System.out.println(isExist);
map.clear();
System.out.println(map.isEmpty());
/*
输出：
123
true
true
true
*/
}
@Test
public void test3(){
Map map = new HashMap();
map.put("AA", 123);
map.put(45, 123);
map.put("BB", 56);
// 遍历所有的key集：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("*******************");
// 遍历所有的value集:values()
Collection values = map.values();
for (Object obj: values){
System.out.println(obj);
}
System.out.println("*******************");
// 遍历所有的key-value
// 方式一：entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
// entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + " ---> " + entry.getValue());
}
System.out.println("*******************");
// 方式二：
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + " ==== " + value);
}
/*
输出：
AA
BB
45
*******************
123
56
123
*******************
AA ---> 123
BB ---> 56
45 ---> 123
*******************
AA ==== 123
BB ==== 56
45 ==== 123
*/
}
}TreeMapTest.java
package Map;
import org.junit.Test;
import java.util.*;
/**
* ClassName: TreeMaoTest
* Date: 2020/3/4 19:04
* author: Oh_MyBug
* version: V1.0
*/
public class TreeMapTest {
// 向TreeMap中key-value，要求key必须是由同一个类创建的对象
// 因为要按照key进行排序：自然排序、定制排序
@Test
public void test1(){
TreeMap map = new TreeMap();
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1, 98);
map.put(u2, 89);
map.put(u3, 76);
map.put(u4, 100);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + " ---> " + entry.getValue());
}
}
// 定制排序
@Test
public void test2(){
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}
throw new RuntimeException("输入的数据类型不匹配");
}
});
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1, 98);
map.put(u2, 89);
map.put(u3, 76);
map.put(u4, 100);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + " ---> " + entry.getValue());
}
/*
输出：
User{name='Rose', age=18} ---> 100
User{name='Jack', age=20} ---> 76
User{name='Tom', age=23} ---> 98
User{name='Jerry', age=32} ---> 89
*/
}
}PropertiesTest.java
package Map;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
/**
* ClassName: PropertiesTest
* Date: 2020/3/4 19:21
* author: Oh_MyBug
* version: V1.0
*/
public class PropertiesTest {
// Properties：常用来处理配置文件。key和value都是String类型
public static void main(String[] args){
FileInputStream fis = null;
try {
Properties pros = new Properties();
fis = new FileInputStream("jdbc.properties");
pros.load(fis); // 加载流对应的文件
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name:" + name + "\npassword:" + password);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
输出：
name:OhMyBug
password:123
*/
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
