Day20（SetTest,MapDemo,ArrayListAndHashMap,CollectionsDemo,HashMapAndHashtable,LinkedHashMap,TreeMap）

一、Set Test1

package com.shujia.lhw.day20;

import java.util.HashSet;

/*
    HashSet集合存储自定义对象并遍历
    如果对象的成员变量值相同即为同一个对象

    1、创建一个学生类
    2、创建HashSet集合对象
    3、创建5个学生对象
    5、将学生对象添加到集合当中
    6、遍历

 */
public class SetTest1 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Student1> set = new HashSet<>();

        //创建5个学生对象
        Student1 s1 = new Student1("明旺",18);
        Student1 s2 = new Student1("王宇",17);
        Student1 s3 = new Student1("周家祥",19);
        Student1 s4 = new Student1("张保桂",20);
        Student1 s5 = new Student1("明旺",18);

        //将学生对象添加到集合当中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

        //遍历
        for (Student1 student1 : set) {
            System.out.println(student1.getName()+"---"+student1.getAge());
        }
    }
}

package com.shujia.lhw.day20;

import java.util.Objects;

public class Student1 {
    private String name;
    private int Age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        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) {
        Age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student1 student1 = (Student1) o;
        return Age == student1.Age && Objects.equals(name, student1.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, Age);
    }

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", Age=" + Age +
                '}';
    }
}

----------------------------------------------------------------------------------------------------------------------------

二、SetTest2

package com.shujia.lhw.day20;

import java.util.Comparator;
import java.util.TreeSet;

/*
    TreeSet集合存储自定义对象并遍历
    如果对象的成员变量值相同即为同一个对象
    按照年龄进行从大到小排序

 */
public class SetTest2 {
    public static void main(String[] args) {
        //无参构造，走的是自然排序
//        TreeSet<Student2> set1 = new TreeSet<>();
        //带参数构造方法，走的是比较器排序
        //匿名内部类实现
        TreeSet<Student2> set1 = new TreeSet<>(new Comparator<Student2>(){
            @Override
            public int compare(Student2 o1, Student2 o2) {
//                return 0;
                //按照年龄从大到小排序
                int i = o2.getAge() - o1.getAge();
                //隐含条件
                //年龄一样，姓名不一定一样
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()):i;

                return i2;
            }
        });

        //创建学生对象
        Student2 s1 = new Student2("刘备",18);
        Student2 s2 = new Student2("曹操",19);
        Student2 s3 = new Student2("孙权",7);
        Student2 s4 = new Student2("诸葛亮",11);
        Student2 s5 = new Student2("司马懿",19);
        Student2 s6 = new Student2("刘备",20);

        //将学生对象添加到集合中
        set1.add(s1);
        set1.add(s2);
        set1.add(s3);
        set1.add(s4);
        set1.add(s5);
        set1.add(s6);

        //遍历
        for (Student2 student2 : set1) {
            System.out.println(student2.getName()+"---"+student2.getAge());
        }
    }
}

package com.shujia.lhw.day20;

public class Student2 implements Comparable<Student2>{
    private String name;
    private int age;

    public Student2() {
    }

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

    @Override
    public int compareTo(Student2 o) {
//        return 0;
        //按照年龄从大到小进行排序
        int i = o.getAge() - this.age;
        //隐含条件
        //年龄一样，姓名不一定一样
        int i2 = i == 0 ? o.name.compareTo(this.name):i;

        return i2;
    }
}

-------------------------------------------------------------------------------------------------------------------------------

三、SetTest3

package com.shujia.lhw.day20;

import java.util.Comparator;
import java.util.TreeSet;

/*
    键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩）按照总分从高到低输出到控制台

    1、创建学生类
    2、创建集合对象TreeSet
    3、创建学生对象
    4、将学生对象添加到集合当中
    5、遍历
 */
import java.util.Scanner;

public class SetTest3 {
    public static void main(String[] args) {
        //比较器排序
        TreeSet<Student3> set = new TreeSet<>(new Comparator<Student3>() {
            @Override
            public int compare(Student3 o1, Student3 o2) {
//                return 0;
                //按照总分从高到低输出到控制台
                int i = o2.getSumScore() - o1.getSumScore();
                //挖掘隐含条件
                //总分一样，语文成绩不一定一样
                int i2 = i == 0 ? o2.getChinese() - o1.getChinese() : i;
                //语文成绩一样，数学成绩不一定一样
                int i3 = i2 == 0 ? o2.getMath() - o1.getMath() : i2;

                //各科成绩一样姓名不一定一样
                int i4 = i3 == 0 ? o1.getName().compareTo(o2.getName()) : i3;

                return i4;
            }
        });

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //使用创建学生对象并添加到集合当中
        for (int i = 0; i <= 5; i++) {
            System.out.println("请输入第" + i + "个学生的姓名:");
            String name = sc.next();
            System.out.println("请输入" + i + "学生的语文成绩:");
            int chinese = sc.nextInt();
            System.out.println("请输入" + i + "学生的数学成绩：");
            int math = sc.nextInt();
            System.out.println("请输入" + i + "学生的英语成绩：");
            int english = sc.nextInt();

            //创建学生对象
//            Student3 student = new Student3(name,chinese,math,english);
            Student3 student3 = new Student3();
            student3.setName(name);
            student3.setChinese(chinese);
            student3.setMath(math);
            student3.setEnglish(english);

            //将学生对象添加到集合当中
            set.add(student3);
        }
        System.out.println("=====================================================");
        System.out.println("学生的信息如下：");
        System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩\t总成绩");
        //遍历学生信息
        for (Student3 student3 : set) {
            System.out.println(student3.getName()+"\t"+student3.getChinese()+"\t"+student3.getMath()
            +"\t"+student3.getEnglish()+"\t"+student3.getSumScore());
        }
    }
}

package com.shujia.lhw.day20;

public class Student3 {
    private String name;
    private int chinese;
    private int math;
    private int english;

    public Student3() {
    }

    public Student3(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }
//定义获取总分的方法
    public int getSumScore(){
        return chinese+math+english;
    }
    @Override
    public String toString() {
        return "Student3{" +
                "name='" + name + '\'' +
                ", chinese=" + chinese +
                ", math=" + math +
                ", english=" + english +
                '}';
    }
}

--------------------------------------------------------------------------------------------------------------------------------

四、Map

package com.shujia.lhw.day20;
/*
    Map接口的概述：
      将键映射到值的对象
      Map不能包含重复的键
      每个键可以映射到最多一个值

    举例：
      <k,v>
      1001 王宇
      1002 周家祥
      1001 周家祥（不允许）
    Map集合中，K的值不能重复

    Map接口与Collection接口的区别：
      1、Map接口与Collection接口是平级关系，不存在继承关系，都是属于util包下的
      2、Map中的元素都是成对出现的，Map集合中的键是唯一的，值是可以重复的，又称之为：夫妻对
      3、Collection集合中的元素都是单独出现的，Collection接口下面有一个子接口Set，它的元素也是唯一

      List中的元素也是单独存出现，可以重复，像这样单独存在的元素，称之为：光棍

    Map接口中的方法：
      1、添加功能：
        V put(k key,V value)将指定值与该映射中的指定键相关联（可选操作）
        举例：map.put(1001,"王宇");

      2、删除功能：
        void clear()从Map中删除所有的映射（可选操作）
        V remove(Object key)如果存在（可选操作），从该Map中删除一个键的映射

      3、判断功能：
        boolean containsKey(Object key)如果此映射包含指定键的映射，则返回true
        boolean containsValue(Object value)如果Map将一个或多个键映射到指定的值，则返回true
        boolean isEmpty()如果Map不包含键值映射，则返回true

      4、获取功能：
        V get(Object key)返回指定键所映射的值，或null 如果此映射包含键的映射
        Set<K> keySet()返回此Map中包含的键的Set视图
        Collection<V> values()返回此Map中所包含的值的Collection视图
        Set<Map.Entry<K,V>> entrySet()获取Map中的所有元素，元素的类组成是由一个键和一个值组成

      5、长度功能：
        int size()返回此Map中键值映射的数量

 */

import com.sun.org.apache.bcel.internal.generic.IUSHR;

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {

        //创建Map集合对象
        //由于Map是一个接口，所以接口不能实例化，要使用一个具体的子类来进行实例化
        //这里借助HashMap
        Map<String,String> map = new HashMap<>();

        //添加元素
        //V put(K key,V value)将指定的值与该映射中的键相关联（可选操作）
        //这里的返回值是将来再次插入同一个键的时候，被覆盖的那个值
        System.out.println(map.put("黄晓明","杨颖"));
        System.out.println(map.put("邓超","孙俪"));
        System.out.println(map.put("小虎","冯提莫"));
        System.out.println(map.put("小虎","IU"));
        map.put("黄晓明","杨颖");
        map.put("邓超","孙俪");
        map.put("小虎","冯提莫");
        map.put("小虎", "IU");

        //删除功能：
        //void clear()从该Map中删除所有的映射（可选操作）
//        map.clear();
//        V remove(Object key)如果存在（从可选的操作），从该Map中删除一个键的映射
        //返回对应删除的值
//        System.out.println(map.remove("小虎"));
        System.out.println("==============================================]");
        //boolean containsKey(Object key)如果此映射包含指定键的映射，则返回true
        System.out.println(map.containsKey("小虎"));
        //boolean containsValue(Object value)如果此Map将一个或多个键映射到指定的值，则返回true
        System.out.println(map.containsValue("IU"));
        System.out.println(map.isEmpty());
        System.out.println("====================================================");

        System.out.println(map);
    }
}

-------------------------------------------------------------------------------------------------------------------------

五、Map 2

package com.shujia.lhw.day20;

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

/*
    Map集合的获取功能：
      V get(Object key)返回指定键所映射的值，或 null如果此映射包含该建的映射
      Set<K> keySet()返回此Map中包含的键的Set视图
      Collection<V> values()返回此Map中包含的值的Collection视图

 */
public class MapDemo2 {
    public static void main(String[] args) {
        //创建Map集合对象
        HashMap<String,String> map = new HashMap<>();

        //向集合中添加元素
        map.put("黄晓明","杨颖");
        map.put("邓超","孙俪");
        map.put("小虎","冯提莫");
        map.put("张杰","谢娜");

        //V get(Object key)返回到指定键所映射到的值，或 null如果此映射包含改键的映射
        //根据key找值
        //如果map中不包含此key，则返回null
        System.out.println(map.get("小虎"));
        System.out.println(map.get("明旺"));
        System.out.println("===========================================");

        //Set<K> keySet()返回此Map中包含的键的Set视图
        Set<String> set = map.keySet();
        for(String s : set){
//            System.out.println(s);
            String value = map.get(s);
            System.out.println(s+":"+value);
        }

        //Collection<V> values() 返回此Map中包含的值的Collection视图
        Collection<String> values = map.values();
        for (String s : values) {
            System.out.println(s);
        }
    }
}

-----------------------------------------------------------------------------------------------------------------------

六、Map 3

package com.shujia.lhw.day20;

import java.util.HashMap;
import java.util.Set;

/*
    集合遍历的方式一：
      根据键找值
        1、通过调用keySet()方法获取Map集合中所有的key
        2、通过get(key)这个方法，可以获取到每一个key对应的value
        3、输出

 */
public class MapDemo3 {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();

        //向集合中添加元素
        map.put("霞","洛");
        map.put("蛮王","寒冰");
        map.put("卢锡安","塞纳");
        map.put("盖伦","卡特");

        //通过调用keySet()方法获取Map集合中所有的key
        Set<String> keySet = map.keySet();

        //遍历keySet获取到每一个key
        for (String s : keySet) {
            String value = map.get(s);
            System.out.println(s+":"+value);
        }
    }
}

---------------------------------------------------------------------------------------------------------------------------------

七、Map 4

package com.shujia.lhw.day20;

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

/*
    Map集合遍历的第二种方式：
      依次先把所有的键值对获取到，然后再依次获取到每一个键值对的key和value
 */
public class MapDemo4 {
    public static void main(String[] args) {
        //1、创建集合对象
        HashMap<String,String> map = new HashMap<>();

        //2、向集合中添加元素
        map.put("王子1","白雪公主");
        map.put("王子2","灰姑娘");
        map.put("王子3","美人鱼");

        //遍历：依次先把所有的键值对获取到
        //Set<Map.Entry<K,V>> entrySet()获取Map中所有元素，元素的类组成是由一个键和一个值组成
        Set<Map.Entry<String,String>> set = map.entrySet();

        //遍历集合获取每一个键值对
        for (Map.Entry<String, String> keyValue : set) {
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }
    }
}

---------------------------------------------------------------------------------------------------------------------------

八、Map 5

package com.shujia.lhw.day20;

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

/*
    HashMap<Integer,String>
 */
public class MapDemo5 {
    public static void main(String[] args) {
        //1、创建集合对象
        HashMap<Integer,String> map = new HashMap<>();

        //2、向集合中添加元素
        map.put(1001,"明旺");
        map.put(1002,"王宇");
        map.put(1003,"周家祥");
        map.put(1003,"张保桂");

        //3、遍历集合
        System.out.println("================方式一：根据键找值====================");
        //获取到所有的key
        Set<Integer> set = map.keySet();
        for (Integer i : set) {
            String s = map.get(i);
            System.out.println(i+":"+s);
        }

        System.out.println("=================方式二：根据键值对找键和值===================");
        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        for (Map.Entry<Integer, String> keyValue : entrySet) {
            Integer key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }

    }
}

------------------------------------------------------------------------------------------------------------------------------

九、Map 6

package com.shujia.lhw.day20;

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

/*
    HashMap<String,Student>
 */
public class MapDemo6 {
    public static void main(String[] args) {
        //1、创建集合对象
        HashMap<String,Student4> map = new HashMap<>();

        //2、创建学生对象
        Student4 s1 = new Student4("明旺",18);
        Student4 s2 = new Student4("王宇",17);
        Student4 s3 = new Student4("周家祥",19);
        Student4 s4 = new Student4("张保桂",19);

        //3、向集合中添加键对值
        map.put("帅气男孩",s1);
        map.put("一表人才",s2);
        map.put("油腻大叔",s3);
        map.put("忧郁男孩",s4);

        Set<Map.Entry<String,Student4>> entries = map.entrySet();
        for (Map.Entry<String,Student4>keyValue:entries){
            String key = keyValue.getKey();
            Student4 value = keyValue.getValue();
            System.out.println(key+":"+value);
        }
    }
}

---------------------------------------------------------------------------------------------------------------------------------十、Map 7

package com.shujia.lhw.day20;

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

/*
    HashMap<Student,String>

    如果key是自己定义的一个对象，该类需要重写hashCode方法和equals方法
    因为put方法的底层，添加元素的标准就是根据hashCode()方法和equals()的值来判断元素是否重复
 */
public class MapDemo7 {
    public static void main(String[] args) {
        //1、创建集合对象
        HashMap<Student5,String> map = new HashMap<>();

        //2、创建学生对象
        Student5 s1 = new Student5("王昭君",17);
        Student5 s2 = new Student5("貂蝉",16);
        Student5 s3 = new Student5("杨玉环",18);
        Student5 s4 = new Student5("西施",19);
        Student5 s5 = new Student5("王昭君",17);

        //将元素添加到集合中
        map.put(s1,"1111");
        map.put(s2,"2222");
        map.put(s3,"3333");
        map.put(s4,"4444");
        map.put(s5,"5555");

        //遍历
        Set<Map.Entry<Student5,String>> entries = map.entrySet();
        for (Map.Entry<Student5,String> keyValue:entries){
            Student5 key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }
    }
}

------------------------------------------------------------------------------------------------------------------------------

十一、ArrayListAndHashMap

package com.shujia.lhw.day20;

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

/*
    ArrayList嵌套HashMap
 */
public class ArrayListAndHashMap {
    public static void main(String[] args) {
        //定义一个ArrayList对象
        ArrayList<HashMap<String,String>> list = new ArrayList<>();

        //创建2个HashMap对象
        HashMap<String,String> map1 = new HashMap<>();
        map1.put("霞","洛");
        map1.put("卢锡安","塞纳");
        map1.put("蛮王","寒冰");
        map1.put("盖伦","卡特");

        HashMap<String,String> map2 = new HashMap<>();
        map2.put("邓超","孙俪");
        map2.put("张杰","谢娜");
        map2.put("小虎","冯提莫");

        list.add(map1);
        list.add(map2);

        //遍历
        for (HashMap<String, String> maps : list) {
            Set<Map.Entry<String,String>> entries = maps.entrySet();
            for (Map.Entry<String, String> keyValue : entries) {
                String key = keyValue.getKey();
                String value = keyValue.getValue();
                System.out.println(key+":"+value);
            }
        }
    }
}

--------------------------------------------------------------------------------------------------------------------------

十二、CollectionsDemo1

package com.shujia.lhw.day20;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/*
    Collections工具类的概述：
      针对集合操作的工具类

    Collections与Collection的区别：
      1、Collection是单列集合的顶层接口，有两大子接口List/Set
      2、Collections是针对于集合操作的工具类，可以对集合进行排序，还有查找（二分查找）

      public static <T> void sort(List<T> list)
      public static <T> int binarySearch(List<?> list,T key)
      public static <T> T max(Collection<?> coll)
      public static void reverse(List<?> list)
      public static void shuffle(List<?> list)

      static <T> List<T> synchronizedList(List<T> list)返回由指定列表支持的同步（线程安全）列表

 */
public class CollectionsDemo1 {
    public static void main(String[] args) {
        //创建List集合对象
        ArrayList<Integer> list = new ArrayList<>();

        //将ArrayList转换成线程安全的集合，返回的集合和原本的是一个存储空间
        List<Integer> list1 = Collections.synchronizedList(list);
//        System.out.println(list.hashCode());
//        System.out.println(list1.hashCode());

        //添加元素
        list1.add(10);
        list1.add(30);
        list1.add(20);
        list1.add(70);
        list1.add(40);
        list1.add(50);
        System.out.println(list);

        System.out.println("============================================");
        System.out.println("排序前的集合："+list);
        //public static <T> void sort(List<T> list)
        Collections.sort(list);
        System.out.println("排序后的集合："+list);
        System.out.println("================================================");

        //排序后的集合：[10,20,30,40,50,70]
        //public static <T> binarySearch(List<?> list,T key)二分查找前提是有序
        //二分查找，如果元素存在，返回该元素对应索引
        System.out.println(Collections.binarySearch(list,70));
        System.out.println(Collections.binarySearch(list,700));

        //public static <T> T max(Collection<?> coll)查找最大值
        System.out.println(Collections.max(list));

        //public static void reverse(List<?> list)反转
        Collections.reverse(list);
        System.out.println(list);

        //public static void shuffle(List<?> list)随机置换
        Collections.shuffle(list);
        System.out.println(list);


    }
}

----------------------------------------------------------------------------------------------------------------------------

十三、HashMapAndHashtable

package com.shujia.lhw.day20;

import java.util.HashMap;
import java.util.Hashtable;

/*
    面试题：HashMap和Hashtable的区别：
      1、HashMap和Hashtable他们存储的元素都是一个一个的键值对
      2、HashMap中的key和value允许为null值，而Hashtable不允许
      3、Hashtable是线程安全的，而HashMap是线程不安全的

 */
public class HashMapAndHashtable {
    public static void main(String[] args) {
        HashMap<String,String> map1 = new HashMap<>();
        map1.put(null,"123");
        map1.put("111",null);
        map1.put(null,null);
        System.out.println(map1);

        Hashtable<String,String> map2 = new Hashtable<>();
//        map2.put(null,"123");//Hashtable元素中的key不允许为null
//        map2.put("111",null);//Hashtable元素中的value不允许为null
//        map2.put(null,null);
        System.out.println(map2);
    }
}

----------------------------------------------------------------------------------------------------------------------------

十四、LinkedHashMapDemo

package com.shujia.lhw.day20;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/*
    LinkedHashMap:
      class LinkedHashMap extends HashMap implements Map{}
      哈希表和链表实现的Map接口，具有可预测的迭代次序
      哈希保证的是元素的唯一，保证key是唯一
      链表保证是有序的（存储和取出的顺序一致）

 */
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<>();

        //向集合中添加元素
        map.put("1234","hello");
        map.put("4567","world");
        map.put("3456","java");
        map.put("7890","hadoop");
        map.put("1234","hive");

        //遍历
        Set<Map.Entry<String,String>> entries = map.entrySet();
        for(Map.Entry<String,String> keyValue:entries){
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }

    }
}

-------------------------------------------------------------------------------------------------------------------------------

十五、TreeMapDemo1

package com.shujia.lhw.day20;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
    TreeMap:键是基于红黑树存储的
    键：String
    值：String

 */
public class TreeMapDemo1 {
    public static void main(String[] args) {
        //1、创建集合对象
        TreeMap<String,String> map = new TreeMap<>();

        //创建元素并添加到集合中
        map.put("hello","你好");
        map.put("world","世界");
        map.put("java","面向对象的编程语言");
        map.put("mysql","结构化数据库");

        //遍历：
        Set<Map.Entry<String,String>> entries = map.entrySet();
        for(Map.Entry<String,String> keyValue:entries){
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }
    }
}

-----------------------------------------------------------------------------------------------------------------------------

十六、TreeMapDemo2

package com.shujia.lhw.day20;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
    TreeMap<String,String>
    键：Student键的存储是红黑树存储，可以保证键的排序和唯一
    值：String

 */
public class TreeMapDemo2 {
    public static void main(String[] args) {
        //1、创建TreeMap对象
//        TreeMap<Student6,String> map = new TreeMap<>();
        //推荐使用比较器排序，并且用匿名内部类实现
        TreeMap<Student6,String> map = new TreeMap<>(new Comparator<Student6>(){
            @Override
            public int compare(Student6 o1, Student6 o2) {
//                return 0;
                //判断年龄是否一样
                int i = o1.getAge() - o2.getAge();
                //年龄一样，姓名不一定一样
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()):i;

                return i2;
            }
        });

        //2、创建学生对象
        Student6 s1 = new Student6("明旺",18);
        Student6 s2 = new Student6("王宇",19);
        Student6 s3 = new Student6("周家祥",20);
        Student6 s4 = new Student6("张保桂",17);
        Student6 s5 = new Student6("明旺",18);

        //3、向集合中添加元素
        map.put(s1,"男枪");
        map.put(s2,"女警");
        map.put(s3,"卡特");
        map.put(s4,"霞");
        map.put(s5,"男枪");

        //遍历
        Set<Map.Entry<Student6,String>> entries = map.entrySet();
        for(Map.Entry<Student6,String> keyValue : entries){
            Student6 key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+":"+value);
        }
    }
}

package com.shujia.lhw.day20;

public class Student6 implements Comparable<Student6>{
    private String name;
    private int age;

    public Student6() {
    }

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

    @Override
    public int compareTo(Student6 o) {
//        return 0;
        //判断年龄是否一样
        int i = this.age - o.age;
        //年龄一样，姓名不一定一样
        int i2 = i == 0 ? this.name.compareTo(o.name):i;

        return i2;
    }
}

------------------------------------------------------------------------------------------------------------------------

十七、TreeMapDemo3

package com.shujia.lhw.day20;

import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*
    "aababcabcdabcde"获取字符串中每一个字母出现的次数要求结果：a(5)b(4)c(3)d(2)e(1)
    分析：
      1、定义一个字符串（后期可用键盘录入改进）
      2、定义一个TreeMap对象存储数据
        键：Character
        值：Integer
      3、将字符串转成字符数组
      4、遍历字符数组，得到每一个字符
      5、拿着这个字符作为键去map集合中去找，看返回值
        如果返回值是null，表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
        如果返回值不是null，说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
      6、定义一个StringBuffer作为拼接
      7、遍历集合得到键和值，按照对应的输出格式进行拼接
      8、把StringBuffer输出

    输入：aababcabcdabcde
    输出：a(5)b(4)c(3)d(2)e(1)
 */
public class TreeMapDemo3 {
    public static void main(String[] args) {
        //定义一个字符串（后期可用字符串改进）
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要统计的字符串：");
        String s = sc.next();

        //定义一个TreeMap对象存储数据
        TreeMap<Character,Integer> map = new TreeMap<>();

        //将字符串转成字符数组
        char[] chars = s.toCharArray();

        //遍历字符数组，得到每一个字符 增强for循环遍历
        for(Character ch : chars){
            //拿着这个字符作为键去Map集合中去找，看返回值get(key)
            Integer num = map.get(ch);

            //如果返回值是null，表示该集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
            if(num == null){
                map.put(ch,1);
            }else{
                //返回值不是null，说明集合中已经存在该字符作为键，value的值+1，然后重新放入到集合中
                num++;
                map.put(ch,num);
            }
        }

        //定义一个StringBuffer作为拼接
        StringBuffer sb = new StringBuffer();

        //遍历集合得到键和值，按照对相应的输出格式进行拼接
        Set<Map.Entry<Character,Integer>> entries = map.entrySet();
        for (Map.Entry<Character, Integer> keyValue : entries) {
            Character ch = keyValue.getKey();
            Integer number = keyValue.getValue();
            sb.append(ch).append("(").append(number).append(")");
        }

        //将StringBuffer转成字符串
        String result = sb.toString();
        System.out.println("统计结果为："+result);
    }
}