Map接口

package com.www.java1;

import org.junit.Test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 一、Map实现类的结构
 * |------Map：双列数据，存储key-value数据，-----类似于“函数”
 *      |-----HashMap：作为Map主要实现类：线程不安全，效率高；可以存储null的key和value
 *             |-----LinkedHashMap：保证遍历Map元素时，可以按照添加的顺序遍历
 *                      原因：在原有的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：无序、不可重复----->key所在的类要重写equals和hashCode方法（以hashMap为例）
 *  Map中的value：无序、可重复----->value所在类要重写equals
 *  一个键值对key-value构成一个Entry对象（无序、不可重复）
 * 三、HashMap底层实现原理？以JDK7说明
 *    HashMap map = new HashMap();
 *    在实例化以后，底层创建了长度是16的一维数组Entry[] table，
 *    ...可能已经执行多次put...
 *    map.put(key1,value1)；
 *    首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
 *    如果此位置上的数据为空，此时的key1-value1添加成功---->情况一
 *    如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据
 *    的哈希值：
 *          如果key1的哈希值和已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----->情况二
 *          如果key1的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals(key2)
 *          如果equals()返回false：此时key1-value1添加成功----->情况三
 *          如果equals()返回true：使用value1替换value2.
 *
 *      补充：对于情况二三，以链表形式存储
 *
 *      在不断的添加过程中，涉及到扩容问题(当超出临界值，且存放位置非空时)，默认的扩容方式：变为原来的两倍，并将原有数据复制过来
 *
 *      jdk8相较于jdk7在底层实现方面的不同：
 *      1.new HashMap()：底层没有创建数组
 *      2.jdk8创建的数组名称为Node[]
 *      3.在调用put()方法时开始创建数组
 *      4.jdk7底层结构：数组 + 链表；jdk8底层结构：数组 + 链表 + 红黑树
 *      当数组的某一个索引位置上的元素以链表形式存在时，如果链表上的数据 > 8 ，且数组长度大于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集合
 *
 *
 *
 *
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class MapTest {
    /*
     *  元视图操作的方法：
     *  Set keySet()：返回所有key构成的Set集合
     *  Collection values()：返回所有value构成的Collection集合
     *  Set entrySet()：返回所有key-value对构成的Set集合
     */
    @Test
    public void test3(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",23);
        map.put(34,123);

//        Set key = map.keySet();
//        Iterator iterator = key.iterator();
//        while(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        System.out.println("");
//        Collection value = map.values();
//        Iterator iterator1 = value.iterator();
//        while (iterator1.hasNext()){
//            System.out.println(iterator1.next());
//        }
//        System.out.println("");
//        Set keyValue = map.entrySet();
//        Iterator iterator2 = keyValue.iterator();
//        while (iterator2.hasNext()){
//            System.out.println(iterator2.next());
//        }//单纯遍历

        //遍历方式一
        Set key1 = map.keySet();
        Iterator iterator3 = key1.iterator();
        while(iterator3.hasNext()){
            Object next = iterator3.next();//取到了key
            Object o = map.get(next);//取到了value
            System.out.println(next + "===" + o);
        }
        //遍历方式二
        Set set = map.entrySet();//键值对
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();//返回的是一个泛型
            Map.Entry obj1 = (Map.Entry) obj;//Node[]实现了Map.Entry，每一个键值对都是Node类型，也就是Map.Entry
            System.out.println(obj1.getKey() + "===" + obj1.getValue());
        }

    }
    /*
     添加、删除、修改操作：
    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中的所有数据
     */
    @Test
    public void test2(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put("BB",23);
        map.put(34,123);
        //修改
        map.put("AA",12);

        System.out.println(map);//{AA=12, BB=23, 34=123}

        Map map1 = new HashMap();
        map1.put(12,234);
        map1.put("CC",234);
        map.putAll(map1);
        System.out.println(map);//{AA=12, BB=23, CC=234, 34=123, 12=234}

        Object cc = map.remove("CC");
        System.out.println(cc);//234
        System.out.println(map);//{AA=12, BB=23, 34=123, 12=234}

        map.clear();
        System.out.println(map.size());//0
    }

    @Test
    public void test(){
        Map map = new HashMap();
        map.put(null,null);
    }
}

package com.www.java1;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class Person implements Comparable{
    String name;
    int age;

    public Person() {
    }

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name.equals(person.name);
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }

    //按照姓名从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o.getClass() == getClass()){
            Person p = (Person)o;
            return this.name.compareTo(p.name);
        }else{
            throw new RuntimeException("输入类型不匹配");
        }
    }

}

package com.www.java1;

import org.junit.Test;

import java.util.*;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class TreeMapTest {
    //TreeMap中添加对象，key需要同一对象：自然排序、定制排序
    @Test
    public void test(){
        TreeMap map = new TreeMap();
        map.put(new Person("Tom",23),80);
        map.put(new Person("Jerry",18),85);
        map.put(new Person("Marry",22),90);
        map.put(new Person("Jack",23),85);
        map.put(new Person("Rose",25),87);
        map.put(new Person("Moria",21),23);
        map.put(new Person("Lucia",20),99);

        Set set = map.entrySet();//取出entry数组
        Iterator iterator = set.iterator();//迭代器
        while(iterator.hasNext()){
            Map.Entry entry = (Map.Entry)iterator.next();
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }

    //按照成绩排序
    @Test
    public void test1(){
        Comparator com = new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {

                if(o1.getClass() == Person.class && o2.getClass() == Person.class){//因为比较的是key，对应的是person
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;//强转

                    return Integer.compare(p1.getAge(),p2.getAge());
                }
                throw new RuntimeException("数据类型不匹配");
            }
        };
        TreeMap map = new TreeMap(com);
        map.put(new Person("Tom",23),80);
        map.put(new Person("Jerry",18),85);
        map.put(new Person("Marry",22),90);
        map.put(new Person("Jack",23),85);
        map.put(new Person("Rose",25),87);
        map.put(new Person("Moria",21),23);
        map.put(new Person("Lucia",20),99);

        Set set = map.entrySet();//取出entry数组
        Iterator iterator = set.iterator();//迭代器
        while(iterator.hasNext()){
            Map.Entry entry = (Map.Entry)iterator.next();
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }


}

name=Tom捉杰瑞
password=abc123

package com.www.java1;

import java.io.FileInputStream;
import java.util.Properties;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class PropertiseTest {
    public static void main(String[] args) throws Exception {
        //处理配置文件
        Properties prop = new Properties();
        FileInputStream file = new FileInputStream("jdbc.properties");
        prop.load(file);//加载流对应的文件
        String name = prop.getProperty("name");
        String password = prop.getProperty("password");
        System.out.println("name = " + name + "password= " + password);
    }
//    @Test
//    public void test() throws Exception {
//
//        Properties prop = new Properties();
//        FileInputStream file = new FileInputStream("jdbc.properties");
//        prop.load(file);//加载流对应的文件
//        String name = prop.getProperty("name");
//        String password = prop.getProperty("password");
//        System.out.println("name = " + name + "password= " + password);
//    }//出错
}