Map、斗地主案例

Map集合

package com.itheima.demo01.Map;
import java.util.HashMap;
import java.util.Map;
/* java.util.Map<k,v>集合 Map集合的特点： 1.Map集合是一个双列集合，一个元素包含两个值（一个key,一个value) 2.Map集合中的元素，key和value的数据类型可以相同，可以不同 3.Map集合中的元素，key是不允许重复的，value是可以重复的 4.Map集合中的元素，key和value是一一对应 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.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的 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 class Demo01Map {

public static void main(String[] args) {

show04();
}
/* boolean containsKey(Object key)判断集合中是否包含指定的值 包含返回true,不包含返回false */
private static void show04() {

Map<String,Integer>map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178);
boolean v1 = map.containsKey("赵丽颖");
System.out.println(v1);//true
boolean v2 = map.containsKey("赵颖");
System.out.println(v2);//false
}
/* public V get(Object key) 根据指定的键，在Map集合中获取对应的值。 返回值：V key存在，v返回对应value值 key不存在，v返回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);
Integer v1 = map.remove("林志玲");
System.out.println(v1);//178
Integer v2 = map.remove("林志颖");
// int v2 = map.remove("林志颖");//自动拆箱 NullPointerException
System.out.println(v2);//null
System.out.println(map);//{赵丽颖=168, 杨颖=165}
}
/* 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("李晨","范冰冰1");
System.out.println(v1);//null
String v2 = map.put("李晨","范冰冰2");
System.out.println(v2);//范冰冰1
System.out.println(map);//{李晨=范冰冰2}
map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");
System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
}
}

Map集合遍历键找值方式

package com.itheima.demo01.Map;
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(),把集合所有的key取出来，存储到一个Set集合中 2.遍历set集合，获取Map集合中的每一个Key 3.通过Map集合中的方法get(key),通过key找到value */
public class Demo02KeySet {

public static void main(String[] args) {

Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178);
//1.使用Map集合中的方法KeySet(),把集合所有的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);
}
}
}

Entry键值对 对象

Map集合遍历键值对方式

package com.itheima.demo01.Map;
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<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对象
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) {

String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
}
}

HashMap存储自定义类型的键值

package com.itheima.demo02.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/* HashMap存储自定义类型键值 Map集合保证key是唯一的： 作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一 */
public class Demo01HashMapSavePerson {

public static void main(String[] args) {

show02();
}
private static void show02() {

//创建HashMap集合
HashMap<Person,String> map =  new HashMap<>();
//往集合中添加元素
map.put(new Person("女王",18),"英国");
map.put(new Person("秦始皇",18),"秦国");
map.put(new Person("普京",30),"俄罗斯");
map.put(new Person("女王",18),"毛里求斯");
//使用entrySet和增强for遍历Map集合
Set<Map.Entry<Person, String>> set = map.entrySet();
for (Map.Entry<Person, String> entry : set) {

Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"->"+value);//Person{name='女王', age=18}->毛里求斯
//Person{name='秦始皇', age=18}->秦国
// Person{name='普京', age=30}->俄罗斯
}
}
/* HashMap存储自定义类型键值 key:String类型 String类重写hashCode方法和equals方法，可以保证key唯一 value:Person类型 value可以重复（同名同年龄的人视为同一个） */
private static void show01() {

//创建HashMap集合
HashMap<String,Person> map =  new HashMap<>();
//往集合中添加元素
map.put("北京",new Person("张三",18));
map.put("上海",new Person("李四",19));
map.put("广州",new Person("王五",20));
map.put("北京",new Person("赵六",18));
//使用keySet和增强for遍历Map集合
Set<String> set = map.keySet();
for (String key : set) {

Person value = map.get(key);
System.out.println(key+"->"+value);//上海->Person{name='李四', age=19}
// 广州->Person{name='王五', age=20}
// 北京->Person{name='赵六', age=18}
}
}
}

package com.itheima.demo02.Map;
import java.util.Objects;
public class Person {

private String name;
private int 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);
}
@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;
}
public Person(String name, int age) {

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

}
}

LinkedHashMap集合

package com.itheima.demo02.Map;
import java.util.HashMap;
import java.util.LinkedHashMap;
/* java.util.linkedHashMap<K,V> extends 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);//{a=d, b=b, c=c} key不允许重复，无序
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);//{a=d, c=c, b=b} key不允许重复，有序
}
}

Hashtable集合

package com.itheima.demo3.Map;
import java.util.HashMap;
import java.util.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流相结合的集合 */
public class Demo02Hashtable {

public static void main(String[] args) {

HashMap<String,String> map = new HashMap<>();
map.put(null,"a");
map.put("b",null);
map.put(null,null);
System.out.println(map);//{null=null, b=null}
Hashtable<String,String> table = new Hashtable<>();
table.put(null,"a");//NullPointerException
table.put("b",null);//NullPointerException
table.put(null,null);//NullPointerException
System.out.println(table);
}
}

练习_计算一个字符串中每个字符出现的次数

package com.itheima.demo3.Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/* 练习： 计算一个字符串中每个字符出现次数 分析： 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("请输入一个字符串：");
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)){

Integer value = map.get(c);
value++;
map.put(c,value);
}else {

map.put(c,1);
}
}
//5.遍历Map集合，输出结果
Set<Map.Entry<Character, Integer>> entries = map.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {

System.out.println("字母："+entry.getKey()+"个数："+entry.getValue());
}
}
}

JDK9对集合添加的优化

package com.itheima.demo04JDK9;
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","c","d","a");
System.out.println(list);//[a, b, c, d, a]
// list.add("w");//UnsupportedOperationException不支持操作异常
// Set<String> set = Set.of("a","b","c","d","a");//IllegalArgumentException非法参数异常，有重复的元素
Set<String> set = Set.of("a","b","c","d");
System.out.println(set);//[d, c, b, a]
//set.add("w");//UnsupportedOperationException不支持操作异常
//Map<String,Integer> map = Map.of("张三",18,"李四",19,"张三",20);//IllegalArgumentException非法参数异常，有重复的元素
Map<String,Integer> map = Map.of("张三",18,"李四",19,"王五",20);
System.out.println(map);
//map.put("赵四",20);//UnsupportedOperationException不支持操作异常
}
}

Debug

package com.itheima.demo05.Debug;
/* 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("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
}
}

斗地主案例的需求分析

package com.itheima.demo.Test;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
/* 斗地主综合案例：有序版本 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){

//给玩家1发牌
player01.add(in);
}else if(i%3==1){

//给玩家2发牌
player02.add(in);
}else if(i%3==2){

//给玩家3发牌
player03.add(in);
}
}
/* 4.排序(默认升序） 使用Collections中的方法sort(list) */
Collections.sort(player01);
Collections.sort(player02);
Collections.sort(player03);
Collections.sort(diPai);
/* 5.看牌 */
LookPoker("player01",poker,player01);
LookPoker("player02",poker,player02);
LookPoker("player03",poker,player03);
LookPoker("底牌",poker,diPai);
}
/* 5.定义一个看牌的方法，提高代码的复用性 参数： String name:玩家名称 HashMap<Integer,String> poker 存储牌的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();//打印完每个玩家的牌换行
}
}