JAVA进阶知识点总结 4-Map HashMap LinkedHashMap Map的遍历方式 斗地主案例

最新推荐文章于 2023-03-03 11:18:36 发布
最新推荐文章于 2023-03-03 11:18:36 发布
阅读量275 收藏
点赞数
分类专栏： java基础知识点 文章标签： java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adamcafe/article/details/88832937
版权

01_第一章：回顾_三种集合的存储方式：

在这里插入图片描述

02_第一章：Map集合_常用方法：

1).Map集合的特点:
1).双列集合–键值对存储；
2).键不能重复–值可以重复；

2).Map的两个子类:
Map的数据结构全部应用在“键”上，值不适用数据结构。
1).HashMap：“键”是哈希表结构；无序的；
2).LinkedHashMap:“键”是链表 + 哈希表结构。有序的。

3).Map的常用方法：
K:key(键)
V:value(值)

1).增、改：
	1).public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
2).删除：
	1).public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，
返回被删除元素的值。
3).查询：
	1).public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

4).对Map的遍历：Map不能直接遍历。
1).键找值：

public class Demo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("美女","杨幂");
        map.put("光头", "徐峥");
        map.put("贵妇","黄渤");
        //遍历方式一：键找值
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + "," + map.get(key));
        }
    }
}

2).获取键值对对象：

public class Demo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("美女","杨幂");
        map.put("光头", "徐峥");
        map.put("贵妇","黄渤");
        //遍历方式二：取出所有的键值对对象
        Set<Map.Entry<String,String>> es =  map.entrySet();
        for (Map.Entry<String, String> e : es) {
            String key = e.getKey();
            String value = e.getValue();
            System.out.println(key + "," + value);
        }
    }
}

3).两种遍历方式的对比：

在这里插入图片描述

03.第一章：Map集合_使用自定义对象做键：

1).自定义对象做键：重写hashCode()和equals()方法；
2).示例代码：

1).Student类:

public class Student {
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

2).测试类:

public class Demo {
    public static void main(String[] args) {
        Map<Student,String> map = new HashMap<>();

        map.put(new Student("徐峥",17), "北京顺义");
        map.put(new Student("黄渤",18),"青岛黑马");
        map.put(new Student("黄渤",18),"上海黑马");//重写hashCode和equals后，验证成功

        //1.键找值
        Set<Student> keys = map.keySet();
        for (Student stu : keys) {
            System.out.println(stu + "|" + map.get(stu));
        }
        System.out.println("-----------------------------------------");
        //2.键值对
        Set<Map.Entry<Student,String>> es = map.entrySet();
        for (Map.Entry<Student, String> e : es) {
            Student key = e.getKey();
            String value = e.getValue();
            System.out.println(key + "%" + value);
        }
    }
}

04.第一章：Map集合_LinkedHashMap：

1).特点：“键”的数据结构：链表 + 哈希表 ，有序的；
2).特点：

public class Demo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("美女", "杨幂");
        map.put("帅哥", "胡瑞");
        map.put("光头", "徐峥");
        map.put("贵妇", "黄渤");
        //1.键找值
        Set<String> keys = map.keySet();
        for (String k : keys) {
            System.out.println(k + "," + map.get(k));
        }

    }
}

05.第一章：Map集合_练习：

1).计算一个字符串中每个字符出现次数:
2).算法分析：

在这里插入图片描述
3).示例代码：

public class Demo {
    public static void main(String[] args) {
        //计算一个字符串中每个字符出现次数
        String str = "jfjfuduiomflvmczkaavmfsbvajfk";
        //步骤：
        //1.定义Map集合，存储结果
        Map<Character, Integer> map = new HashMap<>();
        //2.遍历字符串，取出每个字符
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //3.用这个字符做“键"，到集合中找：值
            Integer value = map.get(c);
            if(value == null){
                //      没找到：put(字符，1)
                map.put(c, 1);
            }else{//      找到：put(字符,值 + 1);
                map.put(c,value + 1);
            }
        }

    //4.循环结束
    //5.验证，遍历Map
    Set<Character> keys = map.keySet();
    for (Character c : keys) {
        System.out.println(c + " = " + map.get(c));
    }
    }
}

06.怎样选择集合：

1).单列：
	1).有序：常用：ArrayList
		1).经常查询，很少增、删：ArrayList
		2).经常增删：LinkedList
	2).无序：常用:HashSet

2).双列：当需要存储少数的几种对象，并希望通过一个名字来获取某个对象时

3).HashMap

07.第二章：可变参数：

1).当我们的方法中需要某种类的多个参数时，可以定义为：可变参数：
2).例如:

public class Demo {
    public static void main(String[] args) {
        int a1 = sum();//编译后：int a1 = sum(new int[0]);
    int a2 = sum(2,3,24,3242,2432,5,44,1,42,51,4);//编译后：sum(new int[]{2,3,24,3242,2432,5,44,1,42,51,4});
        int[] arr = {1,43,24,32,542};
        int a3 = sum(arr);
    }
    public static int sum(int ... a) {//sum(int[] a)
        int s = 0;
        for (int i = 0; i < a.length; i++) {
            s = s + a[i];
        }
        return s;
    }
}

3).其他说明：
1).在一个方法的形参列表中最多只能有一个“可变参数”；而且可变参数必须要位于“形参列表”的末尾。

public class Demo {
    public static void main(String[] args) {
                
        fun("黄渤",1.7);
        fun("黄渤",1.7,14324,32,432,43,25,324,32,542,432,542,43,24,32);
        int[] arr2 = {1,2,43,24};
        fun("黄渤",1.7,arr2);
        
    }

    
    public static void fun(String s,double  d,int ... arr){
		//....
    }
}

2).可变参数可以是“任何类型”

08.第二章：Debug调试：

1).在需要断点的代码位置左侧，鼠标单击，出现一个小红点:
在这里插入图片描述

2).在代码视图，右键，Debug运行：
在这里插入图片描述

3).运行后，IDEA会在断点处暂停代码的执行，等待我们的指令：
在这里插入图片描述

4):单步执行：

F8：单步执行，如果语遇到方法调用，不会进入方法体，直接将方法执行完毕。
或者：
F7:单步执行，如果遇到方法调用，会进入方法体。

F9:结束单步执行，会继续运行后续的代码直到遇到下一个断点，或者程序结束。

09.第三章：综合案例_斗地主洗牌发牌：

1).分析：
1).封装一副牌–Map
2).创建一个存储编号的集合
3).洗牌–洗编号
4).发牌–发编号
5).看牌–用编号到Map中将对应的牌面找出
2).对牌排序的算法：

在这里插入图片描述
1 封装_副牌
2 创建一个存储编号的集合
3 洗牌_洗编号
4 发牌_发编号
5 看牌_用编号到Map中将对应的牌面找出

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

========================================================================
学习目标总结：
01.能够说出Map集合特点
1).双列集合–键值对存储；
2)."键"不能重复；值可以重复；
02.使用Map集合添加方法保存数据
Map<String,String> map = new HashMap<>();
map.put(“美女”,“杨幂”);
…

03.使用”键找值”的方式遍历Map集合

Set<String> keys = map.keySet();
for(String k : keys){
	System.out.println(k + "," + map.get(k));
}

04.使用”键值对”的方式遍历Map集合

Set<Map.Entry<String,String>> es = map.entrySet();
for(Map.Entry<String,String> e : es){
	String key = e.getKey();
	String value = e.getValue();
	....
}

05.能够使用HashMap存储自定义键值对的数据
1).自定义对象做键:要重写hashCode()和equals()
2).

public static void main(String[] args) {
    Map<Student,String> map = new HashMap<>();

    map.put(new Student("徐峥",17), "北京顺义");
    map.put(new Student("黄渤",18),"青岛黑马");
    map.put(new Student("黄渤",18),"上海黑马");
//1.键找值
Set<Student> keys = map.keySet();
for (Student stu : keys) {
    System.out.println(stu + "|" + map.get(stu));
}
System.out.println("-----------------------------------------");
//2.键值对

    Set<Map.Entry<Student,String>> es = map.entrySet();
    for (Map.Entry<Student, String> e : es) {
        Student key = e.getKey();
        String value = e.getValue();
        System.out.println(key + "%" + value);
    }
}

06.能够使用可变参数
public static void show(int … nums){//编译后：show(int[] nums)
//nums就是一个数组
}
07.能够使用HashMap编写斗地主洗牌发牌案例
1).封装牌面
1).map
2).两个数组
3).索引变量；
4).开始封装
2).创建一个编号集合
3).洗牌–洗编号
4).发牌–发编号
5).看牌–将编号转换为Map中的牌面

AdamCafe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java HashMap三种循环遍历方式及其性能对比实例分析
08-25
主要介绍了Java HashMap三种循环遍历方式及其性能对比,结合具体实例形式分析了Java HashMap三种循环遍历方式的实现方法、运行效率及性能优劣,需要的朋友可以参考下
Java集合系列之LinkedHashMap
m0_69804655的博客
02-25 855
其实 LinkedHashMap 几乎和 HashMap 一样：从技术上来说，不同的是它定义了一个 Entry header，这个 header 不是放在 Table 里，它是额外独立出来的。LinkedHashMap 通过继承 hashMap 中的 Entry,并添加两个属性 Entry before,after,和 header 结合起来组成一个双向链表，来实现按插入顺序或访问顺序排序。
Java——Map集合
挣钱买房买车的博客
07-26 2004
Java——Map集合详述
HashMap中修改键的情况
m0_63480655的博客
03-03 1805
HashMap
HashMap存储自定义类型值,LinkedHashMap,HashTable,Debug
guibar的博客
12-08 277
HashMap存储自定义类型键值 当给HashMap中存储自定义对象时，如果自定义对象作为key存在，这时要保证对象的唯一性，必须重写对象的hashCode和equals方法 如果要保证map中存储元素的顺序。主要体现在key值，可以使用java.util.LinkedHashMap集合来存放 ​ 练习：每位学生(姓名，年龄) 都有自己的家庭地址，学生作为键key值，家庭地址作为value值 ​ 注意：同名同年龄的学生为同一学生 package com.work; import java.util.
用debug看HashMap
weixin_44742328的博客
08-23 752
一直都是对HashMap的底层及扩容原理都没有很好的理解，所以就决定重新对HashMap的底层原理重新来梳理梳理。 HashMap这个扩容原理真的是众说纷纭，感觉就没有一个较为清楚，原来只知道的HashMap当链表的长度大于8 并且数组的长度大于64 链表才会转换成红黑树。但是一直没有去自我验证，今天我就来验证验证，此次我们使用的是JDK1.8： /** * @author acoffee * @create 2021-08-23 11:02 */ public class Test { pu
Java HashMap 如何正确遍历并删除元素的方法小结
08-25
主要介绍了Java HashMap 如何正确遍历并删除元素的方法小结,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java HashMap的三种遍历方法及优缺点含示例
最新发布
01-24
HashMap是一种基于哈希表的Map接口实现，主要用于存储键值对。它允许空值和空键。其主要特点是通过键的哈希值存储值，并提供了添加、获取和操作存储值的方法。 HashMap的底层数据结构是由数组和链表组成的。数组是...
java中Map集合的常用遍历方法及HashMap的应用实例
06-15
Map的遍历大体有3种： 1、遍历Map.entrySet()：它的每一个元素都是Map.Entry对象，这个对象中， 放着的就是Map中的某一对key-value； 2、遍历Map.keySet()：它是Map中key值的集合，我们可以通过遍历这个集合来 ...
java提高篇（二三）-----HashMap详解
09-01
HashMap基于哈希表的 Map 接口的实现，本篇文章主要讲诉了java中HashMap，有兴趣的可以了解一下。
集合综合案例：斗地主
Luis
06-13 246
按照斗地主的规则，完成洗牌发牌的动作。 具体规则 组装54张扑克牌将 54张牌顺序打乱 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。 查看三人各自手中的牌（按照牌的大小排序）、底牌 规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3 需求分析 准备牌： 完成数字与纸牌的映射关系： 使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。 洗牌： 通过数字完成洗牌发牌 发牌： 将每个
JAVA实例之斗地主（基于LinkedHashMap的发牌自动排序）
TOPic666的博客
08-06 123
JAVA实例之斗地主（基于LinkedHashMap的发牌自动排序） 代码 package com.Map; import java.util.ArrayList; import java.util.Collections; import java.util.LinkedHashMap; import java.util.Set; public class doudizhu { public static void main(String[] args) { //准备牌
LinkedHashMap 访问顺序方式遍历
热门推荐
qq_35811626的博客
03-07 3万+
LinkedHashMap 支持两种遍历方式 LinkedHashMap是通过比HashMap多了一个双向链表实现的有序。 1.按照插入顺序遍历 2.按照访问顺序遍历 按照访问顺序遍历时，每次访问完map中的元素后，会将该元素置入map的最后一位， 例如：LinkedHashMap&lt;String, Integer&gt; map = new LinkedHashMap&lt...
[Java基础要义]HashMap、LinkedHashMap元素遍历机制探讨
我的程序人生(亦山札记)
01-22 2万+
Map作为键值对Entry的的容器，对其内部 键值对Entry 的遍历总归是要有一个顺序的。       本文重点讨论HashMap及其子类LinkedHashMap的遍历机制，总结出两者的特点和适用情况。 1.HashMap的遍历机制               HashMap提供了两个遍历访问其内部元素Entry的接口：               1.       Set
集合与遍历 Debug (Collection工具类,HashSet,Map)
snack_TC_dora的博客
07-17 197
一。比较器     作用：比较大小的     Collections.sort(List&lt;?&gt; list)     如果调用该功能，那么我们需要注意，     这个功能 采用默认的比较规则进行对象之间的比较排序。     什么是默认的规则呢，这就要求集合中的元素类型     去实现一个叫做Comparable接口，其实是为了实现里面     compareTo()功能，这个功能中就定...
java容器系列五（LinkedHashMap详解）
lc138544的博客
12-16 426
参考博文：https://blog.csdn.net/future234/article/details/80704005 一，LinkedHashMap概述 1，允许key为null,允许value为null 2,与HashMap最大区别：默认情况下，遍历顺序就是元素插入顺序。 LinkedHashMap的Entry static class Entry&lt;K,V&gt; extends H...
LinkedHashMap for循环遍历
keep12moving的博客
05-15 7217
Map<String, Future<String[]>> futures = new LinkedHashMap<String, Future<String[]>>(); futures.put(Line_Num, executorService.submit(api)); for (Map.Entry<String, Future&lt...
⼿写⼀下HashMap的⼏种遍历⽅式 - Entry 遍历 - keySet 遍历 - foreach遍历 - keySet foreach遍历
07-27
HashMap的几种遍历方式如下： 1. Entry遍历：使用entrySet()方法可以同时遍历Map里面的Key和Value。可以通过迭代器或者foreach循环来实现。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用entrySet()方法遍历 for (Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); // 处理key和value } ``` 2. keySet遍历：使用keySet()方法可以遍历Map里面的Key。可以通过迭代器或者foreach循环来实现。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用keySet()方法遍历 for (String key : map.keySet()) { Integer value = map.get(key); // 处理key和value } ``` 3. foreach遍历：在JDK8及以上版本中，可以直接使用foreach循环来遍历HashMap的键值对。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用foreach遍历 map.forEach((key, value) -> { // 处理key和value }); ``` 4. keySet foreach遍历：在JDK8及以上版本中，可以使用keySet()方法获取键的集合，然后使用foreach循环遍历。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用keySet foreach遍历 for (String key : map.keySet()) { Integer value = map.get(key); // 处理key和value } ``` 以上是HashMap的几种常见遍历方式。根据具体的需求，可以选择适合的遍历方式来操作HashMap的键值对。 #### 引用[.reference_title] - *1* *3* [Java - 关于HashMap通过keySet遍历kv的二次调用问题](https://blog.csdn.net/Zong_0915/article/details/120905738)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [HashMap的七种遍历方式](https://blog.csdn.net/maojian_ohhey/article/details/115431835)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值