Day21

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

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数

举例：键盘录入“aababcabcdabcde” 在控制台输出：“a（5）b（4）C（3）D（2）e（1）

package hashmapdemo;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*
需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数

举例：键盘录入“aababcabcdabcde” 在控制台输出：“a（5）b（4）C（3）D（2）e（1）
 */
public class HashMapDemo03 {
    public static void main(String[] args) {
        //键盘录入数据
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str= input.nextLine();

        //创建hashmap集合，键是Character 值是Integer
        //HashMap<Character,Integer> hm=new HashMap<Character,Integer>();
        //如果想要按照输入字符排序的 就用TreeSet
        TreeMap<Character,Integer> hm=new TreeMap<Character,Integer>();

        //遍历字符串得到每一个字符
        for (int i = 0; i <str.length() ; i++) {
            char key=str.charAt(i);
            Integer value=hm.get(key);

            if(value==null){
                //如果返回值null，说明该集合中不存在该字符，就把字符作为键，1储存为值
                hm.put(key,1);
            }else{
                //如果返回值不为null，说明该集合中存在该字符，值++；
                value++;
                hm.put(key,value);
            }
        }

        //遍历hashmap集合 ，按照要求拼接
        StringBuilder sb=new StringBuilder();

        Set<Character> keySet =hm.keySet();
        for (Character key: keySet){
            Integer value=hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result =sb.toString();
        System.out.println(result);
    }
}

Collections类的概述

是针对集合操作的工具

Collections类的常用方法

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

public class CollectionsDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list=new ArrayList<Integer>();

        //添加元素
        list.add(30);
        list.add(10);
        list.add(50);
        list.add(40);
        list.add(90);
        list.add(70);

        //public static <T extends Comparable<? super T>> void sort(List<T> list)
        Collections.sort(list);

        //public static void reverse(List<?> list);翻转指定列表中元素的顺序
        Collections.reverse(list);

        //public static void shuffle(List<?> list);
        Collections.shuffle(list);

        System.out.println(list);

    }
}

案例：ArrayList存储学生对象并且排序

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母排序

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

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array =new ArrayList<Student>();

        //创建学生对象
        Student s1=new Student("Lucas",18);
        Student s2=new Student("LYK",20);
        Student s3=new Student("Simon",22);
        Student s4=new Student("Leo",24);

        //把学生添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        //使用Collections对ArrayList集合排序
        Collections.sort(array, new Comparator<Collections.Student>() {
            @Override
            public int compare(Collections.Student s1, Collections.Student s2) {
                //按照年龄从小到大排序，年龄相同时，按照姓名的字母排序
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName()-s2.getName():num;
                return num2;
                return 0;
            }
        });
        for (Student s:array){
            System.out.println(s.getName()+" "+s.getAge());
        }
    }
}

案例：模拟斗地主

需求： 通过程序实现斗地主过程中的洗牌，发牌和看牌

思路：

1. 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2. 往牌盒里面装牌
3. 洗牌，也就是把牌打撒，用Collections的shuffle（）方法实现
4. 发牌，也就是遍历集合，给三个玩家发牌
5. 看牌，也就是三个玩家分别遍历自己的牌

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

/*
1. 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2. 往牌盒里面装牌
3. 洗牌，也就是把牌打撒，用Collections的shuffle（）方法实现
4. 发牌，也就是遍历集合，给三个玩家发牌
5. 看牌，也就是三个玩家分别遍历自己的牌
 */
public class PokerDemo {
    public static void main(String[] args) {
        //创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> array=new ArrayList<String>();

        //往牌盒里面装牌
        //定义花色数组
        String [] colors={"♦","♠","♥","♣"};
        //定义点数数字
        String [] numbers={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        for (String i:colors){
            for (String j:numbers){
                array.add(i+j);
            }
        }
        array.add("BigJoker");
        array.add("SmallJoker");

        //洗牌，也就是把牌打撒，用Collections的shuffle（）方法实现
        Collections.shuffle(array);

        //发牌，也就是遍历集合，给三个玩家发牌
        ArrayList<String> Lucas=new ArrayList<String>();
        ArrayList<String> LYK=new ArrayList<String>();
        ArrayList<String> Simon=new ArrayList<String>();
        ArrayList<String> dp=new ArrayList<String>();

        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);
            if(i>= array.size()-3){
                dp.add(poker);
            }else if(i%3==0){
                Lucas.add(poker);
            }else if(i%3==1){
                LYK.add(poker);
            }else if (i%3==2){
                Simon.add(poker);
            }
        }
        //看牌，也就是三个玩家分别遍历自己的牌
        LookPoker("Lucas",Lucas);
        LookPoker("LYK",LYK);
        LookPoker("Simon",Simon);
        LookPoker("底牌",dp);
    }
    //看牌的方法
    public static void LookPoker(String name,ArrayList<String> array){
        System.out.println(name+"的牌是：");
        for (String i:array){
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

模拟斗地主升级版

要求：对牌进行排序

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

public class PokerPlusDemo {
    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={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        //从0开始往HashMap中存储编号，并存储对应的牌。同时往ArrayList里面存储编号
        int index=0;
        for (String i:numbers){
            for (String j:colors){
                hm.put(index,i+j);
                array.add(index);
                index++;
            }
        }
        hm.put(index,"BigJoker");
        array.add(index);
        index++;
        hm.put(index,"SmallJoker");
        array.add(index);

        //洗牌，洗的是编号，用Collections的shuffle方法实现
        Collections.shuffle(array);

        //发牌，发的也是编号，为了保证编号是排序的，创建TreeSet集合接受
        TreeSet<Integer> Lucas = new TreeSet<Integer>();
        TreeSet<Integer> LYK = new TreeSet<Integer>();
        TreeSet<Integer> Simon = new TreeSet<Integer>();
        TreeSet<Integer> dp = new TreeSet<Integer>();

        for (int i = 0; i < array.size(); i++) {
            int x= array.get(i);
            if(i>= array.size()-3){
                dp.add(x);
            }else if(i%3==0){
                Lucas.add(x);
            }else if(i%3==1){
                LYK.add(x);
            }else if(i%3==2){
                Simon.add(x);
            }

        }

        //看牌
        LookPoker("Lucas",Lucas,hm);
        LookPoker("LYK",LYK,hm);
        LookPoker("Simon",Simon,hm);
        LookPoker("底牌",dp,hm);
    }
    public static void LookPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.println(name+"的牌是:");
        for (Integer key:ts){
            String s = hm.get(key);
            System.out.print(s+" ");
        }
        System.out.println();
    }
}