集合（3）

集合（3）

一、Map集合

键存在一个，值可以多个

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> m = new HashMap<String, String>();
        m.put("12345","陈");//V put(K key, V value) 将指定的值与该映射中的指定键相关联
        m.put("12345","额");//替换陈，键唯一性
        m.put("123456","林");
        m.put("123457","叶");
        System.out.println(m);
    }
}

Map基本功能

V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数

Map获取功能

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

public class MapDemo01 {
    public static void main(String[] args) {
        Map<String,String> m = new HashMap<String, String>();
        m.put("一","一一");
        m.put("二","二二");
        m.put("三","三三");
        m.put("四","四四");
        m.remove("一");
//        m.clear();
        System.out.println(m.containsKey("二"));
        System.out.println(m.containsValue("二二"));
        System.out.println(m.isEmpty());
        System.out.println(m.size());
        m.get("二");
        Set<String> set = m.keySet();
        for (String sb:set) {
            System.out.println(sb);
        }
        Collection<String> values = m.values();
        for (String s:values) {
            System.out.println(s);
        }
        System.out.println(m);
    }
}

Map集合遍历

法一：

public class MapDemo02 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();
        m.put("一", "一一");
        m.put("二", "二二");
        m.put("三", "三三");
        m.put("四", "四四");
        //遍历Map集合
        Set<String> keyset = m.keySet();
        for (String s : keyset) {
            String value = m.get(s);
            System.out.println(s + "," + value);
        }
    }
}

法二：Set<Map.Entry<K,V>> entrySet()

public class MapDemo03 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();
        m.put("一", "一一");
        m.put("二", "二二");
        m.put("三", "三三");
        m.put("四", "四四");
        Set<Map.Entry<String, String>> entrySet = m.entrySet();//利用方法
        for (Map.Entry<String, String> s : entrySet) { //把<>里当整体类型
            String key = s.getKey();//getKey和getValue获取键值
            String value = s.getValue();
            System.out.println(key + "," + value);
        }
    }
}

二、案例：创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历

public class 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;
    }
}

public class MapDemo04 {
    public static void main(String[] args) {
        Map<String, Student> m = new HashMap<String, Student>();
        Student s1 = new Student("李白", 23);
        Student s2 = new Student("苏轼", 43);
        Student s3 = new Student("杜甫", 33);
        m.put("12345", s1);
        m.put("23456", s2);
        m.put("34567", s3);
        //遍历方法一
//        Set<String> keySet = m.keySet();
//        for (String s:keySet) {
//            Student value = m.get(s);
//            System.out.println(s+","+value.getName()+","+value.getAge());
//        }
        //遍历方法二
        Set<Map.Entry<String, Student>> entrySet = m.entrySet();
        for (Map.Entry<String, Student> value : entrySet) {
            String key = value.getKey();
            Student value1 = value.getValue();
            System.out.println(key + "," + value1.getAge() + "," + value1.getName());
        }
    }
}

三、案例：创建一个 HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。

要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

public class 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 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 HashMapDemo {
    public static void main(String[] args) {
        HashMap<Student, String> hm = new HashMap<Student, String>();
        Student s1 = new Student("杨满", 28);
        Student s2 = new Student("武德", 29);
        Student s3 = new Student("林", 99);
        Student s4 = new Student("林", 99);
        hm.put(s1, "北京");
        hm.put(s2, "福鼎");
        hm.put(s3, "白琳");
        hm.put(s4, "温州");
        Set<Student> keySet = hm.keySet();
        for (Student s : keySet) {
            String sb = hm.get(s);
            System.out.println(s.getName() + "," + s.getAge() + "," + sb);
        }
    }
}

四、ArrayList嵌套HashMap

创建一个 ArrayList集合，存储三个元素，每一个元素都是HashMap
每一个 HashMap的键和值都是String，并遍历。

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<HashMap<String, String>> a = new ArrayList<HashMap<String, String>>();
        HashMap<String, String> hm = new HashMap<String, String>();
        hm.put("骂", "打");
        hm.put("南", "北");
        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm2.put("ye", "yu");
        hm2.put("c", "s");
        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm3.put("er", "lin");
        hm3.put("da", "xiao");
        a.add(hm);
        a.add(hm2);
        a.add(hm3);
        for (HashMap<String, String> s : a) {
            Set<String> key = s.keySet();
            for (String key1 : key) {
                String value = s.get(key1);
                System.out.println(key1 + "," + value);
            }
        }
    }
}

五、HashMap嵌套ArrayList

案例需求
创建一个 HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList
每一个 ArrayList的元素是String，并遍历。

public class Demo01 {
    public static void main(String[] args) {
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
        ArrayList<String> hlm = new ArrayList<String>();
        hlm.add("贾宝玉");
        hlm.add("林黛玉");
        ArrayList<String> xyj = new ArrayList<String>();
        xyj.add("唐僧");
        xyj.add("孙悟空");
        hm.put("红楼梦", hlm);
        hm.put("西游记", xyj);
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for (String s : value) {
                System.out.println("\t"+ s);
            }
        }
    }
}

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

案例需求
键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例：键盘录入 “aababcabcdabcde” 在控制台输出：“a(5)b(4)c(3)d(2)e(1)”

public class Demo01 {
    public static void main(String[] args) {
        //创建HashMap集合，键是Character，值是Integer
        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = sc.nextLine();
        //遍历
        for (int i = 0; i < s.length(); i++) {
            char key = s.charAt(i); //charAt返回指定索引处的char值
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值
            Integer value = hm.get(key);
            //判断条件
            if (value == null) {
                hm.put(key, 1);
            } else {
                value++;
                hm.put(key, value);
            }
        }
        //拼接
        StringBuilder sb = new StringBuilder();
        //遍历集合
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer v = hm.get(key);
            sb.append(key).append("(").append(v).append(")");
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

七、Collections 类常用方法

public static void sort(List list) 按升序排序,需要自然排序接口
public static void reverse(List<?> list) 反转顺序
public static void shuffle(List<?> list) 随机排列

public class Demo02 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(10);
        list.add(8);
        list.add(7);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

八、ArrayList集合存储学生并排序【应用】

案例需求
ArrayList 存储学生对象，使用Collections对ArrayList进行排序
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

public class 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;
    }
}

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<Student> arry = new ArrayList<Student>();
        Student s1 = new Student("as", 12);
        Student s2 = new Student("ad", 13);
        Student s3 = new Student("ds", 14);
        Student s4 = new Student("csss", 16);
        Student s5 = new Student("css", 1);
        arry.add(s1);
        arry.add(s5);
        arry.add(s4);
        arry.add(s3);
        arry.add(s2);
        Collections.sort(arry, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge() - o2.getAge();
                int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num2;
            }
        });
        for (Student sb : arry) {
            System.out.println(sb.getAge() + sb.getName());
        }
    }
}

九、模拟斗地主

public class Demo04 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        String[] color = {"♠", "♣", "♦", "♥"};
        String[] nums = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        for (String c : color) {
            for (String s : nums) {
                array.add(c + s);
            }
        }
        array.add("大王");
        array.add("小王");
        Collections.shuffle(array);
        ArrayList<String> cs = new ArrayList<String>();
        ArrayList<String> css = new ArrayList<String>();
        ArrayList<String> dp = new ArrayList<String>();
        ArrayList<String> csss = new ArrayList<String>();
        for (int i = 0; i <array.size(); i++) {
            String pkp = array.get(i);
            if (i >= array.size() - 3) {
                dp.add(pkp);
            } else if (i % 3 == 0) {
                cs.add(pkp);
            } else if (i % 3 == 1) {
                css.add(pkp);
            } else if (i % 3 == 2) {
                csss.add(pkp);
            }
        }
        lookp("cs", cs);
        lookp("css", css);
        lookp("csss", csss);
        lookp("dp", dp);
    }
    public static void lookp(String name, ArrayList<String> array) {
        System.out.print(name + "的牌");
        for (String sb : array) {
            System.out.print(sb + " ");
        }
        System.out.println();
    }
}

十、斗地主升级

public class Demo05 {
    public static void main(String[] args) {
        //HashMap，键编号，值是牌
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        //ArrayList存储编号
        ArrayList<Integer> array = new ArrayList<Integer>();
        //花色数组和点数数组
        String[] colors = {"♠", "♣", "♦", "♥"};
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        //从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hm.put(index, color + number);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "大王");
        array.add(index);
        index++;
        hm.put(index, "小王");
        array.add(index);
        //洗牌(洗编号)，用Collections的shuffle()方法实现
        Collections.shuffle(array);
        //发牌(发编号，保证排序的创建TreeSet)
        TreeSet<Integer> cs = new TreeSet<Integer>();
        TreeSet<Integer> css = new TreeSet<Integer>();
        TreeSet<Integer> csss = new TreeSet<Integer>();
        TreeSet<Integer> dp = new TreeSet<Integer>();
        for (int i = 0; i < array.size(); i++) {
            int a = array.get(i);
            if (i >= array.size() - 3) {
                dp.add(a);
            } else if (i % 3 == 0) {
                cs.add(a);
            } else if (i % 3 == 1) {
                css.add(a);
            } else if (i % 3 == 2) {
                csss.add(a);
            }
        }
        //调用看牌方法
        look("cs",cs,hm);
        look("css",css,hm);
        look("csss",csss,hm);
        look("dp",dp,hm);
        //定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

    }
    public static void look(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm) {
        System.out.print(name+ "的牌是：");
        for (Integer key:ts) {
            String poker = hm.get(key);
            System.out.print(poker+"");
        }
        System.out.println();
    }
}