import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.TreeMap;

public class HashAndTree {
    public static void main(String[] args) {
        //关于哈希表的引用传递和值传递
        //使用Java提供的引用数据类型时，哈希表是值传递
        //使用自定义(抽象)数据类型，哈希表是引用传递
        System.out.println("============1.关于哈希表的引用传递和值传递============");
        HashSet<Integer> hs1 = new HashSet<>();
        /**
         * 当定义的值范围不在integer常量池范围内时(-127~128)，视为两个对象。
         * 在常量池范围中时，为一个对象。
         */
        Integer a1 = 100;
        Integer a2 = 100;
        System.out.println("在常量池范围：");
        System.out.println(a1==a2);

        Integer b1 = 129;
        Integer b2 = 129;
        System.out.println("不在常量池范围：");
        System.out.println(b1==b2);

        /**
         * 当范围不在常量池，但存放在哈希表中时，值传递，同一对象。
         */
        hs1.add(b1);
        System.out.println("不在常量池范围，但存在哈希表中：");
        System.out.println(hs1.contains(b2));

        /**
         * 使用自定义的引用数据类型，引用传递。
         * 很好理解，t1,t2相当于两个对象（两个内存地址），所以必然不会相等
         */
        HashSet<Test> hs2 = new HashSet<>();
        Test t1 = new Test(10);
        Test t2 = new Test(10);
        hs2.add(t1);
        System.out.println("使用自定义数据类型时：");
        System.out.println(hs2.contains(t2));

        //如果一个对象被不同变量引用呢？
        //一个对象被不同变量引用，其实用的都是同一个内存地址。
        Test t3 = t1;
        Test t4 = t1;
        hs2.add(t3);
        System.out.println("使用自定义数据类型时，一个对象被不同变量引用：");
        System.out.println(hs2.contains(t4));

        System.out.println("============2.关于哈希表的固定操作============");
        HashMap<Integer,String> hm1 = new HashMap<>();
        //增加
        hm1.put(001,"宋江");
        hm1.put(002,"吴用");
        hm1.put(003,"李逵");
        System.out.println("添加元素后：");
        for (Map.Entry<Integer, String> entry : hm1.entrySet()){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
        System.out.println("删除元素后：");
        hm1.remove(002);
        for (Map.Entry<Integer,String> entry : hm1.entrySet()){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
        System.out.println("修改元素后：");
        hm1.put(003,"林冲");
        for (Map.Entry<Integer,String> entry : hm1.entrySet()){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
        System.out.println("查找001号元素是否存在：");
        System.out.println(hm1.containsKey(001));
        System.out.println("查找001号元素的值：");
        System.out.println(hm1.get(001));

        System.out.println("============3.关于有序表的固定操作============");
        TreeMap<Integer,String> treeMap = new TreeMap<>();
        treeMap.put(7,"我是7");
        treeMap.put(2,"我是2");
        treeMap.put(1,"我是1");
        treeMap.put(8,"我是8");
        treeMap.put(5,"我是5");
        System.out.println("添加元素后：");
        for (Map.Entry<Integer,String> entry : treeMap.entrySet()){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
        System.out.println("删除元素后：");
        treeMap.remove(1);
        for (Map.Entry<Integer,String> entry : treeMap.entrySet()){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
        System.out.println("有序表中的最小值是："+treeMap.firstKey());
        System.out.println("有序表中的最大值是："+treeMap.lastKey());
        System.out.println("有序表中<=9的值的最大值是"+treeMap.floorKey(9));
        System.out.println("有序表中>=1的值的最小值是"+treeMap.ceilingKey(1));
    }
}
class Test{
    int value;
    public Test(int value){
        this.value = value;
    }
}