JAVA道路day13

Mapクラス

ケース

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 Test {
    public static void main(String[] args) {
        //创建输入器
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入字符串");
        String s=new String();
        if (scanner.hasNext()){
            s=scanner.next();
        }
        scanner.close();
        //创建一个HashMap集合
        TreeMap<Character,Integer> hm=new TreeMap<>();

        //遍历字符串
        for (int i=0;i<s.length();i++){
            char c = s.charAt(i);//得到当前位置的字符
            Integer integer = hm.get(c);//得到当前字符对应的键的值
            if (integer==null){//如果没有值则增加元素
                hm.put(c,1);
            }else {//值++
                integer++;
                hm.put(c,integer);
            }
        }

        //用keySet遍历
        Set<Character> characters = hm.keySet();
        for (Character c:characters){
            System.out.println(c+"("+hm.get(c)+")");
        }


    }
}

コレクションクラス

コレクションクラスの概要

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Collectors;

//Collections是一个类，里面有针对集合操作的静态方法
/*
1.针对集合操作的工具类
2.Collections类的常用方法
    - public static <T extends Comparable<? super T>> void sort(List<T> list):给指定的列表按升序排序
    - public static void reverse(List<?> list):反转指定列表中元素的顺序
    - public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表
 */
public class Test {
    public static void main(String[] args) {
        //创建一个集合对象
        ArrayList<String> array=new ArrayList<>();

        //添加元素
        array.add("a");
        array.add("b");
        array.add("d");
        array.add("c");
        array.add("a");

        Collections.sort(array);
        Collections.reverse(array);
        Collections.shuffle(array);
        
        System.out.println(array);
    }
}

ケース1

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

//案例：ArrayList存储学生对象并排序
//需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
//要求：按照年龄大小从小到大排序，年龄相同时，按照姓名的字母顺序排序
public class Test {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arrayList=new ArrayList<>();

        //创建学生对象
        Student s1=new Student("one",1);
        Student s2=new Student("four",4);
        Student s3=new Student("three",3);
        Student s4=new Student("two",2);
        Student s5=new Student("Atwo",2);

        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s5);

        //使用Collections类进行排序
        Collections.sort(arrayList, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });

        //遍历集合
        for (Student s:arrayList){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}
/*
//自定义学生类
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;
    }
}

 */

ケース2（アナログ地主）

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

/*
  需求：
      通过程序实现斗地主过程中的洗牌，发牌和看牌
  思路：
      1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
      2.往牌盒里面装牌，也就是给集合添加元素
      3.洗牌，把牌打乱，用Collections中的shuffle()方法实现
      4.发牌，也就是遍历集合，给三个玩家发牌
      5.看牌，也就是三个玩家遍历自己的牌
 */
public class Test {
    public static void main(String[] args) {
        //创建一套牌的集合
        ArrayList<String> poker=new ArrayList<>();
        /*
          ♦2，♦3...♦A
          ♠2...
          ♥2...
          ♣2...
         */
        //花色数组
        String[] colors={"♦","♠","♥","♣"};
        //点数数组
        String[] points={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        //把牌放入牌盒，添加进集合
        for (String color:colors){
            for (String point:points){
                poker.add(color+point);
            }
        }
        poker.add("大王");
        poker.add("小王");

        //创建三个玩家
        ArrayList<String> xjyPoker=new ArrayList<>();
        ArrayList<String> ysjPoker=new ArrayList<>();
        ArrayList<String> bmPoker=new ArrayList<>();
        ArrayList<String> dpPoker=new ArrayList<>();//底牌

        //洗牌，把牌打乱，用Collections中的shuffle()方法实现
        Collections.shuffle(poker);

        //发牌，也就是遍历集合，给三个玩家发牌
        for (int i=0;i<poker.size();i++){
            String s = poker.get(i);
            if (i>=poker.size()-3){
                dpPoker.add(s);
            }else if (i%3==0){
                xjyPoker.add(s);
            }else if (i%3==1){
                ysjPoker.add(s);
            }else if (i%3==2){
                bmPoker.add(s);
            }
        }
        Collections.sort(xjyPoker);
        Collections.shuffle(ysjPoker);
        Collections.shuffle(bmPoker);

        //看牌，也就是三个玩家遍历自己的牌
        lookPoker("谢佳妤",xjyPoker);
        lookPoker("杨胜杰",ysjPoker);
        lookPoker("小表妹",bmPoker);
        lookPoker("底牌",dpPoker);


    }
    //看牌的方法
    public static void lookPoker(String name,ArrayList<String> arrayList){
        System.out.print(name+"的牌是:");
        for (String s:arrayList){
            System.out.print(s+" ");
        }
        System.out.println();
    }
}

ケース3（アナログ地主アップグレード版）

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

//模拟斗地主升级版
//需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
//要求：对牌进行排序
public class Test {
    public static void main(String[] args) {
        //创建一个HashMap<Integer,String>集合 键为序号，值为牌
        HashMap<Integer,String> hm=new HashMap<>();
        //花色数组
        String[] colors={"♦","♠","♥","♣"};
        //点数数组
        String[] points={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        //把牌放入牌盒，添加进集合
        int i=0;
        for (String point:points){
            for (String color:colors){
                hm.put(i++,color+point);
            }
        }
        hm.put(i++,"大王");
        hm.put(i,"小王");

        //创建一个序号数组
        ArrayList<Integer> arrayList=new ArrayList<>();
        for (int i1=0;i1<54;i1++){
            arrayList.add(i1);
        }

        //用TreeSet创建三个玩家数组，自然排序
        TreeSet<Integer> xjySet=new TreeSet<>();
        TreeSet<Integer> ysjSet=new TreeSet<>();
        TreeSet<Integer> xbmSet=new TreeSet<>();
        TreeSet<Integer> dpSet=new TreeSet<>();

        //洗牌，打乱arrayList的元素顺序
        Collections.shuffle(arrayList);

        //把牌发给玩家
        for (int j=0;j<arrayList.size();j++){
            Integer integer = arrayList.get(j);
            if (j>=arrayList.size()-3){
                dpSet.add(integer);
            }else if (j%3==0){
                xjySet.add(integer);
            }else if (j%3==1){
                ysjSet.add(integer);
            }else if (j%3==2){
                xbmSet.add(integer);
            }
        }

        //玩家看牌
        lookPoker("谢佳妤",xjySet,hm);
        lookPoker("杨胜杰",ysjSet,hm);
        lookPoker("小表妹",xbmSet,hm);
        lookPoker("底牌",dpSet,hm);

    }
    //看牌的方法
    public static void lookPoker(String name,TreeSet<Integer> treeSet,HashMap<Integer,String> hashMap){
        System.out.print(name+"的牌是");
        for (int k:treeSet){
            System.out.print(hashMap.get(k)+" ");
        }
        System.out.println();
    }
}