day17Java-Map练习

博客名称
Java-(中级)

在做TreeMap练习的时候想要实现排序,键值一定要实现Comparable或者Comparator就的方法才能实现排序,切记切记。。

HashMap练习1

需求:将下面数据用集合存储,并遍历
为了更符合要求：
这次的数据就看成是学生对象。

bj北京
  			jc	JavSE
  					林青霞		27
  					风清扬		30
  			jy	 JavaEE	
  					赵雅芝		28
  					糖糖		29
sh上海
  			jc	JavSE
  					郭美美		20
  					犀利哥		22
  			jy	JavaEE		
  					罗玉凤		21
  					马征		23
gz广州
  			jc	JavaSE
  					王力宏		30
  					李静磊		32
  			jy	JavaEE
  					郎朗		31
  					柳岩		33
xa西安
  			jc	JavaSE
  					范冰冰		27
  					刘意		30
  			jy	JavaEE
  					李冰冰		28
  					张志豪		29

代码演示

public class HashMapDemo06 {
    public static void main(String[] args) {
        //创建大集合
        HashMap<String, HashMap<String, ArrayList<Student>>> bighm = new HashMap<>();
        //创建中集合1
        HashMap<String, ArrayList<Student>> midhm1 = new HashMap<>();
        //创建小集合1
        ArrayList<Student> minal1 = new ArrayList<>();
        ArrayList<Student> minal2 = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student(" 赵雅芝", 28);
        Student s4 = new Student(" 糖糖", 29);
        //将学生对象添加到小集合
        minal1.add(s1);
        minal1.add(s2);
        minal2.add(s3);
        minal2.add(s4);
        //将小集合添加到中小集合
        midhm1.put("JavSE", minal1);
        midhm1.put("JavaEE", minal2);
        //将中集合添加到大集合
        bighm.put("北京", midhm1);

        //创建中集合2
        HashMap<String, ArrayList<Student>> midhm2 = new HashMap<>();
        //创建小集合2
        ArrayList<Student> minal3 = new ArrayList<>();
        ArrayList<Student> minal4 = new ArrayList<>();
        //创建学生对象
        Student s5 = new Student("郭美美", 20);
        Student s6 = new Student("犀利哥", 22);
        Student s7 = new Student("罗玉凤", 21);
        Student s8 = new Student("马征", 23);
        //将学生对象添加到小集合
        minal3.add(s5);
        minal3.add(s6);
        minal4.add(s7);
        minal4.add(s8);
        //将小集合添加到中小集合
        midhm2.put("JavaSE", minal3);
        midhm2.put("JavaEE", minal4);
        //将中集合添加到大集合
        bighm.put("上海", midhm2);

        //创建中集合3
        HashMap<String, ArrayList<Student>> midhm3 = new HashMap<>();
        //创建小集合3
        ArrayList<Student> minal5 = new ArrayList<>();
        ArrayList<Student> minal6 = new ArrayList<>();
        //创建学生对象
        Student s9 = new Student("王力宏", 30);
        Student s10 = new Student("李静磊", 32);
        Student s11 = new Student("郎朗", 31);
        Student s12 = new Student("柳岩", 33);
        //将学生对象添加到小集合
        minal5.add(s9);
        minal5.add(s10);
        minal6.add(s11);
        minal6.add(s12);
        //将小集合添加到中集合
        midhm3.put("JavaSE", minal5);
        midhm3.put("JavaEE", minal6);
        //将中集合添加到大集合
        bighm.put("广州", midhm3);

        //创建中集合4
        HashMap<String, ArrayList<Student>> midhm4 = new HashMap<>();
        //创建小集合4
        ArrayList<Student> minal7 = new ArrayList<>();
        ArrayList<Student> minal8 = new ArrayList<>();
        //创建学生对象
        Student s13 = new Student("范冰冰", 27);
        Student s14 = new Student("杨颖", 30);
        Student s15 = new Student("李冰冰", 28);
        Student s16 = new Student("卢本伟", 29);
        //将学生对象添加到小集合
        minal7.add(s13);
        minal7.add(s14);
        minal8.add(s15);
        minal8.add(s16);
        //将小集合添加到中集合
        midhm4.put("JavaSE",minal7);
        midhm4.put("JavaEE",minal8);
        //将中集合添加到大集合
        bighm.put("西安", midhm4);

        //方式1:获取键集合遍历
        for(String key:bighm.keySet()){
            System.out.println(key);
            HashMap<String, ArrayList<Student>> midhm = bighm.get(key);
            for(String midkey:midhm.keySet()){
                System.out.println("\t"+midkey);
                ArrayList<Student> minal = midhm.get(midkey);
                for (Student minkey:minal){
                    System.out.println("\t\t"+minkey.getName()+"\t"+minkey.getAge());
                }
            }
        }
        System.out.println("-----------------------------------------------");
        //方式2:获取键值对对象集合遍历
        for(Map.Entry<String, HashMap<String, ArrayList<Student>>> bigme:bighm.entrySet()){
            System.out.println(bigme.getKey());
            HashMap<String, ArrayList<Student>> minhm = bigme.getValue();
            for(Map.Entry<String,ArrayList<Student>> midme:minhm.entrySet()){
                System.out.println("\t"+midme.getKey());
                ArrayList<Student> minal = midme.getValue();
                for(Student minkey:minal){
                    System.out.println("\t\t"+minkey.getName()+"\t"+minkey.getAge());
                }
            }
        }
    }
}

结果:

上海
	JavaSE
		郭美美	20
		犀利哥	22
	JavaEE
		罗玉凤	21
		马征	23
广州
	JavaSE
		王力宏	30
		李静磊	32
	JavaEE
		郎朗	31
		柳岩	33
西安
	JavaSE
		范冰冰	27
		杨颖	30
	JavaEE
		李冰冰	28
		卢本伟	29
北京
	JavSE
		林青霞	27
		风清扬	30
	JavaEE
		 赵雅芝	28
		 糖糖	29
-----------------------------------------------
上海
	JavaSE
		郭美美	20
		犀利哥	22
	JavaEE
		罗玉凤	21
		马征	23
广州
	JavaSE
		王力宏	30
		李静磊	32
	JavaEE
		郎朗	31
		柳岩	33
西安
	JavaSE
		范冰冰	27
		杨颖	30
	JavaEE
		李冰冰	28
		卢本伟	29
北京
	JavSE
		林青霞	27
		风清扬	30
	JavaEE
		 赵雅芝	28
		 糖糖	29

Map集合练习2统计字符串字母数量

需求1:aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

分析:
    1.创建键盘录入对象,并录入数据
    2.创建录入的字符串数据转为字符数组
    3.创建集合对象,用于存储数据
    4.遍历字符数组
    5:在根据键获取键的值,获取的值可能
           是null
               put(key,1);
         不是null
               value++;
               put(key,value)
    6:创建StringBuffer对象
    7.遍历TreeMap集合
    8.将集合中元素,append到StringBuffer对象中

代码演示

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

        //根据题目的要求我将字符串转化成键盘录入
        Scanner sc = new Scanner(System.in);
        char[] chars = sc.nextLine().toCharArray();
        //创建集合对象
        TreeMap<Character, Integer> tm = new TreeMap<>();

        //遍历 数组
        for (char chs : chars) {
            Integer i = tm.get(chs);
            if (i == null) {
                tm.put(chs, 1);
            } else {
                i++;
                tm.put(chs, i);
            }
        }

        StringBuffer sb = new StringBuffer();

        //方式1:获取键集合遍历
        for (Character key : tm.keySet()) {
            sb.append(key).append("(").append(tm.get(key)).append(")");
        }
        System.out.println("sb--"+sb);
        System.out.println("------------------------");

        StringBuffer sb2 = new StringBuffer();
        //方式2:获取键值对对象集合遍历
        for (Map.Entry<Character, Integer> me : tm.entrySet()) {
            sb2.append(me.getKey()).append("(").append(me.getValue()).append(")");
        }
        System.out.println("sb2--"+sb2);
    }
}

结果:

aababcabcdabcde
sb--a(5)b(4)c(3)d(2)e(1)
------------------------
sb2--a(5)b(4)c(3)d(2)e(1)

统计字符串字母数量图解

HashMap嵌套HashMap练习3

需求2:HashMap嵌套HashMap
Java
JavaSE
格雷福斯 20
影流之主 22
JavaEE
至高之拳 21
落入狂沙 23
先存储元素，然后遍历元素

代码演示

public class TreeMapDemo04 {
    public static void main(String[] args) {
        //创建大集合
        HashMap<String,HashMap<String,Integer>>  bighm = new HashMap<>();

        //创建小集合1
        HashMap<String,Integer> minhm1 = new HashMap<>();
        minhm1.put("格雷福斯",20);
        minhm1.put("影流之主",22);
        //将小集合添加到大集合
        bighm.put("JavaSE",minhm1);

        //创建小集合2
        HashMap<String,Integer> minhm2 = new HashMap<>();
        minhm2.put("至高之拳",21);
        minhm2.put("落日狂沙",23);
        //将小集合添加到大集合
        bighm.put("JavaEE",minhm2);

        //方式1:获取键集合遍历
        for (String key:bighm.keySet()){
            System.out.println(key);
            HashMap<String, Integer> minhm = bighm.get(key);
            for(String minkey:minhm.keySet()){
                System.out.println("\t"+minkey+"\t"+minhm.get(minkey));
            }
        }
        System.out.println("------------------------");
        //方式2:获取键值对对象集合遍历
        for(Map.Entry<String,HashMap<String,Integer>> me:bighm.entrySet()){
            System.out.println(me.getKey());
            HashMap<String, Integer> minhm = me.getValue();
            for(Map.Entry<String, Integer> mingme:minhm.entrySet()){
                System.out.println("\t"+mingme.getKey()+"\t"+mingme.getValue());
            }
        }
    }
}

结果:

JavaSE
	影流之主	22
	格雷福斯	20
JavaEE
	落日狂沙	23
	至高之拳	21
------------------------
JavaSE
	影流之主	22
	格雷福斯	20
JavaEE
	落日狂沙	23
	至高之拳	21

HashMap嵌套ArrayList练习4

需求：假设HashMap集合的元素是ArrayList。有3个。
每一个ArrayList集合的值是字符串。
元素我已经完成，请遍历。
结果：
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过

代码演示

public class TreeMapDemo05 {
    public static void main(String[] args) {
        //创建大集合
        HashMap<String,ArrayList<String>> bighm = new HashMap<>();

        //创建小集合1
        ArrayList<String> al1 = new ArrayList<>();
        al1.add("吕布");
        al1.add("周瑜");
        //将小集合添加大集合
        bighm.put("三国演义",al1);

        //创建集合2
        ArrayList<String> al2 = new ArrayList<>();
        al2.add("令狐冲");
        al2.add("林平之");
        //将小集合添加大集合
        bighm.put("笑傲江湖",al2);

        //创建集合3
        ArrayList<String> al3 = new ArrayList<>();
        al3.add("郭靖");
        al3.add("杨过");
        bighm.put("神雕侠侣",al3);

        //方式1:获取键集合遍历
        for(String key:bighm.keySet()){
            System.out.println(key);
            ArrayList<String> alValue = bighm.get(key);
            for(String valueKey:alValue){
                System.out.println("\t"+valueKey);
            }

        }
        System.out.println("---------------------------------------");
        //方式2:获取键值对对象集合遍历
        for(Map.Entry<String,ArrayList<String>> me:bighm.entrySet()){
            System.out.println(me.getKey());
            ArrayList<String> alList = me.getValue();
            for (String key:alList){
                System.out.println("\t"+key);
            }
        }
    }
}

结果:

神雕侠侣
	郭靖
	杨过
三国演义
	吕布
	周瑜
笑傲江湖
	令狐冲
	林平之
---------------------------------------
神雕侠侣
	郭靖
	杨过
三国演义
	吕布
	周瑜
笑傲江湖
	令狐冲
	林平之

ArrayList嵌套HashMap练习4

ArrayList集合嵌套HashMap集合并遍历。
需求：
假设ArrayList集合的元素是HashMap。有3个。
每一个HashMap集合的键和值都是字符串。
元素我已经完成，请遍历。
结果：
周瑜—小乔
吕布—貂蝉

	 郭靖---黄蓉
	 杨过---小龙女
	
	 令狐冲---任盈盈
	 林平之---岳灵珊

代码演示

public class HashMap06 {
    public static void main(String[] args) {
        //创建大集合
        ArrayList<HashMap<String,String>> bigal = new ArrayList<>();

        //创建小集合
        HashMap<String,String> hm = new HashMap<>();
        hm.put("周瑜","小乔");
        hm.put("吕布","貂蝉");
        //将小集合添加到大集合
        bigal.add(hm);

        //创建小集合
        HashMap<String,String> hm1 = new HashMap<>();
        hm1.put("郭靖","黄蓉");
        hm1.put("杨过","小龙女");
        //将小集合添加到大集合
        bigal.add(hm1);

        //创建小集合
        HashMap<String,String> hm2 = new HashMap<>();
        hm2.put("令狐冲","任盈盈");
        hm2.put("林平之","岳灵珊");
        //将小集合添加到大集合
        bigal.add(hm2);

        //方式1:获取键集合遍历
        for(HashMap<String,String> key:bigal){
            for (String valueKey:key.keySet()){
                System.out.println(valueKey+"----"+key.get(valueKey));
            }
        }
        System.out.println("----------------------------");
        //方式2:获取键值对对象集合
        for(HashMap<String,String> key:bigal){
           for(Map.Entry<String,String> me:key.entrySet()){
               System.out.println(me.getKey()+"----"+me.getValue());
           }
        }
    }
}

结果:

吕布----貂蝉
周瑜----小乔
杨过----小龙女
郭靖----黄蓉
令狐冲----任盈盈
林平之----岳灵珊
----------------------------
吕布----貂蝉
周瑜----小乔
杨过----小龙女
郭靖----黄蓉
令狐冲----任盈盈
林平之----岳灵珊