Map的实现类
package com.atguigu.java;
import org.junit.Test;
import java.util.*;
/**
* 一 ： Map的实现类
* /----Map ： 双列数据，存储key-value对的数据 ---类似于高中的函数：y=fx
* /----HashMap:作为Map的主要实现类***** 线程不安全的，效率高，可以存储null的key和value
* /----LinkedHashMap:保证遍历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方法。
* Map中的value是无序的，可重复的，使用？Collection存储所有的value ---value所在的类需要重写equals方法
* 一个键值对；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（key2）,比较
* 如果equals返回false，此时key1-value1添加成功。 -----情况3
* 如果equals返回true，使用value1去替换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中链表长度大于默认值，转换为红黑树 ： jsk8
* 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
* 删除 remove
* 修改 put
* 查询 get
* 长度 size
* 遍历 keySet values entrySet
*
* @author liangqichen
* @create 2021-09-29 20:11
*/
public class MapTest {
@Test
public void test5(){
/*
元视图操作的方法：
* Set keySet()：返回所有key构成的Set集合
* Collection values()：返回所有value构成的Collection集合
* Set entrySet()：返回所有key-value对构成的Set集合
*/
Map map = new HashMap();
map.put("AA",123);
map.put(45,1234);
map.put("BB",56);
// 遍历所有的key集 keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next()); // AA BB 45
}
// 遍历所有的value集 cvalues()
Collection values = map.values();
for(Object obj :values){
System.out.println(obj);// 123 56 1234
}
// 遍历所有的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() + "---》value" + entry.getValue());
// AA---》value123 BB---》value56 45---》value1234
}
//方式二：
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" + value);
//AA===value123 BB===value56 45===value1234
}
}
@Test
public void test4(){
/*
元素查询的操作：
* 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是否相等
*/
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//Object get(Object key)：获取指定key对应的value
System.out.println(map.get(45)); // 123 不存在为null
//boolean containsKey(Object key)
boolean isExist = map.containsKey("BB");
System.out.println(isExist); // true
// boolean containsValue(Object value)
isExist = map.containsValue(123);
System.out.println(isExist); // true
//int size()
map.clear();
//boolean isEmpty()
System.out.println(map.isEmpty()); // true
// boolean equals(Object obj)
}
@Test
public void test3(){
/*
添加、删除、修改操作：
* 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中的所有数据
*/
// 添加
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
// 修改
map.put("AA",87);
System.out.println(map); // {AA=87, BB=56, 45=123}
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map); // {AA=87, BB=56, CC=123, DD=123, 45=123}
// remove(Object key)
Object value = map.remove("CC");
System.out.println(value); // 123 若不存在 就返回null
System.out.println(map); //{AA=87, BB=56, DD=123, 45=123}
// clear
map.clear(); //长度还在
System.out.println(map.size()); // 0
System.out.println(map); // {}
}
@Test
public void test2(){
Map map = new HashMap();
map = new LinkedHashMap();
map.put(123,"AA");
map.put(345,"BB");
map.put(12,"CC");
System.out.println(map); // {123=AA, 345=BB, 12=CC}
}
@Test
public void test1() {
Map map = new HashMap();
map = new Hashtable();
map.put(null, null);
}
}package com.atguigu.java;
import org.junit.Test;
import java.util.*;
/**
* @author liangqichen
* @create 2021-10-01 20:27
*/
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 iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "--->" + entry.getValue());
/*
User{name='Tom', age=23}--->98
User{name='Rose', age=18}--->100
User{name='Jerry', age=32}--->89
User{name='Jack', age=20}--->76
*/
}
}
// 定制排序
@Test
public void test3(){
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 iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.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
*/
}
}
}package com.atguigu.java;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
/**
* @author liangqichen
* @create 2021-10-01 20:42
*/
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 passworld = pros.getProperty("passworld");
System.out.println("name = " + name + ",passworld " + passworld); // name = Tom,passworld abc123
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}name=Tom梁启晨
passworld=abc123package com.atguigu.java;
/**
* @author liangqichen
* @create 2021-09-25 10:04
*/
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) {
System.out.println("User equals()...");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
// 按照姓名从大到小排列,年龄从小到大排序
@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("输入的；类型不匹配");
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
