JAVA总结 DAY017 1105

DAY017

一、Map

1.什么是Map
1、Map：双列集合的顶层接口
2、Map：单词含义，地图，地图上的每个点，都表示了生活中的一个具体位置。地图的点和生活中的位置，有一个一一对应的关系，这种关系是通过穷举的方式来描述的。
3、Map：描述的就是一个数据（key）到另一个数据（value）的映射关系（对应关系）
一个数据（key）：就是有规律的，容易记忆的，简单的一个数据
另一个数据（value）：没有规律的，不容易记忆的，复杂的一个数据
大多数都是根据key来寻找value
4、映射：对应关系
表达式方式：y = x * x
穷举罗列：{1=1, 2=4, 3=9, 4=16, 5=25,6=36,7=49}
5、java中Map就是使用的穷举罗列的方式来描述映射关系
6、Map的特点：
Key（键）是唯一的，value（值）不是唯一的
每个键都只能对应确定唯一的值
7、Map和Collection的区别：
Map是双列集合，Collection是单列集合
Map的键是唯一的，Collection中的Set子接口中的元素是唯一的
Map的所有操作和算法都是针对键有效，Collection中的set子接口中的操作和算法针对元素有效

2.Map中的常用方法
1、增加键值对：put(K key, V value)
2、删除方法：
根据给定的键，删除对应的键值对：remove(K key)
清空集合：clear()
3、获取方法：
获取集合的大小：size()，获取键值对对数
根据给定的键，获取对应的值：V get(K key)
4、判断方法：
判断集合中是否存在某个键：containsKey(Object obj)
判断集合中是否存在某个值：containsValue(Object obj)
5、修改方法：
根据给定的键，修改对应的值：put(K key, V value)
如果在集合中已经存在key这个键，那么使用put方法，就是修改其对应的值；如果集合中不存在key这个键，那么使用put方法，就是在集合中增加了一个键值对
代码示例

Map<String, String> map = new HashMap<>();
		// map中存数据的方法
		map.put("瞎子", "李青");
		System.out.println(map.get("瞎子"));
        // 获取map集合中键值对的对数
		System.out.println(map.size());
        // 清空
		map.clear();

3.Map集合的第一种遍历
1、获取Map集合中的所有键，放到一个Set集合中，遍历该Set集合，获取到每一个键，根据键再来获取对应的值。【根据键获取值】
2、获取Map集合中的所有键
Set keySet()
3、遍历Set集合的两种方法：
迭代器
增强for循环
4、拿到每个键之后，获取对应的值
V get(K key)
5、特点：
获取了所有的键的集合之后，仍然要依赖原来的Map集合
代码示例

public static void main(String[] args) {
        Map<String, Person> map = new HashMap<>();
        map.put("wuhan", new Person("zhangsan", 18));
        map.put("beijing", new Person("lisi", 20));
        map.put("shanghai", new Person("wangwu", 24));

        Set<String> set = map.keySet();
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()){
            String s = iter.next();
            System.out.println(s+"\t"+map.get(s));
        }

        for (String str:set){
            System.out.println(str+"\t"+map.get(str));
        }
    }

4.Map集合的第二种遍历思路
1、获取Map集合中的所有键值对对象（Entry），到Set集合中，遍历Set集合，拿到的是每个键值对对象（Entry），从这个对象中分别获取键和值。【根据键值对对象获取键和值】
2、根据Map集合获取所有的键值对对象，到一个Set集合中
Set<Map.Entry<K, V>> entrySet()
3、遍历Set集合，两种遍历方式
迭代器
增强for循环
4、获取到某个键值对对象
Entry是Map接口中的内部接口，访问的方式：Map.Entry
Entry：入口、条目、登记记录
Entry的常用方法：
getKey()获取当前键值对对象的键
getValue()获取当前键值对对象的值
代码示例

public static void main(String[] args) {
        Map<Integer, Person> map = new HashMap<>();
        map.put(1, new Person("zhangsan", 18));
        map.put(2, new Person("lisi", 19));
        map.put(3, new Person("wangwu", 20));
        Set<Map.Entry<Integer, Person>> set = map.entrySet();
        for (Map.Entry<Integer, Person> s:set){
            System.out.println(s.getKey()+"\t"+s.getValue());
        }
    }

嵌套Map集合的遍历代码示例

public static void main(String[] args) {
        Map<String, Person> map1 = new HashMap<>();
        map1.put("武汉", new Person("张三", 18));
        map1.put("北京", new Person("李四", 20));
        map1.put("上海", new Person("王五", 24));

        Map<String, Person> map2 = new HashMap<>();
        map2.put("武汉", new Person("赵六", 18));
        map2.put("北京", new Person("陈七", 20));
        map2.put("上海", new Person("黄八", 24));

        Map<String, Map<String, Person>> mapMap = new HashMap<>();
        mapMap.put("java", map1);
        mapMap.put("web",map2);

        Set<Map.Entry<String, Map<String, Person>>> set = mapMap.entrySet();
        Iterator<Map.Entry<String, Map<String, Person>>> iter = set.iterator();
        while (iter.hasNext()){
            Map.Entry<String, Map<String, Person>> entry = iter.next();
            String str = entry.getKey();
            System.out.println(str);
            Map<String, Person> map = entry.getValue();
            Set<Map.Entry<String, Person>> set1 = map.entrySet();
            Iterator iter1 = set1.iterator();
            while (iter1.hasNext()){
                Map.Entry<String, Person> entry1 = (Map.Entry<String, Person>) iter1.next();
                String str0 = entry1.getKey();
                Person p = entry1.getValue();
                System.out.println(str0+"\t"+p);

            }
        }
    }

5.HashMap
1、就是Map集合使用哈希表的存储方式的一种实现类
2、HashMap存储的是jdk中提供的类型的键，就可以直接保证键的唯一性
3、HashMap中存储的键，是自定义类型，无法保证键的唯一性；原因：虽然都是张三、23，但是这些对象并不是相同的对象，这些对象的哈希值计算结果各不相同，就说明一定不是相同的对象，所以无法保证键的唯一。重写hashCode和equals方法
说明：HashMap的键的唯一性和HashSet的元素的唯一性，保证方式都一样
4、HashMap和HashSet的关系：
1、HashSet是由HashMap实现出来的，HashSet就是HashMap的键的那一列
2、将HashMap中的值的那一列隐藏掉，就变成了HashSet
代码示例

    @Override
	public int hashCode() {
		final int prime = 31;//张三，23
		int result = 1;
		result = prime * result + age;//54
		//31*54 + name.hashCode();
		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;
		Person other = (Person) 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;
	}

6.LinkedHashMap
1、是HashMap的一个子类
2、和HashMap的不同之处在于，具有可预知的迭代顺序，存储键值对的顺序和遍历集合时取出键值对的顺序一致。

7.HashMap和Hashtable的关系
1、HashMap和Hashtable都是用于存储键和值的对应关系，都是Map的实现类，都是使用哈希表的方式存储。
2、不同点：
1、版本不同，Hashtable是jdk1.0版本出现的，HashMap是jdk1.2版本出现的
2、线程安全性不同，Hashtable是线程安全的，HashMap是线程不安全的
3、Hashtable不能存储null键null值，HashMap可以存储null键null值
4、命名规则：Hashtable时期没有形成完全严格的命名要求

二、Collections工具类

1、int binarySearch(List list, E e )：在一个有升序顺序的List集合中，通过二分查找寻找元素e的索引
2、fill(List list, E e)：将list集合中的所有元素都填充为元素e
3、int frequency(Collection c, E e)：返回在集合c中的元素e的个数
4、max、min：获取集合的最大值或者最小值
5、replaceAll(List list, E oldVal, E newVal)：将集合list中的所有指定老元素oldVal都替换成新元素newVal
6、reverse(List list)：将参数集合list进行反转
7、shuffle(List list)：将list集合中的元素进行随机置换
8、swap(List list, int a, int b)：将a索引和b索引的元素进行交换
9、synchronizedXxx方法系列：将一个线程不安全的集合传入方法，返回一个线程安全的集合
代码示例

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(2);
        list.add(8);
        list.add(8);
        list.add(10);
        list.add(9);
        list.add(13);

        //  System.out.println(Collections.binarySearch(list, 8));
        List list1 = new ArrayList();
        list1.add(3);
        list1.add(7);
        list1.add(11);

        /*Collections.copy(list,list1);
        System.out.println(list);
        System.out.println(list1);*/
        // Collections.fill(list,100);
        //System.out.println(Collections.min(list));
        // Collections.replaceAll(list, 8, 7);
        // Collections.shuffle(list);
        // Collections.sort(list);
        Collections.swap(list,0,1);
        System.out.println(list);

    }

三、斗地主的制牌、洗牌和发牌

1、思路：
1、制牌：1~K一共13个数字，四个花色，4 * 13张牌，小王、大王
2、洗牌：shuffle将集合中的字符串随机置换
3、发牌：将一个集合中的元素，分发到3个集合中
4、通过穷举，手动将所有牌面的大小，全都定义出来，每个牌面上的字符串，都可以对应一个其在扑克牌中的大小的数字（字符串和数字的对应关系）
5、可以给牌面的大小排序，对应到某个牌面

2.代码示例

public static void main(String[] args) {
        //定义两个数组分别储存花色和面值
        String[] huase = {"♠", "♥", "♣", "♦"};
        String[] nums = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K","A", "2"};
        //map集合为54张扑克牌的容器 键值对应0-53索引
        Map<Integer, String> map = new HashMap<>();
        //List集合储存Map集合的键值
        List<Integer> list = new ArrayList<>();
        int index = 0;
        //制牌，通过嵌套for循环产生除大小王的52张牌
        for (int i=0;i<nums.length;i++){
            for (int j=0;j<huase.length;j++){
                String s = huase[j]+nums[i];
                map.put(index, s);
                list.add(index);
                index++;
            }
        }
        //将大小王添加至集合
        map.put(index,"小王");
        list.add(index);
        map.put(index + 1, "大王");
        list.add(index + 1);

        // 使用shuffle 洗牌
        Collections.shuffle(list);
        //声明4个集合作为底牌和三个玩家的容器
        List<Integer> dipai = new ArrayList<>();
        List<Integer> wanjia1 = new ArrayList<>();
        List<Integer> wanjia2 = new ArrayList<>();
        List<Integer> wanjia3 = new ArrayList<>();

        //发牌 发的是每张牌在Map集合中的索引
        for (Integer i = 0; i < list.size(); i++) {
            if (i<3){
                dipai.add(list.get(i));
            }else if (i % 3==0){
                wanjia1.add(list.get(i));
            } else if (i % 3==1) {
                wanjia2.add(list.get(i));
            }else if (i % 3 ==2){
                wanjia3.add(list.get(i));
            }
        }

        //将每张牌按照顺序排列
        Collections.sort(dipai);
        Collections.sort(wanjia1);
        Collections.sort(wanjia2);
        Collections.sort(wanjia3);

        //调用显示方法  将每个玩家的所有牌输出出来
        System.out.println(look("wanjia1",wanjia1,map));
        System.out.println(look("wanjia2",wanjia2,map));
        System.out.println(look("wanjia3",wanjia3,map));
        System.out.println(look("底牌",dipai,map));
    }

    //将每个人的牌对应上Map集合中牌的面值
    public static String look(String name,List<Integer> list,Map<Integer, String> map){
        String str = "";
        for (int i = 0;i<list.size();i++){
            str+=map.get(list.get(i));
        }
        return name+":"+str;
    }

运行结果