HashMap TreeMap LinkedHashMap

HashMap 键是Student值 是String 的案例
  键是Student, 如果不重写,则键肯定不一致, 所以需要重写键对象的hashcode() equals()

LinkedHashMap 底层是链表,怎么存怎么取

TreeMap
  键如果是自定义对象,则该对象必须有比较的功能

public class demon7_hashmapHashMap {
    /*
     * 嵌套HashMap
     *  键是学生 值是学生归属地
     *  有多个班级  键是班级   值是班级号
     */
    public static void main(String[] args) {
        HashMap<Student, String> hm1 = new HashMap<>();
        hm1.put(new Student("张三",23), "北京");
        hm1.put(new Student("李四",24), "北京");
        hm1.put(new Student("王五",25), "上海");
        hm1.put(new Student("赵柳",26), "广州");
        //System.out.println(hm1);

        HashMap<Student, String> hm2 = new HashMap<>();
        hm2.put(new Student("唐僧",1023), "北京");
        hm2.put(new Student("悟空",1024), "北京");
        hm2.put(new Student("八戒",1025), "上海");
        hm2.put(new Student("沙僧",926), "广州");
        //System.out.println(hm2);

        HashMap<HashMap<Student, String>, Integer> grade = new HashMap<>();
        grade.put(hm1, 88);
        grade.put(hm2, 89);

        for (HashMap<Student, String> hm : grade.keySet()) {
            Integer value = grade.get(hm);
            for (Student s : hm.keySet()) {
                String addr = hm.get(s);

                System.out.println(s + "..." + addr + "..." + value);
            }
        }
    }

}
public class test1 {
    /*
     * 需求:统计字符串中每个字符出现的次数
     */
    public static void main(String[] args) {
        String str = "aaaabbbcccccccccc";
        char[] arr = str.toCharArray();
        HashMap<Character,Integer> hm = new HashMap<>();
        for (char c : arr) {
            /*if (!hm.containsKey(c)){
                hm.put(c, 1);
            }else {
                hm.put(c, hm.get(c)+1);
            }*/
            hm.put(c, !hm.containsKey(c)? 1 : hm.get(c)+1 );
        }
        for (Character key : hm.keySet()) {
            System.out.println(key + " = " + hm.get(key));
        }
        System.out.println(hm.get(‘a‘));
    }

}
public class test2_dizhu2 {

    public static void main(String[] args) {
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] color = {"红","黑","梅","花"};

        HashMap<Integer, String> hm = new HashMap<>();   //存贮索引和牌

        ArrayList<Integer> list = new ArrayList<>();  // 存索引
        int index= 0 ;
        for (String s1 : color) {
            for (String s2 : num) {
                hm.put(index, s1.concat(s2));
                list.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        list.add(index);
        index++;
        hm.put(index, "大王");
        list.add(index);
        Collections.shuffle(list);     //随机打乱顺序,相当于洗牌

        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        TreeSet<Integer> me = new TreeSet<>();
        TreeSet<Integer> dipai= new TreeSet<>();
        for (int i = 0; i < list.size(); i++) {    //发牌  存 牌的索引
            if (i>=list.size()-3) {
                dipai.add(list.get(i));
            } else if (i%3==0) {
                gaojin.add(list.get(i));
            }else if (i%3==1) {
                longwu.add(list.get(i));
            }else {
                me.add(list.get(i));
            }
        }
        lookPoker(hm, gaojin, "高进");
        lookPoker(hm, longwu, "龙武");
        lookPoker(hm, me, "xxx");
        lookPoker(hm, dipai, "底牌");
    }
    //看牌的参数列表:  hashMap
    public static void lookPoker(HashMap<Integer, String> hm, TreeSet<Integer> ts, String name) {
        System.out.print(name + "的牌是:");
        for (Integer i : ts) { //  ts代表双列集合的键的集合
            System.out.print(hm.get(i)+ " ");
        }
        System.out.println();
    }

}
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class test3 {

    /**
     * * A:案例演示
     * 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
     *
     *  分析:
     * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
     * 2,洗牌
     * 3,发牌
     * 4,看牌
     */
    public static void main(String[] args) {
        //1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] color = {"红桃","黑桃","方片","梅花"};
        HashMap<Integer, String> hm = new HashMap<>();                    //存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<>();                    //存储索引
        int index = 0;

        //拼接扑克牌并索引和扑克牌存储在hm中
        for(String s1 : num) {                                            //获取数字
            for(String s2 : color) {                                    //获取颜色
                hm.put(index, s2.concat(s1));
                list.add(index);                                        //将索引0到51添加到list集合中
                index++;
            }
        }
        //将小王添加到双列集合中
        hm.put(index, "小王");
        list.add(index);                                                //将52索引添加到集合中
        index++;
        hm.put(index, "大王");
        list.add(index);                                                //将53索引添加到集合中

        //2,洗牌
        Collections.shuffle(list);
        //3,发牌
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        TreeSet<Integer> me = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();

        for(int i = 0; i < list.size(); i++) {
            if(i >= list.size() - 3) {
                dipai.add(list.get(i));                            //将三张底牌存储在底牌集合中
            }else if(i % 3 == 0) {
                gaojin.add(list.get(i));
            }else if(i % 3 == 1) {
                longwu.add(list.get(i));
            }else {
                me.add(list.get(i));
            }
        }

        //看牌
        lookPoker(hm, gaojin, "高进");
        lookPoker(hm, longwu, "龙五");
        lookPoker(hm, me, "xxx");
        lookPoker(hm, dipai, "底牌");
    }
    /*
     * 看牌
     * 1,返回值类型void
     * 2,参数列表HashMap,TreeSet,String name
     */
    public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts ,String name) {
        System.out.print(name + "的牌是:");
        for(Integer i : ts) {                        //i代表双列集合中的每一个键
            System.out.print(hm.get(i) + " ");
        }
        System.out.println();
    }
}

原文地址:https://www.cnblogs.com/yaobiluo/p/11306352.html

时间: 2024-10-09 21:56:55

HashMap TreeMap LinkedHashMap的相关文章

HashTable HashMap TreeMap LinkedHashMap 区别

参考:http://blog.csdn.net/xiaodifa995455120/article/details/7277441 http://www.apkbus.com/forum.php?mod=viewthread&tid=52426 Hashmap 是一个 最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度.HashMap最多只允许一条记录的键为Null;允许多条记录的值为Null;HashMap不支持线程的同步,即任一时刻可以有多个

深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap 【中】

LinkedHashMap - 有序的 HashMap 我们之前讲过的 HashMap 的性能表现非常不错,因此使用的非常广泛.但是它有一个非常大的缺点,就是它内部的元素都是无序的.如果在遍历 map 的时候, 我们希望元素能够保持它被put进去时候的顺序,或者是元素被访问的先后顺序,就不得不使用 LinkedHashMap. LinkdHashMap 继承了 HashMap,因此,它具备了 HashMap 的优良特性-高性能.在HashMap 的基础上, LinkedHashMap 又在内部维

HashMap Hashtable LinkedHashMap 和TreeMap

java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap. Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复. HashMap是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度,遍历时,取得数据的顺序是完全随机的. HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;

深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap 【上】

前言 Map 是非常常用的一种数据接口.在 Java 中,提供了成熟的 Map 实现. 图 1 最主要的实现类有 Hashtable.HashMap.LinkedHashMap和 TreeMap.在 HashTable 的子类中,还有 Properties的实现.Properties 是专门读取配置文件的类,我们会在稍后介绍.这里首先值得关注的是 HashMap 和 HashTable 两套不同的实现,两者都实现了 Map 接口.从表面上看,并没有多大差别,但是在内部实现上却有些微小的细节. 首

HashMap与LinkedHashMap的区别

HashMap与LinkedHashMap的区别: 一般情况下,我们用的最多的是HashMap,在Map 中插入.删除和定位元素,HashMap 是最好的选择.但如果您要按自然顺序或自定义顺序遍历键,那么TreeMap会更好.如果需要输出的顺序和输入的相同,那么用LinkedHashMap 可以实现,它还可以按读取顺序来排列.工作流当中使用LinkedHashMap的好处是可以按照遍历集合的顺序来存值排列.

HashMap和LinkedHashMap的比较使用

由于现在项目中用到了LinkedHashMap,并不是太熟悉就到网上搜了一下. import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; public class TestLinkedHashMap {   public static void main(String args[])   {    System.out.println("**

从 Map 到 HashMap 到 LinkedHashMap

java 从 Map 到 HashMap 到 LinkedHashMap Map 接口 Map 是 java 容器的基础接口,提供按照 kv 方式存取数据的能力.Map 定义了一系列的操作,以及一个内部接口 Map.Entry ,Entry 表示一个 kv 对 : int size() boolean isEmpty() boolean containKey(Object) boolean containValue(Object) V get(Object) V put(K, V) V remo

Java的HashMap与LinkedHashMap异同

 一句话概括的说:两者最大的不同就是,HashMap不保证put进去的数据的顺序:而LinkedHashMap则保证put进去的数据的顺序.换句话也就是说,HashMap添加进去的数据顺序和遍历时的数据顺序不一定:而LinkedHashMap则保证添加时数据顺序是什么,遍历时数据顺序是什么. 例如,假如在HashMap中依次.顺序添加元素:1,2,3,4,5,在遍历HashMap时输出的顺序可能是:3,2,1,4,5. 但是,假如在LinkedHashMap中依次.顺序添加元素:1,2,3,

Java HashMap与LinkedHashMap的区别

HashMap与LinkedHashMap是Map接口的两个实现类,它们最大的区别就是HashMap的元素是无序存放的,LinkedHashMap的元素是有序存放的,示例: Map<String, Integer> hashMap = new HashMap<String, Integer>(); Map<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>(); for (i