javase笔记day18

Map集合

Map接口和Collection接口的不同
	Map是双列的,Collection是单列的
	Map的键唯一,Collection的子体系Set是唯一的
	Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
	
A：HashMap集合底层是哈希表/散列表的数据结构
B：哈希表是一个数组和单链表的结合体（数组查询效率高，增删效率低，链表增删效率高，查询效率低）哈希表充分发挥他们各自的优点

Map集合的方法

V put(K key,V value):添加元素
			如果键是第一次存储，就直接存储元素，返回null
			如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
			
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回

boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空

Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合

int size()：返回集合中的键值对的对数

import java.util.*;

public class MapTest1 {
    public static void main(String[] args) {
        //创建Map集合
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"aaa");
        map.put(2,"bbb");
        map.put(3,"ccc");
        map.put(4,"ddd");
        map.put(5,"eee");
        map.put(6,"eee");

        //删除元素
        map.remove(6);//删去key为6的元素，并返回值

        //判断集合是否包含指定的键
        boolean b = map.containsKey(4);
        System.out.println(b);//true

        //判断集合是否包含指定的值
        boolean bbb = map.containsValue("bbb");
        System.out.println(bbb);//true

        //判断集合是否为空
        boolean empty = map.isEmpty();
        System.out.println(empty);//false

        //返回集合中的键值对的对数
        System.out.println(map.size());//5


        //遍历方式1(通过key获取value)
        //获取集合中所有键的集合
        Set<Integer> keySet = map.keySet();
        //迭代器
        Iterator<Integer> it = keySet.iterator();
        while (it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key + "==" + value);
        }

        System.out.println("==========");
        //增强for
        for (Integer keys : keySet){
            String value = map.get(keys);
            System.out.println(keys + "==" + value);
        }


        System.out.println("==========");

        //遍历方式2（转换成set集合）
        //返回一个键值对的Set集合
        Set<Map.Entry<Integer, String>> mapSet = map.entrySet();

        //调用set迭代器
        Iterator<Map.Entry<Integer, String>> it1 = mapSet.iterator();
        while (it1.hasNext()) {

            Map.Entry<Integer, String> node = it1.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key + "===" + value);
        }

        //增强for
        for (Map.Entry<Integer,String> node1 : mapSet){
            System.out.println(node1);

            //Integer key = node1.getKey();
            //String value = node1.getValue();
        }

    }
}

public class MyTest5 {
    public static void main(String[] args) {
        //创建hashmap集合
        HashMap<Student, String> hm = new HashMap<>();
        hm.put(new Student("张三", 23), "s001");
        hm.put(new Student("张三", 23), "s002");
        hm.put(new Student("李四", 24), "s003");
        hm.put(new Student("王五", 25), "s004");

        //遍历
        Set<Student> students = hm.keySet();
        for (Student key : students) {
            String value = hm.get(key);
            System.out.println(key.getName()+"=="+key.getAge()+"==="+value);
        }
        System.out.println("============================");
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> en : entries) {
            Student key = en.getKey();
            String value = en.getValue();
            System.out.println(key.getName() + "==" + key.getAge() + "===" + value);
        }
        System.out.println("===============================");
        hm.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student key, String value) {
                System.out.println(key.getName() + "==" + key.getAge() + "===" + value);
            }
        });
    }
}
class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    public int compareTo(Student s) {
        //按照年龄大小来排序
        int num = this.age - s.age;
        //年龄一样并不能说明是同一个对象，还得比较姓名
        int num2=num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

HashMap和HashTable

HashMap 允许 null值和 null键。线程不安全效率高
Hashtable 不允许存储null值和null键 线程安全效率低
    
    HashMap<Object, Object> hm = new HashMap<>();
        hm.put(null,"abc");
        hm.put("aaa",null);
        hm.put(null,null);
        System.out.println(hm);

        Hashtable<Object, Object> hashtable = new Hashtable<>();
        //hashtable.put("abc",null); 不允许键或者值 为 null

LinkedHashMap

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
LinkedHashMap的特点： 
	底层的数据结构是链表和哈希表 元素有序 并且唯一
	元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
	Map集合的数据结构只和键有关
			

TreeMap

键的数据结构是红黑树,可保证键的排序和唯一性  
	    排序分为自然排序和比较器排序 
	    线程是不安全的效率比较高

package org.westos.作业;

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

public class TreeMapTest1 {
    public static void main(String[] args) {
        //创建TreeMap集合
        TreeMap<Student,String > treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getAge() - o2.getAge();
                int j = i == 0 ? o1.getName().compareTo(o2.getName()) : i;
                return j;
            }
        });

        treeMap.put(new Student("马云",55),"aaa");
        treeMap.put(new Student("马超",985),"bbb");
        treeMap.put(new Student("马画藤",45),"ccc");
        treeMap.put(new Student("高司令",25),"ddd");

        System.out.println(treeMap);
    }
}
class Student{
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 +
                '}';
    }
}

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

package org.westos.作业;

import java.util.HashMap;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
          /* A:
        案例演示:
        作业：你自己先做
        需求：统计字符串中每个字符出现的次数
        "aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)*/
        Scanner sc = new Scanner(System.in);
        System.out.println("请随便输入一段字符串");
        String s = sc.nextLine();
        // 我们最后得到的字符传  a(3)b(3)c(3)d(2)
        //你可以用到双列集合来做

        //输入的字符串转换为字符数组
        //String s = "aaabbbcccdd";
        char[] ch = s.toCharArray();


        //创建HashMap集合
        HashMap<Character, Integer> hashMap = new HashMap<>();

        //遍历字符
        for (char c : ch) {
            //aaabbbcccdd如果HashMap中无当前字符，则添加进去,1作为第一个存进去的起始值
            if (!hashMap.containsKey(c)) {
                hashMap.put(c, 1);
            } else {
                //如果存在当前字符，则覆盖，然后值加1
                hashMap.put(c, hashMap.get(c) + 1);
            }
        }

        //获取HashMap中的所有键
        //Set<Character> keySet = hashMap.keySet();

        //System.out.println(key);
        //字符拼接
        StringBuilder sb = new StringBuilder();
        //遍历所有键
        for (Character key : hashMap.keySet()) {
            //System.out.println(hashMap.get(key));

            sb.append(key).append("(").append(hashMap.get(key)).append(")");
        }

        System.out.println(sb);


    }
}

HashMap嵌套HashMap

基础班
					张三		20
					李四		22
				就业班
					王五		21
					赵六		23
package org.westos.作业;

import java.util.HashMap;
import java.util.Set;

public class Test2 {
    public static void main(String[] args) {
     
        //基础班集合
        HashMap<String, Integer> jcMap = new HashMap<>();
        //添加
        jcMap.put("张三",20);
        jcMap.put("李四",22);
        //就业班集合
        HashMap<String, Integer> jyMap = new HashMap<>();

        jyMap.put("王五",21);
        jyMap.put("赵六",23);

        HashMap<String, HashMap<String, Integer>> allMap = new HashMap<>();
        allMap.put("基础班",jcMap);
        allMap.put("就业班",jyMap);

        //获取总的集合中的键的集合
        Set<String> keySet = allMap.keySet();
        //遍历键的集合
        for (String s : keySet) {
            //输出键
            System.out.println(s);
            //获取值（这个值是一个集合）
            HashMap<String, Integer> stu = allMap.get(s);

            //获取上一个值集合中的所有的键
            Set<String> keySet1 = stu.keySet();
            //遍历所有的键
            for (String s1 : keySet1) {
                //输出键和输出调用获取值
                System.out.println("\t" + s1 + "\t"+ stu.get(s1));
            }
            System.out.println();
        }

    }
}

HashMap嵌套ArrayList

	集合嵌套之HashMap嵌套ArrayList
		
	假设HashMap集合的元素是ArrayList。有3个。
	每一个ArrayList集合的值是字符串。

	三国演义
	 	吕布
	 	周瑜
	 笑傲江湖
	 	令狐冲
	 	林平之
	 神雕侠侣
	 	郭靖
	 	杨过  
package org.westos.作业;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class Test3 {
    public static void main(String[] args) {
        ArrayList<String> aList = new ArrayList<>();
        aList.add("吕布");
        aList.add("周瑜");

        ArrayList<String> aList1 = new ArrayList<>();
        aList1.add("令狐冲");
        aList1.add("林平之");

        ArrayList<String> aList2 = new ArrayList<>();
        aList2.add("郭靖");
        aList2.add("黄蓉");

        HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
        hashMap.put("三国演义",aList);
        hashMap.put("笑傲江湖",aList1);
        hashMap.put("神雕侠侣",aList2);

        Set<String> keySets = hashMap.keySet();
        for (String s : keySets) {
            System.out.println(s);

            ArrayList<String> value = hashMap.get(s);
            for (int i = 0; i < value.size() ; i++) {

                System.out.println("\t" + value.get(i));

            }

        }

    }
}

ArrayList嵌套HashMap

集合嵌套之ArrayList嵌套HashMap
	
	假设ArrayList集合的元素是HashMap。有3个。
	每一个HashMap集合的键和值都是字符串。

	 周瑜---小乔
	 吕布---貂蝉

	 郭靖---黄蓉
	 杨过---小龙女

	 令狐冲---任盈盈
	 林平之---岳灵珊
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MyTest3 {
    public static void main(String[] args) {
        HashMap<String, String> sgMap = new HashMap<>();
        sgMap.put("周瑜","小乔");
        sgMap.put("吕布", "貂蝉");

        HashMap<String, String> sdMap = new HashMap<>();
        sdMap.put("郭靖", "黄蓉");
        sdMap.put("杨过", "小龙女");

        HashMap<String, String> xaMap = new HashMap<>();
        xaMap.put("令狐冲", "任盈盈");
        xaMap.put("林平之", "岳灵珊");

        ArrayList<HashMap<String, String>> bigList = new ArrayList<>();
        bigList.add(sgMap);
        bigList.add(sdMap);
        bigList.add(xaMap);

        //遍历
        for (HashMap<String, String> hashMap : bigList) {
            Set<Map.Entry<String, String>> entries = hashMap.entrySet();
            for (Map.Entry<String, String> en : entries) {
                String key = en.getKey();
                String value = en.getValue();
                System.out.println(key+"------"+value);
            }
            System.out.println();
        }
    }
}

Collections

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):随机置换

斗地主思路

模拟斗地主洗牌和发牌

模拟斗地主洗牌和发牌并对牌进行排序的代码实现
    package org.westos.demo92;

import java.util.ArrayList;
import java.util.Collections;
public class 斗地主 {
    public static void main(String[] args) {
        //先得有一副牌
        //先创建一个集合充当牌盒子
        ArrayList<String> pokerBox = new ArrayList<>();
        //生成54张牌放进牌盒子
        String[] colors={"♠","♥","♦","♣"};
        String[] nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        //向集合中添加元素
        for (String color : colors) {
            for (String num : nums) {
                //将nums连接到花色后面
                String poker = color.concat(num);
                pokerBox.add(poker);
            }
        }
        //手动添加大小王
        pokerBox.add("☀");
        pokerBox.add("☼");

        //洗牌三次
        Collections.shuffle(pokerBox);
        Collections.shuffle(pokerBox);
        Collections.shuffle(pokerBox);

        //发牌：得有三个人来斗地主，还得留三张底牌
        ArrayList<String> 星仔 = new ArrayList<>();
        ArrayList<String> 刀仔 = new ArrayList<>();
        ArrayList<String> 高进 = new ArrayList<>();
        ArrayList<String> 底牌 = new ArrayList<>();


        Collections.sort(星仔);

        //发牌方式1： 一人数个10来张发给你
        // 星仔 = (ArrayList<String>) pokerBox.subList(0, 11);

        // 方式2：传统发牌 一人一张转着发
        //用牌的索引对3取余
      /*  星仔 0 3 6 9   余数 0
        刀仔 1 4 7 10  余数 1
        高进 2 5 8  11  余数 2 */

        for (int i = 0; i < pokerBox.size(); i++) {
            //留底牌
            if(i>=pokerBox.size()-3){
                底牌.add(pokerBox.get(i));
            }else if(i%3==0){
                星仔.add(pokerBox.get(i));
            } else if (i % 3 == 1) {
                刀仔.add(pokerBox.get(i));
            }else{
                高进.add(pokerBox.get(i));
            }
        }

        //Collections.sort(星仔);

        //看牌
        lookPoker("星仔",星仔);
        lookPoker("刀仔",刀仔);
        lookPoker("高进",高进);
        lookPoker("底牌",底牌);

        //作业：做一个斗地主排序版，牌发好之后，从小到大排好

    }

    private static void lookPoker(String name, ArrayList<String> list) {
        System.out.println(name);
        for (String poker : list) {
            System.out.print(poker+"\t");
        }
        System.out.println();


    }
}

按照大小顺序

package org.westos.作业;

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

public class Test8 {

}
class Demo3 {
    public static void main(String[] args) {
        //定义一个map集合存放牌和索引
        TreeMap<Integer, String> pokers = new TreeMap<>();
        //向集合中存储元素
        String[] color = {"♥","♠","♣","♦"};
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        //创建一个list数组存放map中 键的集合
        ArrayList<Integer> indexs = new ArrayList<>();

        //定义一个索引
        int index=0;
        for (String numbers : number) {//先遍历数字，再为每个数字配上4中花色
            for (String colors : color) {
                pokers.put(index, colors.concat(numbers));
                //向list数组中存放键
                indexs.add(index);
                index++;//每次添加一张牌的时候索引页加1
            }
        }
        System.out.println(index);

        //添加大王 index++是先用后加添加大王的时候先不用加1
        pokers.put(index,"大王");
        indexs.add(index);

        index++;
        pokers.put(index,"小王");
        indexs.add(index);

        //洗牌
        Collections.shuffle(indexs);

        //创建treeset集合存放每一个斗地主的人的牌
        TreeSet<Integer> 星仔 = new TreeSet<>();
        TreeSet<Integer> 刀仔 = new TreeSet<>();
        TreeSet<Integer> 高进 = new TreeSet<>();
        TreeSet<Integer> 底牌 = new TreeSet<>();

        //每一个人的牌通过观察可以发现分别是3余0，1，2
        for (int i = 0; i < indexs.size(); i++) {
            if (i>=indexs.size()-3) {
                底牌.add(indexs.get(i));
            }else if(i%3==0){
                星仔.add(indexs.get(i));
            }else if (i%3==1) {
                刀仔.add(indexs.get(i));
            }else if (i%3==2) {
                高进.add(indexs.get(i));
            }
        }
        //由于要实现对3个人的加底牌的排序，所以为了简化代码，创建一个方法进行调用
        lookPoker("星仔",星仔,pokers);
        lookPoker("刀仔",刀仔,pokers);
        lookPoker("高进",高进,pokers);
        lookPoker("底牌",底牌,pokers);
    }

    private static void lookPoker(String name, TreeSet<Integer> indexs,TreeMap<Integer, String> pokers){
        System.out.print(name+"的牌是：");
        //遍历每一个人的牌也就是TreeSet集合，同时利用索引相同的特点，在TreeMap集合中找到索引对应的牌
        for (Integer index : indexs) {
            System.out.print(pokers.get(index)+"\t"); //将牌输出
        }
        System.out.println();//在输出一个人的牌后换行
        /*
        private static void lookPoker(String name, ArrayList<String> list) {
        System.out.println(name);
        for (String poker : list) {
            System.out.print(poker+"\t");
        }
        System.out.println();
         */
    }
}