第一章 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:trueboolean 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:165Integer v2 = map.get("艾米丽");System.out.println("v2:"+v2);//v2:null}/*public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。返回值:Vkey存在,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:178System.out.println(map);//{苏西=165, 佩奇=168}//int v2 = map.remove("艾米丽");//自动拆箱  NullPointerExceptionInteger v2 = map.remove("");System.out.println("v2:"+v2);//v2:nullSystem.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:nullString 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集合遍历键找值方式

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

分析步骤：

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
遍历键的Set集合，得到每一个键。
根据键，获取键所对应的值。方法提示: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集合中的每一个key3.通过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找到valueInteger value = map.get(key);System.out.println(key+"="+value);}System.out.println("-------------------");//使用增强for遍历Set集合for(String key : set){//3.通过Map集合中的方法get(key),通过key找到valueInteger value = map.get(key);System.out.println(key+"="+value);}System.out.println("-------------------");//使用增强for遍历Set集合for(String key : map.keySet()){//3.通过Map集合中的方法get(key),通过key找到valueInteger 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)对象中的键与值。

操作步骤与图解：

获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
通过键值对(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;}@Overridepublic 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;}@Overridepublic 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);}@Overridepublic 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的断点调试功能，查看程序的运行过程

在有效代码行，点击行号右边的空白区域，设置断点，程序执行到断点将停止，我们可以手动来运行程序

/*
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案例介绍

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

具体规则：

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

规则：手中扑克牌从大到小的摆放顺序：大王,小王,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();//打印每一个玩家的牌然后换行}}

day04 java学习相关推荐

Java 学习 Day04（1）
Java 学习 Day04 程序流程控制一.分支结构中的if-else(条件判断结构) 1.三种结构第一种: if(条件表达式){ 执行表达式 } 第二种:二选一 if(条件表达式){ 执行表达式 ...
Java学习总结与体会，从小菜开始
文章目录 1.Java学习总结一.第一章 1.Java技术体系平台 2.Java的重要的特点 3.跨平台性的原理 4.什么是JDK,什么是JRE? 5.编写最简单的java代码(hello,worl ...
Java学习第十五天
Java学习第十五天第一章 StringBuilder类 1.1 字符串的不可变 1.2 StringBuilder概述 1.3 构造方法 1.4 两个常用方法 1.4.1 append方法 1. ...
Java学习路线图，如何学习Java事半功倍？
作为一个初学者想掌握Java并不是很容易,Java本身是具有一定难度的,虽然说兴趣这东西可以让我们学习不累,但是有多少人学习是因为兴趣,或者有多少人知道自己的兴趣在哪?所以我很明确的告诉你学习这事本来 ...
Java学习必不可少的网站，快收藏起来
java技术在IT互联网行业的发展前景一直在提升,越来越多的人都在学习java技术,今天小编来给大家提供一些学习Java的网站集合,希望能够帮助到正在学习java技术的同学. Java学习必不可少的网 ...
分享五款java学习辅助工具，总有你用的上的~
想要学好java技术,除了自身的努力,辅助工具也不缺少,辅助工具可以帮助大家在今后的工作中可以提高工作效率,下面小编就来分享五款java学习辅助工具,总有你用的上的~ 五款java学习辅助工具: 1. ...
Java学习从入门到精通的学习建议
想要学好java技术,首先打好基础很重要,不论学什么基础都是重中之重,学习Java更是如此.如:基础语法.核心类库.面向对象编程.异常.集合.IO流等基础如果学不好,那么后边更深入的语法也不容易学会. ...
java学习笔记11--Annotation
java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...
java学习笔记13--反射机制与动态代理
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制在Java运行时环境中,对于任意 ...
JAVA学习资源网站
中文java技术网--http://www.cn-java.com/ 灰狐动力(http://www.huihoo.com/)-- 该站点有许多的开源的项目的介绍和学习,涉及操作系统,数据库等许多方向 ...

day04 java学习

第一章 Map集合

1.1 概述

1.2 Map常用子类

1.3 Map接口中的常用方法

1.4 Map集合遍历键找值方式

1.5 Entry键值对对象

Map集合遍历键值对方式

1.6 HashMap存储自定义类型键值

1.7 LinkedHashMap

1.8 Hashtable集合

第二章补充知识点

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

2.2Debug追踪

第三章案例分析

3.1案例介绍

3.2 案例需求分析

day04 java学习相关推荐

最新文章

热门文章

day04 java学习

第一章 Map集合

1.1 概述

1.2 Map常用子类

1.3 Map接口中的常用方法

1.4 Map集合遍历键找值方式

1.5 Entry键值对对象

Map集合遍历键值对方式

1.6 HashMap存储自定义类型键值

1.7 LinkedHashMap

1.8 Hashtable集合

第二章 补充知识点

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

2.2Debug追踪

第三章 案例分析

3.1案例介绍

3.2 案例需求分析

day04 java学习相关推荐

最新文章

热门文章

第二章补充知识点

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

第三章案例分析