java进阶笔记Day(七)

Map集合
Map一个双列集合的根接口， 用来存储【键值对】的集合，Map下面有几个子类
Map<K,V>接口
HashMap<K,V>: 键不能重复，值可以重复
通过重复键的hashCode和equals方法包装键的唯一性
TreeMap<K,V>: 可以对键进行排序
让键实现Comparable接口，复写compareTo方法对键进行排序

//HashMap底层数据结构是哈希表结构，可以包装键的唯一性
Map<String,String> map=new HashMap<>();
map.put(“张三”,“武汉”);
map.put(“李四”,“上海”);
map.put(“王五”,“深圳”);
map.put(“王五”,“广州”);
System.out.println(mqp); //[ 张三=武汉, 李四=上海, 王五=广州 ]
Map集合的常用方法

public V put(K key,V value)
添加键和值到Map集合，如果键重复会把原来的值替换掉
注意：返回被替换的值
public V remove(K key)
通过键删除【键值对】，返回被删除的值
public V get(K key)
通过键获取值，如果返回值为null就说明没有这个键。
public void clear()
清空Map集合中的元素
public int size()
获取Map集合中【键值对】的个数
public boolean containsKey(K key)
判断是否包含指定的键
public boolean containsValue(V key)
判断是否包含指定的值
Map集合的遍历1(重点)

public Set keySet()
获取Map集合中所有的键组成的Set集合
Map<String,String> map=new HashMap<>();
map.put(“李晨”,“范冰冰”);
map.put(“贾乃亮”,“李小璐”);
map.put(“程宇凡”,“白百合”);
map.put(“王宝强”,“马蓉”);
​
//获取所有的键组成Set集合
Set keys = map.keySet();
for (String key : keys) {
//通过键获取值
String value = map.get(key);
System.out.println(key+"…"+value);
}
Map集合的遍历2(重点)

public Set<Map.Entry<K,V>> entrySet()
获取【键值对】组成的Set集合

Map<String,String> map=new HashMap<>();
map.put(“李晨”,“范冰冰”);
map.put(“贾乃亮”,“李小璐”);
map.put(“程宇凡”,“白百合”);
map.put(“王宝强”,“马蓉”);
//获取所有【键值对】组成的Set集合
Set<Map.Entry<String, String>> entrys = map.entrySet();
for (Map.Entry<String, String> entry : entrys) {
//获取【键值对】的键
String key = entry.getKey();
//获取【键值对】的值
String value = entry.getValue();
System.out.println(key+"…"+value);
}

Map集合存储自定义对象

public class Student {
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;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
​
public class Demo2 {
public static void main(String[] args) {
Map<Student,String> map=new HashMap<>();
//往Map集合中存储自定义的对象，作为键
map.put(new Student(“张三”,18),“武汉”);
map.put(new Student(“张三”,18),“汉口”);
map.put(new Student(“李四”,20),“上海”);
map.put(new Student(“王五”,17),“广州”);
map.put(new Student(“赵六”,19),“深圳”);
map.put(new Student(“田七”,21),“北京”);
​
Set keys = map.keySet();
for (Student key : keys) {
String value = map.get(key);
System.out.println(key+"…"+value);
}
​
System.out.println("-------------");
​
Set<Map.Entry<Student, String>> entrys = map.entrySet();
for (Map.Entry<Student, String> entry : entrys) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"…"+value);
}
}
}
List嵌套Map

Map<String,String> map1=new HashMap<>();
map1.put(“李晨”,“范冰冰”);
map1.put(“贾乃亮”,“李小璐”);
​
Map<String,String> map2=new HashMap<>();
map2.put(“程宇凡”,“白百合”);
map2.put(“王宝强”,“马蓉”);
​
//ArrayList集合的元素是Map集合
ArrayList<Map<String,String>> list=new ArrayList<>();
list.add(map1);
list.add(map2);
​
//遍历list集合
for (Map<String, String> map : list) {
//list集合得到的元素是map，map可以继续遍历
Set<Map.Entry<String, String>> entrys = map.entrySet();
for (Map.Entry<String, String> entry : entrys) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"…"+value);
}
}
Map嵌套List

//创建一个ArrayList集合，用来存储湖北省的城市
ArrayList hbList=new ArrayList<>();
hbList.add(“武汉”);
hbList.add(“孝感”);
hbList.add(“十堰”);
hbList.add(“黄冈”);
​
//创建一个ArrayList集合，用来存储湖北省的城市
ArrayList hnList=new ArrayList<>();
hnList.add(“长沙”);
hnList.add(“株洲”);
hnList.add(“湘潭”);
hnList.add(“岳阳”);
​
//使用Map集合，存储list集合
//键：省份名称
//值：该省份的若干城市
HashMap<String,ArrayList> map=new HashMap<>();
map.put(“湖北省”,hbList);
map.put(“湖南省”,hnList);
​
//遍历map集合，获取所有的省份存入Set集合
Set keys = map.keySet();
for (String key : keys) {
System.out.println(key); //打印省份的名称
//根据键获取值
ArrayList value = map.get(key);
//继续遍历list集合，获取该省份下的每一个城市
for (String city : value) {
System.out.println("\t"+city);
}
}
统计字符串中字符出现的次数

//1.键盘录入一个字符串
Scanner sc=new Scanenr(System.in);
System.out.println(“请输入一个字符串：”);
String str=sc.nextLine();
​
//键：字符
//值：字符出现的次数
HashMap<Characher,Integer> map=new HashMap<>();
​
//2.遍历字符串获取每一个字符
for(int i=0;i<str.length();i++){
//获取i索引位置的字符
char ch=str.charAt(i);
//3.把字符当做键存储到HashMap集合中，值就是字符出现的次数
//在存储字符之前，判断Map集合中是否有对应的字符？
if(map.containsKey(ch)){
//如果有这个字符，把原来的值获取出来+1，再存回Map集合
int count=map.get(ch);
map.put(ch,count+1);
}else{
//如果没有这个字符，直接存入map集合，值就是1
map.put(ch,1);
}
}
​
//4.遍历map集合，按照格式输出键和值
Set keys=map.keySet();
for(Characher key:keys){
//获取键对应的值
Integer value=map.get(key);
System.out.print(key+"("+value+")");
}
Collections类(重点)
Collections是用来操作单列集合的工具类

public static addAll(Collection<? super T> c, T… elements)
往Collection集合中添加多个元素
public static int binarySearch(List list, T key)
使用二分查找法，查找List集合中指定元素的索引
注意：在查找之前必须对List集合进行排序
public static void sort(List list)
对List集合进行排序
public static void swap(List<?> list, int i, int j)
对List集合中的i索引和j索引的元素交换位置
public static T max(Collection<? extends T> coll)
获取Collection集合中元素的最大值
public static T min(Collection<? extends T> coll)
获取Collection集合中元素的最小值
public static void reverse(List<?> list)
把List集合中的元素反转
public static void shuffle(List<?> list)
对List集合中的元素进行随机置换

List list=new ArrayList<>();
//往List集合中添加多个元素
Collections.addAll(list,“bbc”,“hello”,“www”,“itcast”,“world”,“java”,“abc”);
System.out.println(“排序前：”+list);
​
//对list集合进行排序
Collections.sort(list);
System.out.println(“排序后：”+list);
​
//查找"world"出现的索引
int index = Collections.binarySearch(list, “world”);
System.out.println(index);
​
//对2索引为4索引的元素换行位置
Collections.swap(list,2,4);
System.out.println(“置换后：”+list);
​
//求List集合中元素的最大值
String max = Collections.max(list);
System.out.println(max);
​
//求List集合中元素的最小值
String min = Collections.min(list);
System.out.println(min);
​
//把list集合中的元素反转
Collections.reverse(list);
System.out.println(“反转后：”+list);
​
//对list集合中的元素随机置换(洗牌)
Collections.shuffle(list);
System.out.println(“洗牌后：”+list);

List list=new ArrayList<>();
​
//往list集合中添加多个元素
Collections.addAll(list,
new Student(“张三”,18),
new Student(“李四”,20),
new Student(“王五”,19),
new Student(“赵六”,17));
​
//对list集合进行排序: 升序
Collections.sort(list);
System.out.println(list);
​
//对list集合进行排序: 降序，指定比较器
Collections.sort(list, new Comparator() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge()-o1.getAge();
}
});
System.out.println(list);
​
//查找集合中的元素
int index = Collections.binarySearch(list, new Student(“王五”, 19));
System.out.println(index);
​
//获取年龄最大的学生对象
Student max = Collections.max(list);
System.out.println(max);
斗地主发牌的案例

//1.准备牌
//花色
String[] colors={“♥”,“♠”,“♦”,“♣”};
//点数
String[] numbers={“3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”,“A”,“2”};
//牌盒子
ArrayList box=new ArrayList<>();
//把花色和点数组成每一张牌 (52张)
for(String color : colors){
for(String number : numbers){
String p=color+number;
box.add§;
}
}
//准备大王和小王
box.add(“大王”);
box.add(“小王”);
//2.洗牌
Collections.shuffle(box);
//3.发牌
//准备3个集合代表玩家，和1个集合代表底牌
ArrayList player1=new ArrayList<>();
ArrayList player2=new ArrayList<>();
ArrayList player3=new ArrayList<>();
ArrayList dipai=new ArrayList<>();
for(int i=0;i<box.size();i++){
String p=box.get(i);
//最后三张
if(i>=51){
dipai.add§;
}else{
if(i%30){
player1.add§;
}else if(i%31){
player2.add§;
}else if(i%3==2){
player3.add§;
}
}
}
//4.看牌
System.out.println(“玩家1：”+player1);
System.out.println(“玩家2：”+player2);
System.out.println(“玩家3：”+player3);
System.out.println(“底牌：”+diapi);
斗地主发牌案例(排序)

public class Doudizhu2 {
public static void main(String[] args) {
//1.准备牌
//花色
String[] colors={“♥”,“♠”,“♦”,“♣”};
//点数
String[] numbers={“3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”,“A”,“2”};
//牌盒子
//键：编号
//值：编号对应的牌
HashMap<Integer,String> map=new HashMap<>();
//单独存储编号的集合
ArrayList list=new ArrayList<>();
​
int index=0; //表示编号
//把花色和点数组成每一张牌 (52张)
for(String number : numbers){
for(String color : colors){
String p=color+number;
list.add(index);
map.put(index++,p);
}
}
//准备大王和小王
list.add(index);
map.put(index++,“大王”);
​
list.add(index);
map.put(index,“小王”);
​
//2.洗牌,洗牌洗的是编号
Collections.shuffle(list);
​
​
//3.发牌
//准备3个集合代表玩家，和1个集合代表底牌
TreeSet player1=new TreeSet<>();
TreeSet player2=new TreeSet<>();
TreeSet player3=new TreeSet<>();
TreeSet dipai=new TreeSet<>();
​
for(int i=0;i<list.size();i++){
Integer p=list.get(i);
//最后三张
if(i>=51){
dipai.add§;
}else{
if(i%30){
player1.add§;
}else if(i%31){
player2.add§;
}else if(i%3==2){
player3.add§;
}
}
}
​
//4.看牌,从map集合中找到编号对应的牌
lookPoker(map, player1);
lookPoker(map, player2);
lookPoker(map, player3);
lookPoker(map, dipai);
}
​
private static void lookPoker(HashMap<Integer, String> map, TreeSet player1) {
for (Integer key : player1) {
String poker = map.get(key);
System.out.print(poker + " ");
}
System.out.println();
}
}