day04 java学习

最新推荐文章于 2024-08-03 19:20:31 发布
最新推荐文章于 2024-08-03 19:20:31 发布
阅读量102 收藏
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24573381/article/details/115563686
版权

第一章 Map集合 

1.1 概述

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。 

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

  • Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
  • Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
  • Collection中的集合称为单列集合，Map中的集合称为双列集合。
  • 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map集合概述

java. util .Map<k, v>集合
Mop集合的特点:
1.Map集合是个双列集合,一个元素包含两个值(一个key, 一个value)
2.Map集合中的元素, key和value的数据类型可以相同，也可以不同
3. Map集合中的元素, key是不允许重复的，value是可以重复的
4.Map集合中的元素，key和value是一一对应

1.2 Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

  • HashMap<k,v>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
  • LinkedHashMap<k,v>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

java. util.HashMap<k,v>集合implements Map<k, v>接口
HashMap集合的特点:
1. HashMap集合底层是哈希表:查询的速度特别的快
           JDK1.8之前:数组+单向链表
           JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8) :提高查询的速度
2. HashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
java. util.LinkedHashMap<k,v>集合extends HashMap<k, v>集合
LinkedHashMap的特点:
1. LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2. L inkedHashMap集合是一个有序的集合 ,存储元素和取出元素的顺序是一致的

此段引用https://blog.csdn.net/woshimaxiao1/article/details/83661464

一、什么是哈希表

在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能

数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)

线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)

二叉树：对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)。

哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下（后面会探讨下哈希冲突的情况），仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。

我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式），而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。

比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。
　　
这个函数可以简单描述为：存储位置 = f(关键字) ，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。举个例子，比如我们要在哈希表中执行插入操作：
插入过程如下图所示

查找操作同理，先通过哈希函数计算出实际存储地址，然后从数组中对应地址取出即可。

哈希冲突

然而万事无完美，如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。

二、HashMap的实现原理

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。（其实所谓Map其实就是保存了两个对象之间的映射关系的一种集合）

所以，HashMap的总体结构如下：

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • boolean containsKey(Object key) 判断集合中是否包含指定的键。
  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对 对象的集合(Set集合)。

Map接口的方法演示：

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

public class Demo01Map {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
        show04();

    }

    /*
            boolean containsKey(Object key) 判断集合中是否包含指定的键。
            包含返回true,不包含返回false
         */
    private static void show04() {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("佩奇",168);
        map.put("苏西",165);
        map.put("瑞贝卡",178);

        boolean b1 = map.containsKey("佩奇");
        System.out.println("b1:"+b1);//b1:true

        boolean b2 = map.containsKey("艾米丽");
        System.out.println("b2:"+b2);//b2:false
    }
    /*
        public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
            返回值:
                key存在,返回对应的value值
                key不存在,返回null
     */
    private static void show03() {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("佩奇",168);
        map.put("苏西",165);
        map.put("瑞贝卡",178);

        Integer v1 = map.get("佩奇");
        System.out.println("v1:"+v1);//v1:165

        Integer v2 = map.get("艾米丽");
        System.out.println("v2:"+v2);//v2:null
    }

    /*
        public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
            返回值:V
                key存在,v返回被删除的值
                key不存在,v返回null
     */
    private static void show02() {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("佩奇",168);
        map.put("苏西",165);
        map.put("瑞贝卡",178);
        System.out.println(map);//{苏西=165, 瑞贝卡=178, 佩奇=168}

        Integer v1 = map.remove("瑞贝卡");
        System.out.println("v1:"+v1);//v1:178

        System.out.println(map);//{苏西=165, 佩奇=168}

        //int v2 = map.remove("艾米丽");//自动拆箱  NullPointerException
        Integer v2 = map.remove("");
        System.out.println("v2:"+v2);//v2:null

        System.out.println(map);//{苏西=165, 佩奇=168}
    }

    /*
        public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
            返回值:v
                存储键值对的时候,key不重复,返回值V是null
                存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
     */
    private static void show01() {
        //创建Map集合对象,多态
        Map<String,String> map = new HashMap<>();

        String v1 = map.put("小猪", "佩奇");
        System.out.println("v1:"+v1);//v1:null

        String v2 = map.put("小猪", "苏西");
        System.out.println("v2:"+v2);//v2:佩奇

        System.out.println(map);//{小猪=佩奇, 小羊=苏西}

        map.put("小狗","丹尼");
        map.put("小兔","瑞贝卡");
        map.put("小象","艾米丽");
        System.out.println(map);//{小猪=佩奇, 小羊=苏西, 小狗=丹尼, 小象=艾米丽, 小兔=瑞贝卡}
    }
}

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

  1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
  2. 遍历键的Set集合，得到每一个键。
  3. 根据键，获取键所对应的值。方法提示:get(K key)
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    Map集合的第一种遍历方式:通过键找值的方式
    Map集合中的方法:
         Set<K> keySet() 返回此映射中包含的键的Set视图。
    实现步骤:
        1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
        2.遍历set集合,获取Map集合中的每一个key
        3.通过Map集合中的方法get(key),通过key找到value
 */
public class Demo02KeySet {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("佩奇",168);
        map.put("苏西",165);
        map.put("瑞贝卡",178);

        //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
        Set<String> set = map.keySet();

        //2.遍历set集合,获取Map集合中的每一个key
        //使用迭代器遍历Set集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String key = it.next();
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
        System.out.println("-------------------");
        //使用增强for遍历Set集合
        for(String key : set){
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
        System.out.println("-------------------");
        //使用增强for遍历Set集合
        for(String key : map.keySet()){
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

1.5 Entry键值对对象

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

  • public K getKey()：获取Entry对象中的键。
  • public V getValue()：获取Entry对象中的值。

Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

  1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。

  2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

  3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    Map集合遍历的第二种方式:使用Entry对象遍历

    Map集合中的方法:
        Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。

    实现步骤:
        1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
        2.遍历Set集合,获取每一个Entry对象
        3.使用Entry对象中的方法getKey()和getValue()获取键与值
 */
public class Demo03EntrySet {
    public static void main(String[] args) {
        //创建map集合
        Map<String, Integer> map = new HashMap<>();
        map.put("佩奇", 168);
        map.put("苏西", 165);
        map.put("瑞贝卡", 178);
        // 1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //2.遍历Set集合,获取每一个Entry对象
        //使用迭代器遍历set集合
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("-----------------------");
        for (Map.Entry<String, Integer> entry : set) {
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);

        }
    }
}

1.6 HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
    HashMap存储自定义类型键值
    Map集合保证key是唯一的:
        作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
 */
public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        //show01();
        show02();
    }

    /*
        HashMap存储自定义类型键值
        key:Person类型
            Person类就必须重写hashCode方法和equals方法,以保证key唯一
        value:String类型
            可以重复
     */
    private static void show02() {
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("佩奇",18),"小猪");
        map.put(new Person("苏西",18),"小羊");
        map.put(new Person("瑞贝卡",18),"小兔");
        map.put(new Person("佩德罗",18),"小马");
        map.put(new Person("苏西",18),"小猪");
        map.put(new Person("艾米丽",15),"小象");

        //使用entrySet和增强for遍历Map集合
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "-->" + value);

        }

    }
    /*
           HashMap存储自定义类型键值
           key:String类型
               String类型就必须重写hashCode方法和equals方法,以保证key唯一
           value:Person类型
               可以重复(同名同年龄的人可以看做是一个人)
        */
    /*private static void show01() {
        //创建HashMap集合
        HashMap<String, Person> map = new HashMap<>();
        //往集合中添加元素
        map.put("小猪",new Person("佩奇",18));
        map.put("小羊",new Person("苏西",18));
        map.put("小兔",new Person("瑞贝卡",18));
        map.put("小马",new Person("佩德罗",18));
        map.put("小猪",new Person("乔治",15));
        map.put("小象",new Person("艾米丽",15));
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key+"-->"+value);
        }
    }*/
    /*
    小猪-->Person{name='乔治', age=15}
    小羊-->Person{name='苏西', age=18}
    小马-->Person{name='佩德罗', age=18}
    小象-->Person{name='艾米丽', age=15}
    小兔-->Person{name='瑞贝卡', age=18}
     */
}
import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "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) {
        this.age = age;
    }

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

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

 1.7 LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

import java.util.HashMap;
import java.util.LinkedHashMap;

/*
    java.util.LinkedHashMap<K,V> entends HashMap<K,V>
    Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
    底层原理:
        哈希表+链表(记录元素的顺序)
 */
public class Demo01LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("b","b");
        map.put("a","d");
        System.out.println(map);// key不允许重复,无序 {a=d, b=b, c=c}

        LinkedHashMap<String, String> linked = new LinkedHashMap<>();
        linked.put("a","a");
        linked.put("c","c");
        linked.put("b","b");
        linked.put("a","d");
        System.out.println(linked);// key不允许重复,有序 {a=d, c=c, b=b}

    }
}

1.8 Hashtable集合

/*
java.util.Hashtable<K,V>集合 implements Map<K,V>接口

Hashtable:底层也是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢
HashMap:底层是一个哈希表,是一个线程不安全的集合,是多线程的集合,速度快

HashMap集合(之前学的所有的集合):可以存储null值,null键
Hashtable集合,不能存储null值,null键

Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了
Hashtable的子类Properties依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合
*/

java.util.Hashtable<K,V>集合 implements Map<K,V>接口

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

/*
    练习:
        计算一个字符串中每个字符出现次数

    分析:
        1.使用Scanner获取用户输入的字符串
        2.创建Map集合,key是字符串中的字符,value是字符的个数
        3.遍历字符串,获取每一个字符
        4.使用获取到的字符,去Map集合判断key是否存在
            key存在:
                通过字符(key),获取value(字符个数)
                value++
                put(key,value)把新的value存储到Map集合中
            key不存在:
                put(key,1)
        5.遍历Map集合,输出结果
 */
public class Demo03MapTest {
    public static void main(String[] args) {
        //1.使用Scanner获取用户输入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        //next()从遇到第一个有效字符（非空格、换行符）开始扫描，遇到第一个分隔符或结束符（空格’ ‘或者换行符 ‘\n’）时结束。
        // nextLine()则是扫描剩下的所有字符串知道遇到回车为止
        String str = sc.next();
        //2.创建Map集合,key是字符串中的字符,value是字符的个数
        HashMap<Character,Integer> map = new HashMap<>();
        //3.遍历字符串,获取每一个字符
        for(char c :str.toCharArray()){
            //4.使用获取到的字符,去Map集合判断key是否存在
            if(map.containsKey(c)){
                //key存在
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }else{
                //key不存在
                map.put(c,1);
            }
        }
        //5.遍历Map集合,输出结果
        for(Character key :map.keySet()){
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
    }

}

第二章 补充知识点

2.1JDK9对集合添加的优化 静态of方法

import java.util.List;
import java.util.Map;
import java.util.Set;

/*
    JDK9的新特性:
        List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素
        static <E> List<E> of​(E... elements)
        使用前提:
            当集合中存储的元素的个数已经确定了,不在改变时使用
     注意:
        1.of方法只适用于List接口,Set接口,Map接口,不适用于接接口的实现类
        2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
        3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常
 */
public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "a", "c", "d");
        System.out.println(list);//[a, b, a, c, d]
        //list.add("w");//UnsupportedOperationException:不支持操作异常

        //Set<String> set = Set.of("a", "b", "a", "c", "d");//IllegalArgumentException:非法参数异常,有重复的元素
        Set<String> set = Set.of("a", "b", "c", "d");
        System.out.println(set);
        //set.add("w");//UnsupportedOperationException:不支持操作异常

        //Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三",19);
        // IllegalArgumentException:非法参数异常,有重复的元素
        Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);
        System.out.println(map); //{王五=20, 李四=19, 张三=18}
        //map.put("赵四",30);//UnsupportedOperationException:不支持操作异常
    }
}

2.2Debug追踪

使用IDEA的断点调试功能，查看程序的运行过程

  1. 在有效代码行，点击行号右边的空白区域，设置断点，程序执行到断点将停止，我们可以手动来运行程序
/*
Debug调试程序
    可以让代码逐行运行，查看代码执行的过程，调试程序中出现的Bug
使用方式：
    在行号的右边，鼠标左键单击，添加断点（每个方法的第一行，哪里有Bug添加到哪里)
    右键，选择Debug执行程序
    程序就会停留在添加的第一个断点处
执行程序：
    F8:逐行执行程序
    F7:进入到方法中
    shift+F8:跳出方法
    F9:跳到下一个断点，如果没有下一个断点，那么就结束程序
    ctrl+F2:退出Debug模式
    Console:切换到控制台
 */
public class Demo01Debug {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
        }
        print();
    }
    private static void print(){
        System.out.println("hello word");
        System.out.println("hello word");
        System.out.println("hello word");
        System.out.println("hello word");
    }

}

第三章 案例分析

3.1案例介绍

按照斗地主的规则，完成洗牌发牌的动作

具体规则： 

  1. 组装54张扑克牌将
  2. 54张牌顺序打乱
  3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

3.2 案例需求分析 

准备牌： 
完成数字与纸牌的映射关系： 
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。 
洗牌： 
通过数字完成洗牌发牌 
发牌： 
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。 
存放的过程中要求数字大小与斗地主规则的大小对应。 
将代表不同纸牌的数字分配给不同的玩家与底牌。 
看牌： 
通过Map集合找到对应字符展示。 
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

import java.util.*;

/*
斗地主综合案例：有序版本
1、准备牌
2、洗牌
3、发牌
4、排序
5、看牌
 */
public class DouDiZhu {
    public static void main(String[] args) {
        //1、准备牌
        //创建一个map集合存储牌的索引和组装好的牌
        HashMap<Integer, String> poker = new HashMap<>();
        //创建一个List集合，存储牌的索引
        ArrayList<Integer> pokerIndex = new ArrayList<>();
        //定义两个集合，存储花色和牌的序号
        List<String> colors = List.of("♦", "♣", "♥", "♠");
        List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        //把大王和小王存储到集合中
        //定义一个牌的索引
        int index = 0;
        poker.put(index, "大王");
        pokerIndex.add(index);
        index++;

        poker.put(index, "小王");
        pokerIndex.add(index);
        index++;
        //循环嵌套遍历两个集合，组装52张牌，存储到集合中
        for(String number:numbers){
            for(String color:colors){
                poker.put(index,color+number);
                pokerIndex.add(index);
                index++;
            }
        }
        //System.out.println(poker);
        //System.out.println(pokerIndex);
        /*
        2.洗牌
        使用collections中的方法shuffle(list)
         */
        Collections.shuffle(pokerIndex);
        //System.out.println(pokerIndex);
         /*
        3.发牌
        定义四个集合，存储玩家的索引和底牌的索引
         */
         ArrayList<Integer> player01 = new ArrayList<>();
         ArrayList<Integer> player02 = new ArrayList<>();
         ArrayList<Integer> player03 = new ArrayList<>();
         ArrayList<Integer> dipai = new ArrayList<>();
         //遍历存储索引的List集合，获取每一个牌的索引
        for (int i = 0; i <pokerIndex.size(); i++) {
            Integer in = pokerIndex.get(i);
            //先判断底牌
            if(i>=51){
                //给底牌发牌
                dipai.add(in);
            }else if (i %3 == 0){
                player01.add(in);
            }else if (i %3 == 1) {
                player02.add(in);
            }else if (i %3 == 2) {
                player03.add(in);
            }
        }

        //4.排序
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(dipai);

        //5.看牌
        lookpoker("佩奇",poker,player01);
        lookpoker("乔治",poker,player01);
        lookpoker("瑞贝卡",poker,player01);
        lookpoker("底牌",poker,player01);
    }

    /*
    定义一个看牌的方法，提高代码的复用性
    参数：
        String name :玩家名称
        HashMap<Integer,String> poker :存储牌的扑克集合
        ArrayList<Integer> list :存储玩家和底牌的List集合
    查表法：
        遍历玩家或者底牌集合，获取牌的索引
        使用牌的索引，去Map集合中，找到对应的牌
     */
    public static void lookpoker(String name,HashMap<Integer, String> poker,ArrayList<Integer> list){
        //输出玩家的名称
        System.out.print(name + ": ");
        //遍历玩家或者底牌集合，获取牌的索引
        for (Integer key : list){
            //使用牌的索引，去Map集合中，找到对应的牌
            String value = poker.get(key);
            System.out.print(value + " ");
        }
        System.out.println();//打印每一个玩家的牌然后换行
    }

}

 

小夏天禧
关注
专栏目录
Java学习day01-day15学习资料
04-05
Java学习资料涵盖从基础到进阶的多个主题，适合初学者逐步掌握这门语言。这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这...
java初学者学习源代码day04.zip
07-03
"day04.zip"表明这是学习过程中的第四天内容，通常在学习初期阶段，会涉及变量、数据类型、运算符、控制流（如if语句、循环）、类与对象等基础知识。 1. `ShowTokens.class` 和 `ShowTokens.java`：`.class` 文件是...
java后端学习DAY04
2302_76786736的博客
04-12 397
JAVAGUIDE：java基础常见面试总结（上）
Java 基础学习 day_04
m0_45196258的博客
07-25 946
面向对象 对象在内存的状态。 new一个对象，对象的实际数据存储在堆中，而对象的地址存储在栈中。 JVM中的操作 new:在堆中开辟空间，属性默认值。 ivokespecial:执行构造方法。 astore:把地址赋给变量。 ...
Java学习-Day5
最新发布
2401_85901426的博客
08-03 2040
在上面的例子中， myCar 是 Car 类的一个对象。我们通过构造器初始化了它的属性，并调用了它的 displayInformation 方法来展示它的状态。类和对象的关系可以类比为模具和铸件的关系：类是模具，对象是根据这个模具铸造出来的具体实例。类是Java中的一个蓝图或者模板，用于创建具体对象的定义。关键字创建一个对象时，你就是在根据类的定义创建一个具体的实例。：sc是可以改变的，需要在步骤二和步骤三中sc同时改成一样的。下面是一个简单的Java类的例子：(可能看不懂，后面会慢慢讲到的)
JAVA学习day6
qq_54395021的博客
04-30 2324
多线程：在身边的应用 可以边 看电影边 听音乐边 打游戏 JDK：java development kit （java开发者工具） JRE：java runtime environment （java运行环境） JVM：java virtual machine （java虚拟机）
java基础学习first day
weixin_45798731的博客
10-26 1472
一、什么是软件开发？ 首先我们必须先明白三个概念： 1、什么是软件 软件就是按照特定的顺序把数据和指令组合在一起，能够完成相应功能的程序。 软件分为两种： 系统软件：专门用于运行其他程序的平台。比如：Linux、Windows、MAC等 应用软件：完成相应功能的程序。比如：MS-Office，QQ，微信等 2、什么是开发 开发其实就是制作软件的过程。开发既然是个过程，这个过程可以分...
韩顺平java学习day1
m0_60005887的博客
03-10 8249
程序举例 新建后缀名Test.java 的文件，用记事本打开，编辑程序，选中目录路径，输入CMD，打开 命令提示符，运行javac -encoding UTF-8 Test.java 编译，生成可执行文件Test.class，再使用java Test命令执行程序 Java的重要特性 面向对象（OOP） 夸平台性。一个编译好的class文件可以在多个系统运行 解释性语言（编译后的代码，不能直接被机器执行，需要解析器来执行） 编译性语言，编译后的代码可以直接被机器执行 Java的开
day05Java学习加油站 +【附带学习路径指南】
qq_41100456的博客
01-21 1803
文章内的【学历路径】可以为小白指清学习方向，不在为不重要的知识点死磕
学习Java笔记记录Day3
m0_69052198的博客
07-26 2574
Day3
Java学习day01
weixin_40852277的博客
04-13 1791
狂神说Java Java入门01 1972年C诞生 贴近硬件，运行极快，效率极高。 操作系统，编译器，数据库、网络系统等 指针和内存管理 1982年C++诞生 面向对象 兼容C 图形领域、游戏等 Java入门02
Java学习day3
m0_60005887的博客
03-16 1520
java运行机制 执行流程分析 .java文件（也称作源文件）通过javac编译成.class文件（字节码文件）再通过java运行得到结果（本质：将.class文件放到对应的JVM执行，JVM可以识别字节码文件） 编译： 将源文件.java编译成JVM 识别可识别的文件，源文件有错误是，编译会给相应的提示，直到正确编译会生成一个.class文件 每次修改源文件后需要重新编译生成对应的.class文件，运行时的结果才是最新结果 运行： 有了可执行的java程序（.class文件） 通弄个运行工具jav
day3 java 学习笔记
01-13
day3 java 笔记
Java入门基础学习资料day03-04
10-22
day04【 Idea、方法】 day05【数组】 day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day...
java初学者学习源代码day04.7z
07-03
这些文件是针对Java初学者的学习资源，主要包含了一些编译后的`.class`文件以及相应的源码`.java`文件。在Java编程中，`.class`文件是由`.java`源码文件编译生成的，用于JVM（Java虚拟机）执行。让我们深入探讨一下...
01-JAVA快速入门（廖雪峰）
qq_24573381的博客
09-18 850
一、Java简介 学习java的原因： 目前全球Top1开发语言 应用于企业和互联网后端开发、Android开发、大数据开发 市场需求最大的软件工程师 便于学习其他语言 Java特点： 一种面向对象的跨平台编程语言 以字节码方式运行在虚拟机上 自带功能齐全的类库 非常活跃的开源社区支持 Java优点： 简单、健壮、安全 跨平台，一次编写，到处运行 高度优化的虚拟机 Java缺点: 语法较繁琐 无法直接操作硬件不适合底层系统的开发 GUI效果不佳不适合桌面应用的...
4Java反射与泛型——1反射——3调用方法（廖雪峰）
qq_24573381的博客
08-05 383
1Method 通过class实例获取方法Method信息： getMethod(name,Class...)：获取某个public的method（包括父类） getDeclaredMethod(name,Class...)：获取当前类的某个method（不包括父类） getMethods()：获取所有public的method（包括父类） getDeclaredMethods()：获取当前类的所有method（不包括父类） Animal.java 2Method对象 Method对象包含一个
4Java反射与泛型——1反射——1class类（廖雪峰）
qq_24573381的博客
08-03 342
1class Java除基本类型外其他都是class（包括interface） String Object Runnable Exception ... String s = "Hello"; Object o = new Double(123.456); Runnable r = new Thread(); Exception e = new RuntimeException();
4Java反射与泛型——1反射——4调用构造方法（廖雪峰）
qq_24573381的博客
08-05 271
1newInstance Class.newInstance()只能调用public无参数构造方法 String s = (String) String.class.newInstance(); Integer n = (Integer) Integer.class.newInstance();//不能直接调用，因为Integer没有定义无参数的构造方法 2Constructor对象 如何调用带参数的构造方法呢？ 可以调用Constructor方法，Constructor对象包含一个构造方法的所
Java MBeanInstantiator 0day 漏洞分析
"Java 0day Analysis - MBeanInstantiator.findClass 漏洞解析" 在2013年1月，Java社区面临了一个新的重大安全威胁：Java MBeanInstantiator.findClass 0day漏洞。这个漏洞的影响广泛，因为Java在当时已经广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小夏天禧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值