2019-05-27 Java学习日记之Map集合&模拟斗地主洗牌发牌

Map集合

Map集合的概述和特点：

A：概述

将键映射到值的对象

一个映射不能包含重复的键

每个 键最多只能映射到一个值

B：Map接口和Collection接口的不同

Map是双列的，Collection是单列的

Map的键唯一，Collection的子体系Set是唯一的

Map集合的数据结构值针对键有效，跟值无关；Collection集合的数据结构是针对元素有效

Map集合的功能概述：

a：添加功能

　　V put（K key，V value）：添加元素

　　　　如果键是第一次存储，就直接存储元素，返回null

　　　　如果键不是第一次存储，就用值把以前的值替换掉，返回以前的值

b：删除功能

void clear（）：移除所有的键值对元素

V remove（Object key）：根据键删除键值对元素，并把值返回

c：判断功能

boolean containsKey（Object key）：判断集合是否包含指定的键

boolean containsValue（Object value）：判断集合是否包含指定的值

boolean isEmpty（）：判断集合是否为空

d：获取功能

Set<Map.Entry<K，V>> entrySet（）：

V get（Object key）：根据键获取值

Set<K> keySet（）：获取集合中所有键的集合

Collection<V> values()：获取集合中所有值得集合

e：长度功能

int size（）：返回集合中的键值对的个数

Demo：

package com.map;

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

public class Demo1 {

    public static void main(String[] args) {
//        demo1();
//        demo2();
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
        
        Collection<Integer> c = map.values();
        System.out.println(c);
        System.out.println(map.size());
    }

    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
        
        //Integer value = map.remove("张三");                //根据键删除元素，返回键对应的值
        //System.out.println(value);
        System.out.println(map.containsKey("张三"));        //判断是否包含传入的键
        System.out.println(map.containsValue(100));        //判断是否包含传入的
        System.out.println(map);
    }

    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 23);
        Integer i2 = map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("赵六", 26);
        Integer i5 = map.put("张三", 26);            //相同的键不存储，值覆盖，吧覆盖的值返回
        
        System.out.println(map);
        
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }

}

Map集合的遍历之键找值：

A：键找值思路

获取所有键的集合

遍历键的集合，获取到每一个键

根据键找值

B：Demo

package com.map;

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

public class Demo2 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
        
        //Integer i = map.get("张三");        //根据键获取值
        //System.out.println(i);
        
        //获取所有的键
        /*Set<String> keySet = map.keySet();    //获取所有键的集合
        Iterator<String> it = keySet.iterator();    //获取迭代器
        while (it.hasNext()) {                //判断集合中是否有元素
            String key = it.next();            //获取每一个键
            Integer value = map.get(key);    //根据键获取值
            System.out.println(key + "=" +value);
        }*/
        
        //使用增强for循环遍历
        for (String key : map.keySet()) {        //map.keySet()是所有键的集合
            System.out.println(key + "=" + map.get(key));
        }
    }

}

 Map集合的遍历值键值对对象找键和值：

A：键值对对象找键和值思路

获取所有键值对对象的集合

遍历键值对对象的集合，获取到每一个键值对对象

根据键值对对象找键和值

B：Demo

package com.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo3 {
    /**
     * Map集合的第二种迭代，根据键值对对象，获取键和值
     */
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        // Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象，并存储在Set中
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //获取每一个对象
        /*Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while (it.hasNext()) {
            //获取每一个Entry对象
            Map.Entry<String, Integer> en = it.next();
            String key = en.getKey();                    //根据键值对对象获取键
            Integer value = en.getValue();                //根据键值对对象获取值
            System.out.println(key + "=" + value);
        }*/
        
        for (Map.Entry<String, Integer> en : entrySet) {
            System.out.println(en.getKey() + "=" + en.getValue());
        }
        
    }
}

HashMap集合键是Student值是String的案例：

package com.map;

import java.util.HashMap;

import com.bean.Student;

public class Demo4 {
    /**
     * HashMap集合键是Student值是String的案例：
     * 键是学生对象，代表每一个学生
     * 值是字符串对象，代表学生归属地
     */
    public static void main(String[] args) {
        HashMap<Student,String> hm = new HashMap<>();
        hm.put(new Student("张三",23),"北京" );
        hm.put(new Student("李四",23),"上海" );
        hm.put(new Student("王五",25),"广州" );
        hm.put(new Student("赵六",26),"深圳" );
        
        System.out.println(hm);
    }

}

LinkedHashMap的概述和使用：

特点：

底层是链表实现的可以保证怎么存就怎么取

package com.map;

import java.util.LinkedHashMap;

public class Demo5 {

    public static void main(String[] args) {
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
        lhm.put("张三", 23);
        lhm.put("李四", 24);
        lhm.put("王五", 25);
        lhm.put("赵六", 26);
        
        System.out.println(lhm);
    }

}

TreeMap集合键是Student值是String的案例：

package com.map;

import java.util.Comparator;
import java.util.TreeMap;

import com.bean.Student;

public class Demo6 {

    public static void main(String[] args) {
        TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getName().compareTo(s2.getName());        //按照姓名排序
                return num == 0 ? s1.getAge() - s2.getAge() : num;
            }
        });
        tm.put(new Student("张三",23),"北京" );
        tm.put(new Student("王五",35),"广州" );
        tm.put(new Student("李四",13),"上海" );
        tm.put(new Student("赵六",46),"深圳" );
        
        System.out.println(tm);
    }

}

统计字符串中每个字符出现的次数：

package com.test;

import java.util.HashMap;

public class Test1 {
    /**
     * 需求：统计字符串中每个字符出现的次数
     * 分析：
     * 1、定义一个需要被统计字符的字符串
     * 2、将字符串转换为字符数组
     * 3、定义双列集合，存储字符串中字符一级字符出现的次数
     * 4、遍历字符数组获取每一个字符，并将字符存储在双列集合中
     * 5、存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储
     * 6、打印双列集合获取字符出现的次数
     */
    public static void main(String[] args) {
        //1、定义一个需要被统计字符的字符串
        String s = "aaaaaabbbbbcccccccc";
        //2、将字符串转换为字符数组
        char[] arr = s.toCharArray();
        //3、定义双列集合，存储字符串中字符一级字符出现的次数
        HashMap<Character, Integer> hm = new HashMap<>();
        //4、遍历字符数组获取每一个字符，并将字符存储在双列集合中
        for (char c : arr) {
            //5、存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储
            /*if (!hm.containsKey(c)) {    //如果不包含这个键
                hm.put(c, 1);
            }else {
                hm.put(c, hm.get(c) + 1);
            }*/
            hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
        }
        //6、打印双列集合获取字符出现的次数
        for (Character key : hm.keySet()) {                //hm.keySet()代表所有键的集合
            System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
        }
    }

}

HashMap和Hashtable的区别：

A：面试题

区别：

Hashtable是JDK1.0版本出现的，是线程安全的，效率低，HashMap是JDK1.2版本出现的，是线程不安全的，效率高

Hashtable不可以存储null键和null值，HashMap可以存储null键和null值

B：Demo

package com.map;

import java.util.HashMap;
import java.util.Hashtable;

public class Demo7 {
    public static void main(String[] args) {
        
        HashMap<String, Integer> hm = new HashMap<>();
        hm.put(null, 23);
        hm.put("张三", null);
        System.out.println(hm);
        
        Hashtable<String, Integer> ht = new Hashtable<>();
        ht.put(null, 23);
        ht.put("张三", null);
        System.out.println(ht);
    }
}

    Collection工具类的概述和常见方法：

A：概述

针对集合操作的工具类

B：成员方法

public static <T> void sort(List<T> list)

public static <T> int binarySearch(List<?> list,T key)

public static <T> T max(Collection<?> coll)  

public static void reverse(List<?> list)

public static void shuffle(List<?> list)

C：Demo

package com.collection;

import java.util.ArrayList;
import java.util.Collections;

public class Demo1 {

    public static void main(String[] args) {
//        demo1();
//        demo2();
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("h");
        list.add("f");
        list.add("g");
        System.out.println(Collections.max(list));        //根据默认排序结果获取集合中的最大值
//        Collections.reverse(list);                        //反转集合
        Collections.shuffle(list);                        //随机置换，可以用来洗牌    
        System.out.println(list);                         
    }

    public static void demo2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
        
        System.out.println(Collections.binarySearch(list, "c"));
        System.out.println(Collections.binarySearch(list, "b"));
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("d");
        list.add("a");
        list.add("c");
        list.add("b");
        list.add("c");
        
        System.out.println(list);
        Collections.sort(list);     //将集合排序
        System.out.println(list);
    }

}

模拟斗地主洗牌和发牌

模拟斗地主洗牌和发牌，牌没有排序：

package com.test;

import java.util.ArrayList;
import java.util.Collections;

public class Test2 {
    /**
     * 模拟斗地主洗牌和发牌，牌没有排序
     * 
     * 分析：
     * 1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去
     * 2、洗牌
     * 3、发牌
     * 4、看牌
     */
    public static void main(String[] args) {
        //1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] color = {"红桃","黑桃","方块","梅花"};
        ArrayList<String> poker = new ArrayList<>();
        
        //拼接花色和数字
        for (String s1 : color) {
            for (String s2 : num) {
                poker.add(s1.concat(s2));         //concat连接两个字符串
            }
        }
        poker.add("小王");
        poker.add("大王");
        //2、洗牌
        Collections.shuffle(poker);
        //3、发牌
        ArrayList<String> tan = new ArrayList<>();
        ArrayList<String> zhou = new ArrayList<>();
        ArrayList<String> chen = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        
        for (int i = 0; i < poker.size(); i++) {
            if (i >= poker.size() - 3) {
                dipai.add(poker.get(i));         //将三张底牌存储在底牌集合中
            }else if (i % 3 == 0) {
                tan.add(poker.get(i));
            }else if (i % 3 == 1) {
                zhou.add(poker.get(i));
            }else {
                chen.add(poker.get(i));
            }
        }
        //4、看牌
        System.out.println(tan);
        System.out.println(zhou);
        System.out.println(chen);
        System.out.println(dipai);
    }

}

模拟斗地主洗牌和发牌并对牌进行排序：

package com.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Test3 {
    /**
     * 模拟斗地主洗牌和发牌，牌没有排序
     * 
     * 分析：
     * 1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去
     * 2、洗牌
     * 3、发牌
     * 4、看牌
     */
    public static void main(String[] args) {
        //1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] color = {"方块","梅花","红桃","黑桃"};
        HashMap<Integer, String> hm = new HashMap<>();            //存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<>();            //存储索引
        int index = 0;
        
        //拼接扑克牌并索引和扑克牌存储在hm中
        for (String s1 : num) {                                    //获取数字    
            for (String s2 : color) {                            //获取颜色
                hm.put(index, s2.concat(s1));
                list.add(index);    
                index++;            
            }
        }
        //将小王添加到双列集合中
        hm.put(index, "小王");
        list.add(index);                                        //将52索引添加到集合中
        index++;
        hm.put(index, "大王");
        list.add(index);                                        //将53索引添加到集合中
        
        //2、洗牌
        Collections.shuffle(list);
        //3、发牌
        TreeSet<Integer> tan = new TreeSet<>();
        TreeSet<Integer> zhou = new TreeSet<>();
        TreeSet<Integer> chen = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();
        
        for (int i = 0; i < list.size(); i++) {
            if (i >= list.size() - 3) {
                dipai.add(list.get(i));         //将三张底牌存储在底牌集合中
            }else if (i % 3 == 0) {
                tan.add(list.get(i));
            }else if (i % 3 == 1) {
                zhou.add(list.get(i));
            }else {
                chen.add(list.get(i));
            }
        }
        //4、看牌
        lookPoker(hm, tan, "谭");
        lookPoker(hm, zhou, "周");
        lookPoker(hm, chen, "陈");
        lookPoker(hm, dipai, "底牌");
        
    }
    /**
     * 看牌
     * 分析：
     * 1、返回值类型void
     * 2、参数列表HashMap，TreeSet，String name
     */
    public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts , String name){
        System.out.print(name + "的牌是：");
        for (Integer i : ts) {        //i代表双列集合中的每一个键
            System.out.print(hm.get(i) + " ");
        }
        System.out.println();
    }
}

泛型固定下边界：

package com.collection;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

import com.bean.BaseStudent;
import com.bean.Student;

public class Demo2 {
    /**
     * 泛型固定下边界
     * ？ super E
     * 
     * 泛型固定上边界
     * ？ extends E
     */
    public static void main(String[] args) {
//        demo1();
        TreeSet<Student> ts1 = new TreeSet<>(new CompareByAge());
        ts1.add(new Student("张三",32));
        ts1.add(new Student("李四",12));
        ts1.add(new Student("王五",42));
        ts1.add(new Student("赵六",22));
        
        TreeSet<BaseStudent> ts2 = new TreeSet<>(new CompareByAge());
        ts2.add(new BaseStudent("张三",32));
        ts2.add(new BaseStudent("李四",12));
        ts2.add(new BaseStudent("王五",42));
        ts2.add(new BaseStudent("赵六",22));
        
        System.out.println(ts2);
    }

    public static void demo1() {
        ArrayList<Student> list1 = new ArrayList<>();
        list1.add(new Student("张三",23));
        list1.add(new Student("李四",24));
    
        ArrayList<BaseStudent> list2 = new ArrayList<>();
        list2.add(new BaseStudent("王五",25));
        list2.add(new BaseStudent("赵六",26));
        
        list1.addAll(list2);
    }

}
class CompareByAge implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        int num = s1.getAge() - s2.getAge();
        return num == 0 ? s1.getName().compareTo(s2.getName()) : num;
    }
    
}

Student.java

package com.bean;

import javax.swing.plaf.nimbus.NimbusLookAndFeel;

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.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 String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) {
        int num = this.age - o.age;
        return num == 0 ? this.name.compareTo(o.name) : num;
    }
    
}

BaseStudent.java

package com.bean;

public class BaseStudent extends Student {

    public BaseStudent() {
    }

    public BaseStudent(String name, int age) {
        super(name, age);
    }

}