Map集合案例

1、获取字符串中每一个字母出现的次数。

　　比如"aababcabcdabcde",结果为：a(5)b(4)c(3)d(2)e(1)

分析如下：

package mapexercise;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
/**
 * Created by gao on 15-12-22.
 */
/*
 * 需求 ："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
 *
 */
public class TreeMapDemo {
    public static void main(String[] args) {
        // 定义一个字符串(可以改进为键盘录入)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 定义一个TreeMap集合
        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        //把字符串转换为字符数组
        char[] chs = line.toCharArray();
        //遍历字符数组，得到每一个字符
        for (char ch : chs) {
            //拿刚才得到的字符作为键到集合中去找值，看返回值
            Integer i = tm.get(ch);
            //是null:说明该键不存在，就把该字符作为键，1作为值存储
            if (i == null) {
                tm.put(ch, 1);
            } else {
                i++;
                tm.put(ch, i);
            }
        }
        //定义字符串缓冲区变量
        StringBuffer sb = new StringBuffer();
        //遍历集合，得到键和值，进行按照要求拼接
        Set<Character> set = tm.keySet();
        for (Character key : set) {
            Integer value = tm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        //把字符串缓冲区转换为字符串输出
        String result = sb.toString();
        System.out.println("result:" + result);
    }
}

输出结果：

请输入一个字符串：

aababcabcdabcde

result:a(5)b(4)c(3)d(2)e(1)

2、集合的嵌套遍历

    1）HashMap嵌套HashMap

package mapexercise;
import java.util.HashMap;
import java.util.Set;
/**
 * Created by gao on 15-12-22.
 */
/*
 * HashMap嵌套HashMap
 */
public class HashMapDemo01 {
    public static void main(String[] args) {
        // 创建集合对象
        HashMap<String, HashMap<String, Integer>> hm = new HashMap<String, HashMap<String, Integer>>();
        // 创建班级1集合对象
        HashMap<String, Integer> ghm1 = new HashMap<String, Integer>();
        // 添加元素
        ghm1.put("小明", 22);
        ghm1.put("小红", 23);
        // 把班级1添加到大集合
        hm.put("Grade1", ghm1);
        // 创建班级2集合对象
        HashMap<String, Integer> ghm2 = new HashMap<String, Integer>();
        // 添加元素
        ghm2.put("小青", 28);
        ghm2.put("小宝", 23);
        // 把班级2添加到大集合
        hm.put("Grade2", ghm2);
        //遍历集合
        Set<String> gradeSet = hm.keySet();
        for (String gradeKey : gradeSet) {
            System.out.println(gradeKey + ":");
            HashMap<String, Integer> gradeValue = hm.get(gradeKey);
            Set<String> studentSet = gradeValue.keySet();
            for (String key : studentSet) {
                Integer value = gradeValue.get(key);
                System.out.println(key + "---" + value);
            }
        }
    }
}

输出结果：

Grade2:

小宝---23

小青---28

Grade1:

小明---22

小红---23

　　2）HashMap嵌套ArrayList

package mapexercise;
/**
 * Created by gao on 15-12-22.
 */
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/**
 * HashMap集合的元素是ArrayList
 */
public class HashMapDemo02 {
    public static void main(String[] args) {
        // 创建集合对象
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
        // 创建元素集合1
        ArrayList<String> array1 = new ArrayList<String>();
        array1.add("吕布");
        array1.add("周瑜");
        hm.put("三国演义", array1);
        // 创建元素集合2
        ArrayList<String> array2 = new ArrayList<String>();
        array2.add("令狐冲");
        array2.add("林平之");
        hm.put("笑傲江湖", array2);
        // 创建元素集合3
        ArrayList<String> array3 = new ArrayList<String>();
        array3.add("郭靖");
        array3.add("杨过");
        hm.put("神雕侠侣", array3);
        //遍历集合
        Set<String> set = hm.keySet();
        for (String key : set) {
            System.out.println(key + ":");
            ArrayList<String> value = hm.get(key);
            for (String s : value) {
                System.out.println("\t" + s);
            }
        }
    }
}

输出结果：

三国演义:

吕布

周瑜

笑傲江湖:

令狐冲

林平之

神雕侠侣:

郭靖

杨过

　　3）ArrayList嵌套HashMap

package mapexercise;
/**
 * Created by gao on 15-12-22.
 */
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/**
 * ArrayList集合嵌套HashMap集合并遍历。
 */
public class HashMapDemo03 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
        // 创建元素1
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("周瑜", "小乔");
        hm1.put("吕布", "貂蝉");
        // 把元素添加到array里面
        array.add(hm1);
        // 创建元素2
        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");
        // 把元素添加到array里面
        array.add(hm2);
        // 创建元素3
        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("林平之", "岳灵珊");
        // 把元素添加到array里面
        array.add(hm3);
        // 遍历
        for (HashMap<String, String> hm : array) {
            Set<String> set = hm.keySet();
            for (String key : set) {
                String value = hm.get(key);
                System.out.println(key + "--" + value);
            }
        }
    }
}

输出结果：

周瑜--小乔

吕布--貂蝉

郭靖--黄蓉

杨过--小龙女

令狐冲--任盈盈

林平之--岳灵珊

　　4）HashMap嵌套HashMap嵌套HashMap(三层嵌套)

package cn.itcast_06;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
 * 为了更符合要求：
 *         这次的数据就看成是学生对象。
 *
 * 传智播客
 *         bj    北京校区
 *             jc    基础班
 *                     林青霞        27
 *                     风清扬        30
 *             jy    就业班
 *                     赵雅芝        28
 *                     武鑫        29
 *         sh    上海校区
 *             jc    基础班
 *                     郭美美        20
 *                     犀利哥        22
 *             jy    就业班
 *                     罗玉凤        21
 *                     马征        23
 *         gz    广州校区
 *             jc    基础班
 *                     王力宏        30
 *                     李静磊        32
 *             jy    就业班
 *                     郎朗        31
 *                     柳岩        33
 *         xa    西安校区
 *             jc    基础班
 *                     范冰冰        27
 *                     刘意        30
 *             jy    就业班
 *                     李冰冰        28
 *                     张志豪        29
 */
public class HashMapDemo {
    public static void main(String[] args) {
        // 创建大集合
        HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>();
        // 北京校区数据
        HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>();
        ArrayList<Student> array1 = new ArrayList<Student>();
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        array1.add(s1);
        array1.add(s2);
        ArrayList<Student> array2 = new ArrayList<Student>();
        Student s3 = new Student("赵雅芝", 28);
        Student s4 = new Student("武鑫", 29);
        array2.add(s3);
        array2.add(s4);
        bjCzbkMap.put("基础班", array1);
        bjCzbkMap.put("就业班", array2);
        czbkMap.put("北京校区", bjCzbkMap);
        // 晚上可以自己练习一下
        // 上海校区数据自己做
        // 广州校区数据自己做
        // 西安校区数据
        HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>();
        ArrayList<Student> array3 = new ArrayList<Student>();
        Student s5 = new Student("范冰冰", 27);
        Student s6 = new Student("刘意", 30);
        array3.add(s5);
        array3.add(s6);
        ArrayList<Student> array4 = new ArrayList<Student>();
        Student s7 = new Student("李冰冰", 28);
        Student s8 = new Student("张志豪", 29);
        array4.add(s7);
        array4.add(s8);
        xaCzbkMap.put("基础班", array3);
        xaCzbkMap.put("就业班", array4);
        czbkMap.put("西安校区", xaCzbkMap);
        // 遍历集合
        Set<String> czbkMapSet = czbkMap.keySet();
        for (String czbkMapKey : czbkMapSet) {
            System.out.println(czbkMapKey);
            HashMap<String, ArrayList<Student>> czbkMapValue = czbkMap
                    .get(czbkMapKey);
            Set<String> czbkMapValueSet = czbkMapValue.keySet();
            for (String czbkMapValueKey : czbkMapValueSet) {
                System.out.println("\t" + czbkMapValueKey);
                ArrayList<Student> czbkMapValueValue = czbkMapValue
                        .get(czbkMapValueKey);
                for (Student s : czbkMapValueValue) {
                    System.out.println("\t\t" + s.getName() + "---"
                            + s.getAge());
                }
            }
        }
    }
}

3、模拟斗地主洗牌和发牌（未排序）

package collectiondemos;
import java.util.ArrayList;
import java.util.Collections;
/**
 * Created by gao on 15-12-22.
 */
/*
 * 模拟斗地主洗牌和发牌
 *
 * 分析：
 *         A:创建一个牌盒
 *         B:装牌
 *         C:洗牌
 *         D:发牌
 *         E:看牌
 */
public class PokerDemo01 {
    public static void main(String[] args) {
        // 创建一个牌盒
        ArrayList<String> array = new ArrayList<String>();
        // 装牌
        // 黑桃A,黑桃2,黑桃3,...黑桃K
        // 红桃A,...
        // 梅花A,...
        // 方块A,...
        // 定义一个花色数组
        String[] colors = {"?", "?", "?", "?"};
        // 定义一个点数数组
        String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10",
                "J", "Q", "K"};
        // 装牌
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color.concat(number));
            }
        }
        array.add("小王");
        array.add("大王");
        // 洗牌
        Collections.shuffle(array);
        // 发牌
        ArrayList<String> fengQingYang = new ArrayList<String>();
        ArrayList<String> linQingXia = new ArrayList<String>();
        ArrayList<String> liuYi = new ArrayList<String>();
        ArrayList<String> diPai = new ArrayList<String>();
        for (int x = 0; x < array.size(); x++) {
            if (x >= array.size() - 3) {
                diPai.add(array.get(x));
            } else if (x % 3 == 0) {
                fengQingYang.add(array.get(x));
            } else if (x % 3 == 1) {
                linQingXia.add(array.get(x));
            } else if (x % 3 == 2) {
                liuYi.add(array.get(x));
            }
        }
        // 看牌
        lookPoker("风清扬", fengQingYang);
        lookPoker("林青霞", linQingXia);
        lookPoker("刘意", liuYi);
        lookPoker("底牌", diPai);
    }
    public static void lookPoker(String name, ArrayList<String> array) {
        System.out.print(name + "的牌是：");
        for (String s : array) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

4、模拟斗地主洗牌和发牌（排序）

package cn.itcast_04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
/*
 * 思路：
 *         A:创建一个HashMap集合
 *         B:创建一个ArrayList集合
 *         C:创建花色数组和点数数组
 *         D:从0开始往HashMap里面存储编号，并存储对应的牌
 *        同时往ArrayList里面存储编号即可。
 *      E:洗牌(洗的是编号)
 *      F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
 *      G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
 */
public class PokerDemo {
    public static void main(String[] args) {
        // 创建一个HashMap集合
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        // 创建一个ArrayList集合
        ArrayList<Integer> array = new ArrayList<Integer>();
        // 创建花色数组和点数数组
        // 定义一个花色数组
        String[] colors = { "♠", "♥", "♣", "♦" };
        // 定义一个点数数组
        String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
                "K", "A", "2", };
        // 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                String poker = color.concat(number);
                hm.put(index, poker);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);
        // 洗牌(洗的是编号)
        Collections.shuffle(array);
        // 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
        TreeSet<Integer> fengQingYang = new TreeSet<Integer>();
        TreeSet<Integer> linQingXia = new TreeSet<Integer>();
        TreeSet<Integer> liuYi = new TreeSet<Integer>();
        TreeSet<Integer> diPai = new TreeSet<Integer>();
        for (int x = 0; x < array.size(); x++) {
            if (x >= array.size() - 3) {
                diPai.add(array.get(x));
            } else if (x % 3 == 0) {
                fengQingYang.add(array.get(x));
            } else if (x % 3 == 1) {
                linQingXia.add(array.get(x));
            } else if (x % 3 == 2) {
                liuYi.add(array.get(x));
            }
        }
        // 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
        lookPoker("风清扬", fengQingYang, hm);
        lookPoker("林青霞", linQingXia, hm);
        lookPoker("刘意", liuYi, hm);
        lookPoker("底牌", diPai, hm);
    }
    // 写看牌的功能
    public static void lookPoker(String name, TreeSet<Integer> ts,
            HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是：");
        for (Integer key : ts) {
            String value = hm.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

5、面试题

　　1）HashMap和Hashtable的区别

　　HashMap用来替代Hashtable

　  · Hashtable:线程安全，效率低。不允许null键和null值

　　 ·  HashMap:线程不安全，效率高。允许null键和null值

package mapexercise;
import java.util.HashMap;
import java.util.Hashtable;
/**
 * Created by gao on 15-12-22.
 */
public class HashMapDemo04 {
    public static void main(String[] args) {
        //HashMap<String,String> hm = new HashMap<String, String>(); //{null=hello, java=null, it001=world}
        Hashtable<String,String> ht = new Hashtable<String, String>();
        ht.put("it001","world");
        ht.put(null,"hello"); //NullPointerException
        ht.put("java",null); //NullPointerException
        System.out.println(ht);
    }
}

　　2）List,Set,Map等接口是否都继承自Map接口

　　　　· List，Set不是继承自Map接口，它们继承自Collection接口

　　　　· Map接口本身就是一个顶层接口

　　3）Collection和Collections的区别?

　　　　· Collection：是单列集合的顶层接口，有子接口List和Set。

　　　　· Collections：是针对集合操作的工具类，有对集合进行排序和二分查找的方法

时间： 2024-12-16 22:12:39

Map集合案例的相关文章

java代码中后台向前台传递list或map集合案例

导入jar包 新建一个servert传递map集合 ajax.java代码: 1 package servlet; 2 3 import java.io.IOException; 4 import java.io.PrintWriter; 5 import java.util.ArrayList; 6 import java.util.HashMap; 7 import java.util.List; 8 import java.util.Map; 9 10 import javax.servl

Java基础知识强化之集合框架笔记57：Map集合之HashMap集合（HashMap&lt;Student，String&gt;）的案例

1. HashMap集合(HashMap<Student,String>)的案例 HashMap<Student,String>键:Student      要求:如果两个对象的成员变量值都相同,则为同一个对象.值:String HashMap是最常用的Map集合,它的键值对在存储时要根据键的哈希码来确定值放在哪里. HashMap 中作为键的对象必须重写Object的hashCode()方法和equals()方法 2. 代码示例: (1)Student.java,如下: 1 pa

计算一个字符串的每个字符出现的次数案例——Map集合

其中,字符的包装类是Character;字符串包装类是String: 遍历字符串转换的数组,每个元素都是一个字符,看创建的这个集合有木有,一开始肯定是没有的其实,字符作为key,所以判断的是这个创建的集合中key中有没有这个字符,出现次数作为value,有则++,再重新对这个key的键值对组成的元素进行覆盖赋值: 最后,创建的这个Map集合赋值完了,遍历集合打印输出: 原文地址:https://www.cnblogs.com/wmqiang/p/10663839.html

Collections工具类、Map集合、HashMap、Hashtable(十八)

1.Map集合概述和特点 * A:Map接口概述 * 去重复, * 查看API可以知道, * 将键映射到值的对象, * 一个映射不能包含重复的键, * 每个键最多只能映射到一个值.* B:Map接口和Collection接口的不同 * Map是双列的,Collection是单列的. * Map的键唯一,Collection的子体系Set是唯一的,即不重复. * Map集合的数据结构值针对键有效,跟值无关;Collection集合的数据结构是针对元素有效. 2.Map集合的功能概述 * a:添加功

Java核心API -- 8(Map集合)

1. Map集合 Java.util.Map接口 |--HashMap实现类 |--TreeMap实现类 2. HashMap实现类 Map接口定义的集合又称为查找表,用于存储所谓"Key-Value"键值对.Key可以看成是Value的索引.而往往Key是Value的一部分内容. 1)Key不可以重复,但所保存的Value可以重复. 2)根据内部结构的不同,Map接口有多种实现类,其中常用的有内部为hash表实现的HashMap和内部为排序二叉树实现的TreeMap.同样这样的数据结

第3章 Map集合的嵌套

1.1 Map中嵌套Map1.1.1 案例代码十一 package com.itheima_03; public class Student { private String num; private String name; public Student() { super(); // TODO Auto-generated constructor stub } public Student(String num, String name) { super(); this.num = num;

Map集合、HashMap集合、LinkedHashMap集合、Hashtable集合、Collections工具类和模拟斗地主洗牌和发牌

1.Map集合概述和特点 * A:Map接口概述  * 查看API可以知道:  * 将键映射到值的对象  * 一个映射不能包含重复的键  * 每个键最多只能映射到一个值 * B:Map接口和Collection接口的不同  * Map是双列的,Collection是单列的  * Map的键唯一,Collection的子体系Set是唯一的  * Map集合的数据结构值针对键有效,跟值无关;Collection集合的数据结构是针对元素有效 2.Map集合的功能概述 * A:Map集合的功能概述  *

Map集合框架的使用

Map用于保存具有映射关系的数据(key-vlaue).Map的key不允许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回false Map中包含了一个keySet()方法,用于返回Map所以key组成的Set集合. Map集合与Set集合元素的存储形式很像,如Set接口下有HashSet.LinkedHashSet.SortedSet(接口).TreeSet.EnumSet等实现类和子接口,而Map接口下则有HashMap.LinkedHashMap.SortedMa

Map集合按照value和key进行排序

最近由于特殊的业务需求,需要做相关数据排序,下面就贴出其中的将map集合中按照value或者key进行排序的代码,后面再具体详说. 1 /** 2 * map 集合排序 3 * @param map 4 * @return 5 */ 6 public static <K, V extends Comparable<? super V>> Map<K, V> sortMap(Map<K, V> map) 7 { 8 List<Map.Entry<K