Java20统计字符出现个数（断点debug），斗地主，自定义Collections类和TreeSet

Posted 2021-05-17 码农编程录

文章目录

• 1.统计字符出现个数：.containsKey（.charAt）
• 2.斗地主：list.addAll(set)
• 3.自定义Collections类和TreeSet：return o1-o2是升序

---

1.统计字符出现个数：.containsKey（.charAt）

统计字符串中：大小写字母及数字字符个数：https://blog.csdn.net/weixin_43435675/article/details/107434867

package com.itheima03.impl;
import java.util.HashMap;
/*
*  需求: 计算一个字符串中每个字符出现次数。
*       0. 弄一个Map : 记录 字符=次数 (就像画正字选票)
*                          char   int
*       1. 遍历这个字符串,取出每个字符
*       2. 判断Map中是否存在这个字符-> boolean containsKey(Object key)  如果此映射包含指定键的映射关系，则返回 true。
*       3. 有: 在对应的次数+1 。没有 : 字符char=1 存进去
*/
public class CountDemo {
    public static void main(String[] args) {
        String str = "abcaba";         
        HashMap<Character, Integer> map = new HashMap<>();//泛型不接收基本类型，所以char写成Character，int的包装类Integer
        for(int i=0; i<str.length();i++){
            char c = str.charAt(i); //相应索引访问到相应字符
            boolean result = map.containsKey(c);   
                                
            if(result){ // 存在,次数value+1
                Integer value = map.get(c); //c是key即char
//                value = value + 1;
//                map.put(c,value);

//                value++;
//                map.put(c,value);

//                int count = ++value;
//                map.put(c,count);
                map.put(c,++value); //不能写成map.put(c,value++);
            }else{ // 不存在, 存入c=1
                map.put(c,1);
            }
        }
        System.out.println(map);
    }
}

2.斗地主：list.addAll(set)

package com.itheima04.Poker;
import java.util.ArrayList;
import java.util.Collections;
// 写一个规则: 2 > A > K > Q > J  ...(不行，组合方式太多2也要>K)  //上次写的没有排序 //黑红梅方
public class SortDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(); //重索序
        list.add(3);
        list.add(5);
        list.add(4);
        list.add(1);
        list.add(2);
        System.out.println(list); //[3,5,4,1,2]，有序
        Collections.sort(list);
        System.out.println(list);//[1,2,3,4,5]
    }
}

15发给第一个，13发给第二个。。。

package com.itheima04.Poker;
import java.util.*;

class PokerDemo {
    public static void main(String[] args) {        
        HashMap<Integer, String> map = new HashMap<>(); //key=编号, value=牌面
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        int index=0;
        for (String number : numbers) {//数字写外面，外一次内一周，数字3和4种花拼接，并标号依次从0对应到3，好按标号排序。            
            for (String color : colors) {
                String poker = color + number;
                map.put(index,poker);
                index++;
            }
        }
//        System.out.println(map); //{0=黑桃3，1=红心3，2=梅花3，...}
        map.put(52,"小☺");
        map.put(53,"大☺");        
        Set<Integer> set = map.keySet(); //0-53
        ArrayList<Integer> list = new ArrayList<>();
        list.addAll(set); //将set集合中每个元素都放进list中
        //下面等同于上面 
        /*for (int i = 0; i < 54; i++) {  //0-53编号放进去
            list.add(i);
        }*/
        
        //洗牌
        Collections.shuffle(list); //只能洗list集合
        //发牌
        ArrayList<Integer> p1 = new ArrayList<>();
        ArrayList<Integer> p2 = new ArrayList<>();
        ArrayList<Integer> p3 = new ArrayList<>();
        ArrayList<Integer> dp = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) { //list里全是编号
            Integer number = list.get(i);
            int mod = i % 3;
            if(i < 3){
                dp.add(number);
            }else if(mod == 1){
                p1.add(number);
            }else if(mod == 2){
                p2.add(number);
            }else if(mod == 0){
                p3.add(number);
            }
        }
        //排序(Integer:从小到大)
        Collections.sort(p1);
        Collections.sort(p2);
        Collections.sort(p3);
        Collections.sort(dp);
//        lookPoker(map,p1); //因为list即p里都是编号，所以还需要map
//        lookPoker(map,p2);
//        lookPoker(map,p3);
//        lookPoker(map,dp);
        lookPoker(map,p1,p2,p3,dp);
    }
    
    private static void lookPoker(HashMap<Integer, String> map, ArrayList<Integer>... lists) { //lists为数组名
        for (ArrayList<Integer> list : lists) {
            for (Integer number : list) {               
                String poker = map.get(number);  //从map中根据number 取出 poker
                System.out.print(poker + "\\t");
            }
            System.out.println();
        }
    }
//    private static void lookPoker(HashMap<Integer,String> map,ArrayList<Integer> list){
//        for(Integer number : list){
//            String poker = map.get(number);
//            System.out.print(poker+"\\t");
//        }
//        System.out.println();
//    }
}

3.自定义Collections类和TreeSet：return o1-o2是升序

package com.itheima05.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
  Arrays数组工具类, Objects对象工具类（命名规则最后+s）
  - java.utils.Collections是集合工具类，用来对集合进行操作。 常用方法如下： 
- public static void shuffle(List<?> list):打乱集合顺序。
- public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
- public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
*/
public class CollectionsDemo01 {
    public static void main(String[] args) {
//        addall();
        ArrayList<Integer> list = new ArrayList<>(); //Integer源码实现了Comparable接口
        Collections.addAll(list,5,3,2,4,1);
//        Collections.sort(list); // 默认: 升序

// 如下第二个参数类型是Comparator接口，必须传入接口实现类对象：new Comparator...后面全是匿名内部类
        Collections.sort(list, new Comparator<Integer>() { // 自定义升降序规则       
            @Override
            public int compare(Integer o1, Integer o2) {
//                return o1 - o2;//升序: 从小到大
                return o2 - o1;//降序: 从大到小
            }
        });
        System.out.println(list);
    }
    
    private static void addall() {
        ArrayList<Integer> list = new ArrayList<>();
//        list.add(3);
//        list.add(5);
        Collections.addAll(list,3,4,5,1,2);
        System.out.println(list);//[3,4,5,1,2]
    }
}

任何排序都是两两比较，如下最大的泡泡先冒出去。

package com.itheima05.collections;
import java.util.ArrayList;
import java.util.Comparator;
/**
 * Collections工具类是集合中常用工具类。这里通过自定义MyCollections类,模拟完成addAll()和sort()方法.
 * 备注: 核心原理相同,但并非完全相同.
 */
public class MyCollections { 
    // 1. addAll方法
    public static void addAll(ArrayList<Integer> list, Integer... args){
        for (Integer arg : args) {
            list.add(arg);
        }
    }
    
    //2. sort方法: 这里采用冒泡排序
    // 注意: 第二个参数是接口,必须传入接口实现类(这将形成多态: 父接口引用调用方法执行的是子类重写方法)
    public static void sort(ArrayList<Integer> list, Comparator<Integer> comparator) {
        int temp;
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 0; j < list.size() - i - 1; j++) {                
                int result = comparator.compare(list.get(j + 1), list.get(j));//j+1和j相邻比较，父类接口调用方法执行下面子类重写的方法。
                if(result < 0){
                    temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j+1,temp);
                }
            }
        }
    }
}

package com.itheima05.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionsDemo02 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,5,3,2,4,1);
        MyCollections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(list);
    }
}

collections底层实际是Timsort排序，不是冒泡。如下左父右子，o1为后一个。rerurn o1-o2 保证result<0即o1后小，进入左边循环。rerurn o2-o1 保证result<0即o1后大。

package com.itheima05.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.TreeSet;

public class CollectionsDemo03 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>(); //ArrayList底层就是数组，数组和集合差不多。
        list.add(new Student("张三",20));
        list.add(new Student("李四",18));
        list.add(new Student("王五",22));
      /* Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age - o2.age; //按年龄升序
            }
        });
        System.out.println(list);*/

//1111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
    // sort(list) : 这个方法要求集合元素类型需要实现 Comparable接口 (Integer已实现,自定义类型必须手动实现)
//      Collections.sort(list); //如果就写class Student不实现Comparable接口，这行会报错
//      System.out.println(list);

//111111111111111111111111111111111111111111111111111111111111111111111111111111111111           
        TreeSet<Student> set = new TreeSet<>(); //TreeSet判定元素重复的原理：compare方法 : 两数相减=0（不是hashcode和equals）    
        //TreeSet底层红黑树（红黑树就是排序，左小右大），和哈希表无关，和Collections.sort一样必须实现Comparable接口
        //Set重点是hashset，TreeSet底层和比较器完全一样，TreeSet具备排序功能但效率不如hashset。TreeMap的key和TreeSet底层一样
        set.add(new Student("张三",20));
        set.add(new Student("李四",18));
        set.add(new Student("王五",22));
        set.add(new Student("马六",22)); //添不进去，因为compareTo比较的是age，不重复
        System.out.println(set);
    }
}

//11111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
class Student implements Comparable<Student>{
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\\'' +
                ", age=" + age +
                '}';
    }   
    @Override
    public int compareTo(Student o) {
        return this.age - o.age; //升序，// this = o1，o = o2  
    }
}

微信公众号：码农编程录