Java从入门到实战之（12）Map示例大全（一）

集合嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如单列集合嵌套、双列集合与单列集合嵌套、双列集合嵌套。

单列集合嵌套:

大学(List表示)有多个分校(list表示)，每个分校有多个班级(字符串)。

双列集合与单列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(List表示)

每个分校有多个班级(字符串)。

双列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(Map表示，key:班级名称、value 班级对象)

每个分校有多个班级(自定义班级类MyClass)。

如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >

Collection< ArrayList<Integer> >

Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>

ArrayList< HashMap<String, String>>

Map集合嵌套

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

模拟斗地主洗牌发牌

5.1 案例介绍

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

具体规则：

1. 组装54张扑克牌

2. 将54张牌顺序打乱

3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

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

具体代码逻辑如下：这是ArrayList集合的一个很好的接近实际意义的练习实战。对于新手来说，可能确实有点难，

但这只是最基础的练习。如果真想在这个行业干下去，请加强这些基础的练习。这些仅仅只是基础，在实际开发中，比这更难，

只有先从最基础的最基本的做起，实际开发，其实很多都是由这些最基础的知识去完成的。只是也相对的加了一些逻辑业务。

但不管怎么样，还是这句话，基础是关键，加油！不放弃，不抛弃！相信自己，你可以的。人生的酸甜苦辣，哪位成功的人士没有经历过呢?谁没有点这些风风雨雨的经历，只有经历这些大风大浪，才有可能成功。对自己说：come on!!!!!!!!!!!!

package cn.arrays;



import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;



/*要修改java文件编码，由GBK修改为UTF-8，

因为默认的字符编码GBK没有我们要的梅花、方片、黑桃、红桃(♠♥♦♣)等特殊字符。*/

public class Porker {

public static void main(String[] args) {

// 准备花色,创建ArrayList集合

ArrayList<String> color = new ArrayList<String>();

// 添加红 黑 梅花 方块 四种元素

color.add("♠");

color.add("♥");

color.add("♦");

color.add("♣");

// 准备数字，创建arrayList对象

ArrayList<String> number = new ArrayList<String>();

// Collections工具

Collections.addAll(number, "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2");

// 定义一个map集合：用来将数字与每一张牌进行对应

HashMap<Integer, String> map = new HashMap<Integer, String>();

int index = 0;

// 加入大小王

map.put(index++, "小☺");

map.put(index++, "大☻");

// 对这些数字进行遍历，arrayList的嵌套遍历

for (String thisNumber : number) {

// 对颜色进行遍历

for (String thisColor : color) {

// 添加到map集合对象中

map.put(index++, thisColor + thisNumber);

}

}

// 这样一副牌就准备好了，输出这副牌，可以查看下

System.out.println(map);

// 一副54张的牌 ArrayList里边为0-53的数的新牌

ArrayList<Integer> cards = new ArrayList<Integer>();

for (int i = 0; i <= 53; i++) {

cards.add(i);

}

// 控制台查看这53个数字

// System.out.println(cards);

// 洗牌，自然排序,即随机排序的

Collections.shuffle(cards);

System.out.println(cards);

// 创建三个玩家和底牌

ArrayList<Integer> iPlayer = new ArrayList<Integer>();

ArrayList<Integer> iPlayer2 = new ArrayList<Integer>();

ArrayList<Integer> iPlayer3 = new ArrayList<Integer>();

ArrayList<Integer> itCards = new ArrayList<Integer>();

// 遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和底牌中

for (int i = 0; i < cards.size(); i++) {

// 如果i大于等于51

if (i >= 51) {

// 将其中的三张加入到底牌中

itCards.add(cards.get(i));

} else {

// 否则这51张牌平分给三位玩家

if (i % 3 == 0) {

// 玩家一获得的牌

iPlayer.add(cards.get(i));

} else if (i % 3 == 1) {

// 玩家二获得的牌

iPlayer2.add(cards.get(i));

} else {

// 玩家三获得的牌

iPlayer3.add(cards.get(i));

}

}

}

// 对每个人手中的牌排序，随机排序

Collections.sort(iPlayer);

Collections.sort(iPlayer2);

Collections.sort(iPlayer3);



// 对应数字形式的每个人手中的牌，定义字符串形式的牌

ArrayList<String> sPlayer = new ArrayList<String>();

ArrayList<String> sPlayer2 = new ArrayList<String>();

ArrayList<String> sPlayer3 = new ArrayList<String>();

ArrayList<String> sCards = new ArrayList<String>();

// 对三位玩家的牌进行遍历

for (Integer key : iPlayer) {

sPlayer.add(map.get(key));

}

for (Integer key : iPlayer2) {

sPlayer2.add(map.get(key));

}

for (Integer key : iPlayer3) {

sPlayer3.add(map.get(key));

}

// 对底牌进行遍历

for (Integer key : itCards) {

sCards.add(map.get(key));

}

// 最终： 看牌，各玩家查看自己的牌

System.out.println("玩家一的牌" + sPlayer); //

System.out.println("玩家二的牌" + sPlayer2);

System.out.println("玩家三的牌" + sPlayer3);

System.out.println("底牌" + sCards);

}

}

掌握Arrays类的常用方法；

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

定义int数组，初始化为：{235,676,90,3,43,65,52,34,36,,776,9,86}
调用Arrays类的相关方法对数组进行升序排序；
调用Arrays类的查找方法，在数组中查找元素：776，并打印查找结果；
调用Arrays类的toString()方法打印这个int数组

6.1.2 冒泡排序、选择排序、二分查找的程序实现；

6.1.3 简述什么是Map集合，最常用的操作有哪些

6.1.4 参照集合体系图，说出所有常用集合及常用集合的相关方法

6.1.5 产生10个1-20之间的随机数要求随机数不能重复案例。

6.1.6 键盘录入多个数据在控制台输出最大值案例。

6.1.7 ArrayList集合的toString()方法源码阅读

6.1.8 键盘录入多个数据，按数据从小到大的顺序打印到控制台。

6.1.9 熟练使用带可变参数的方法(提示：Arrays类与Collections各一个)

6.1.10 描述4种数据结构的特点

数组结构：一块连续的存储区域

链表结构：每个元素指向下一个元素

队列结构：容器先进先出的规则

栈结构：容器先进后出规则

6.1.11 请你统计出,每个字母出现的次数.

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

 

/*

 * String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

 *

 * 请你统计出,每个字母出现的次数.

 * a - 2

 * l - 1

 * i - 1

 * j - 1

 *

 * 1.遍历字符串

 * 2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer  

 * 3.map ,即是结果, 遍历 map .

 *

 */

public class Test {
public static void main(String[] args) {
 

String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

//创建map

HashMap<Character,Integer> hashMap = new HashMap<>();

 

 

// 1.遍历字符串   

for (int i = 0; i < s.length() ; i++) {
char key   = s.charAt(i);  // ch 为每一个字母.

//2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer  

 

//判断 是否包含key , 再保存.

if (hashMap.containsKey(key)) {
 // 包含,存过

 

//Integer count  = hashMap.get(key);// 获取之前次数,

//count++;  // + 1

hashMap.put(key, hashMap.get(key) + 1); // 再 保存

}else {
// 不包含 , 第一次存.

hashMap.put(key, 1);

}

}

 

// 3. 遍历map

Set<Entry<Character,Integer>> entrySet = hashMap.entrySet();

 

System.out.println( "字母  -- 次数 "  );

for (Entry<Character, Integer> entry : entrySet) {
 

System.out.println(entry.getKey() +" -- "+ entry.getValue());

 

}

}

}

6.2 代码题：

6.2.1 创建一个Map集合，添加数据进行测试，使用Map集合的两种遍历方式进行遍历

package day09_Test基础练习题;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class Test001 {
//创建一个Map集合，添加数据进行测试，使用Map集合的两种遍历方式进行遍历

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

map.put("李连杰", "男人");

map.put("林志玲", "女人");

map.put("泰国有", "人妖");

//map集合第一种遍历方式

/*Set<Entry<String, String>> set = map.entrySet();

for (Entry<String, String> entry : set) {
String key = entry.getKey();

String value = entry.getValue();

System.out.println("key="+key+",value="+value);

}*/

//map集合第二种遍历方式

Set<String> set = map.keySet();

for (String key : set) {
String value = map.get(key);

System.out.println("key="+key+",value="+value);

}

}

}

6.2.2 Map集合（相同键与不同键）

定义一个测试类，在测试类中定义main()方法，按以下要求编写代码

1.实例化一个Map<String,String>集合

2.向集合内添加以下内容：

"NO01"，"安森"

"NO01"，"凯特"

"NO02"，"安森"

3.遍历集合，观察打印结果，请说明

4.如果存储“相同的键”时，会发生什么情况

5.如果存储“不同的键”，“相同的值”时，会怎样？

package day09_Test基础练习题;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

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

map.put("NO01", "安森");

map.put("NO02", "凯特");

map.put("NO03", "安森");

Set<Entry<String, String>> entrySet = map.entrySet();

for (Entry<String, String> entry : entrySet) {
String key = entry.getKey();

String value = entry.getValue();

System.out.println("key="+key+",value="+value);

}

System.out.println("---------------存储相同的键-------------------------");

map.put("NO01", "李安");

//查看map

System.out.println(map);//将原先的值给覆盖了

System.out.println("---------------存储不同的键---------------------");

map.put("NO09", "008");

//查看此时的map

System.out.println(map);//存储到Map中了

}

}

6.2.3 遍历Map

定义Student类，要求有如下成员：

成员属性(私有):

姓名(String类型)

性别(String类型)

年龄(int 类型)

构造方法：

无参

全参

成员方法：

get/set方法

(有兴趣，可以将toString()方法也添加上)

定义类测试类，在测试类中定义main()方法，按以下要求编写代码：

实例化一个Map<String,Student>集合
向集合中添加以下元素：

“it001”,new Student(“王宝强”,’男’,20);

“it002”,new Student(“马蓉”,’女’,18);

“it003”,new Student(“宋喆”,’男’,19);

使用两种方式遍历这个Map

Student类：

package day09_Test基础练习题;

public class Student {
private String name;

private char sex;

private int age;

public String getName() {
return name;

}

public void setName(String name) {
this.name = name;

}

public char getSex() {
return sex;

}

public void setSex(char sex) {
this.sex = sex;

}

public int getAge() {
return age;

}

public void setAge(int age) {
this.age = age;

}

@Override

public String toString() {
return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";

}

public Student() {
super();

// TODO Auto-generated constructor stub

}

public Student(String name, char sex, int age) {
super();

this.name = name;

this.sex = sex;

this.age = age;

}

}

package day09_Test基础练习题;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

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

map.put("it001", new Student("王宝强", '男', 20));

map.put("it002", new Student("马蓉", '女', 18));

map.put("it003", new Student("宋哲", '男', 19));

//第一种方式

/*Set<String> keSet = map.keySet();

for (String key : keSet) {
Student student = map.get(key);

System.out.println("key="+key+",student的信息如下："+student);

}*/

//第二种方式

Set<Entry<String, Student>> entrySet = map.entrySet();

for (Entry<String, Student> entry : entrySet) {
String key = entry.getKey();

Student student = entry.getValue();

System.out.println("key="+key+",student的信息如下："+student);

}

}

}

6.2.4 使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键

定义类Cat类，要求有以下成员：

成员属性(私有):

姓名

性别

年龄

构造方法：

无参

全参

成员方法：

get/set方法

定义一个测试类，在测试类中定义main()方法：

l在main()中按以下要求编写代码：

实例化一个Map<Cat,String>集合；
向集合中添加以下元素：

new Cat(“波斯猫”,’公’,2)，”No01”

new Cat(“折耳猫”,’母’,1)，”No02”

new Cat(“折耳猫”,’母’,1)，”No03”

使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键

package day09_Test基础练习题;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

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

map.put(new Cat("波斯猫", '公', 2), "No01");

map.put(new Cat("折耳猫", '母', 1), "No02");

map.put(new Cat("折耳猫", '母', 1), "No03");

//遍历

Set<Entry<Cat, String>> entrySet = map.entrySet();

for (Entry<Cat, String> entry : entrySet) {
Cat cat = entry.getKey();

String value = entry.getValue();

System.out.println("Cat="+cat+",value="+value);

 

}

}

}

6.2.5 定义类，定义main()方法，按以下要求编写代码：定义一个ArrayList<Integer>，添加一些整数；使用Collections类的相关方法将内部元素排序；定义一个HashSet<Integer>，添加一些元素；请问是否可以使用同样的方式排序？为什么？将ArrayList内的元素打乱顺序；打印集合

package day09_Test基础练习题;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

public class Test005 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();

list.add(11);

list.add(222);

list.add(3);

list.add(40);

list.add(5);

//Collections.sort(list);

System.out.println("此时的list集合元素为："+list);

//HashSet

HashSet<Integer> set = new HashSet<>();

set.add(23);

set.add(2);

set.add(203);

set.add(24);

set.add(3);

System.out.println("没有排序的set="+set);

//Collections.sort(set);使用Collections集合的sort方法里面只能放入List集合，不能放入set集合

//打印ArrayList集合

Collections.shuffle(list);

System.out.println("打乱顺序的list集合元素为："+list);

}

}

6.2.6 定义一个Map，存储如下内容：增加一位新老师Allen教JDBC;Lucy改为教CoreJava，使用两种方式遍历集合；输出所有教JDBC的讲师

定义一个Map，存储如下内容：

老师课程

Tom CoreJava

John Oracle

Susan Oracle

Jerry JDBC

Jim Unix

Kevin JSP

Lucy JSP

完成以下要求：

1).增加一位新老师Allen教JDBC;

2).Lucy改为教CoreJava

3).使用两种方式遍历集合；

4).输出所有教JDBC的讲师

package day09_Test拓展三道编程题;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class Test001 {
/*.定义一个Map，存储如下内容：

老师  课程

Tom  CoreJava

John  Oracle

Susan Oracle

Jerry  JDBC

Jim  Unix

Kevin JSP

Lucy  JSP

完成以下要求：

1).增加一位新老师Allen教JDBC;

2).Lucy改为教CoreJava

3).使用两种方式遍历集合；

4).输出所有教JDBC的讲师；*/

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

map.put("Tom", "CoreJava");

map.put("John", "Oracle");

map.put("Susan", "Oracle");

map.put("Jerry", "JDBC");

map.put("Jim", "Unix");

map.put("Kevin", "JSP");

map.put("Lucy", "JSP");

//1).增加一位新老师Allen教JDBC;

map.put("Allen", "JDBC");

//2).Lucy改为教CoreJava

map.put("Lucy", "CoreJava");

//3).使用两种方式遍历集合；

//--方式一：获取所有键的集合

Set<String> keys = map.keySet();

for(String k : keys){
System.out.println(k + "," + map.get(k));

}

//--方式二：获取所有键值对的集合

Set<Map.Entry<String, String>> entrySet = map.entrySet();

for(Map.Entry<String, String> e : entrySet){
System.out.println(e.getKey() + "," + e.getValue());

}

//4).输出所有教JDBC的讲师；

for(String k : keys){
if(map.get(k).equals("JDBC")){
System.out.println("讲师：" + k + " 教JDBC");

}

}

}

}

6.2.7 静态方法，list集合

1.定义一个类Demo；

2.内部定义一个静态方法asList，此方法可以接收任意多的String类型参数，方法功能：将所有String参数的值存储到一个具有String泛型的List集合中，并将此集合返回；

3.在Demo类中定义main()方法，并调用asList方法获取返回值，并遍历集合

package day09_Test拓展三道编程题;

import java.util.ArrayList;

import java.util.List;

public class Test002 {
/*

 * 1.定义一个类Demo；

2.内部定义一个静态方法asList，此方法可以接收任意多的String类型参数，

   方法功能：将所有String参数的值存储到一个具有String泛型的List集合

            中，并将此集合返回；

3.在Demo类中定义main()方法，并调用asList方法获取返回值，并遍历集

  合；

 */

public static void main(String[] args) {
List<String> strList = asList("Java","Oracle","MySql","JDBC","JSP","HTML","jQuery");

for(String s : strList){
System.out.println(s);

}

}

private static List<String> asList(String ... values) {
List<String> strList = new ArrayList<>();

for(String s : values){
strList.add(s);

}

return strList;

}

}

6.2.8 抽到明牌者为地主

成龙，甄子丹，李连杰三个人打斗地主，三人约定，洗牌后，随机抽取一张"明牌"并夹在中间；然后依次抓牌，谁抓到这张便自动作为地主，并收取最后三张。

要求：请用程序实现这一过程，最后打印地主名，以及三个人的牌(要求排序)；

思路：

1.定义一个Map集合存储一副扑克牌；List存储编号；

2.洗牌；

3.随机抽取一个索引(该值必须在倒数三张之前)，用于表示"明牌"，在发牌时谁抓到这一张便作为"地主"；

4.依次给三个人(成龙，甄子丹，李连杰)发牌，并监督谁作为地主；地主自动收取最后三张。

5.打印地主名；

6.最后以排序后的方式打印每个人手里的牌

package day09_Test拓展三道编程题;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

 

public class Test003 {
/*成龙，甄子丹，李连杰三个人打斗地主，三人约定，洗牌后，随机抽取一张"明牌"并夹在中间；然后依次抓牌，谁抓到这张便自动作为地主，并收取最后三张。

要求：请用程序实现这一过程，最后打印地主名，以及三个人的牌(要求排序)；

思路：

  1.定义一个Map集合存储一副扑克牌；List存储编号；

  2.洗牌；

  3.随机抽取一个索引(该值必须在倒数三张之前)，用于表示"明牌"，在发牌

    时谁抓到这一张便作为"地主"；

  4.依次给三个人(成龙，甄子丹，李连杰)发牌，并监督谁作为地主；地主自

     动收取最后三张。

  5.打印地主名；

  6.最后以排序后的方式打印每个人手里的牌

 */

public static void main(String[] args) {
String[] colors = {"♥","♦","♠","♣"};

String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

Map<Integer,String> pokerMap = new HashMap<>();

List<Integer> indexList = new ArrayList<>();

int index = 1;

for(String n : numbers){
for(String c : colors){
pokerMap.put(index, c + n);

indexList.add(index);

index++;

}

}

pokerMap.put(index, "小王");

indexList.add(index);

index++;

pokerMap.put(index, "大王");

indexList.add(index);

//2.洗牌

Collections.shuffle(indexList);

//3.随机抽取一张作为明牌

int flagIndex = -1;

Random rdm = new Random();

flagIndex = rdm.nextInt(indexList.size() - 3);

System.out.println("明牌索引：" + flagIndex);

//4.发牌

List<Integer> chenglongList = new ArrayList<>();

List<Integer> zhenzidanList = new ArrayList<>();

List<Integer> lilianjieList = new ArrayList<>();

int dizhu = 0;//1.成龙；2.甄子丹；3.李连杰

for(int i = 0;i < indexList.size() ; i++){
if(i >= indexList.size() - 3){
if(dizhu == 1){
chenglongList.add(indexList.get(i));

}else if(dizhu == 2){
zhenzidanList.add(indexList.get(i));

}else if(dizhu == 3){
lilianjieList.add(indexList.get(i));

}

}else{
if(i % 3 == 0){
chenglongList.add(indexList.get(i));

if(i == flagIndex){
dizhu = 1;

System.out.println("地主：成龙");

}

}else if(i % 3 == 1){
zhenzidanList.add(indexList.get(i));

if(i == flagIndex){
dizhu = 2;

System.out.println("地主：甄子丹");

}

}else if(i % 3 == 2){
lilianjieList.add(indexList.get(i));

if(i == flagIndex){
dizhu = 3;

System.out.println("地主：李连杰");

}

}

}

}

//排序

Collections.sort(chenglongList);

Collections.sort(zhenzidanList);

Collections.sort(lilianjieList);

//看牌

System.out.println("成龙：" + lookPoker(chenglongList,pokerMap));

System.out.println("甄子丹：" + lookPoker(zhenzidanList,pokerMap));

System.out.println("李连杰：" + lookPoker(lilianjieList,pokerMap));

 

}

public static String lookPoker(List<Integer> list,Map<Integer,String> pokerMap){
StringBuffer buf = new StringBuffer("[");

for(int i = 0;i < list.size() ; i++){
buf.append(pokerMap.get(list.get(i)));

if(i < list.size() - 1){
buf.append(", ");

}

}

buf.append("]");

return buf.toString();

}

}