同步练习(Java SE(八))

案例一: HashMap集合存储学生对象并遍历

需求: 创建一个HashMap结合，键是学号(String),值是学生对象(Student)。存储三个键值元素，并遍历

思路: 1.定义学生类

2.创建HashMap集合对象

3.创建学生对象

4.把学生添加到集合

5.遍历集合

方式1: 键找值

方式2: 键值对对象找键和值

学生类

package test.test58;

// 1.定义学生类
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;
    }
}

测试类

package test.test58;

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

public class HashMapDemo {
    public static void main(String[] args) {
        // 2.创建HashMap集合对象
        HashMap<String,Student> hm = new HashMap<String, Student>();
        // 3.创建学生对象
        Student s1 = new Student("张三",30);
        Student s2 = new Student("李四",35);
        Student s3 = new Student("王五",33);
        // 4.把学生添加到集合
        hm.put("001",s1);
        hm.put("002",s2);
        hm.put("003",s3);
        // 5.遍历集合
        // 方式1: 键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet){
            Student s = hm.get(key);
            System.out.println("学号:"+key+",姓名:"+s.getName()+",年龄:"+s.getAge());
        }

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

        // 方式2: 键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> entry : entrySet){
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println("学号:"+key+",姓名:"+value.getName()+",年龄:"+value.getAge());
        }
    }
}

案例二: HashMap集合存储学生对象并遍历

需求: 创建一个HashMap集合，键是学生对象(Student),值是居住地(String)。存储多个键值对元素，并遍历。

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

思路: 1.定义学生类

2.创建HashMap集合对象

3.创建学生对象

4.把学生添加到集合

5.遍历集合

6.在学生类中重写两个方法

hashCode()

equals()

学生类

package test.test59;

// 1.定义学生类
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;
    }

    // 6.在学生类中重写两个方法
    // equals()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
    // hashCode()
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

测试类

package test.test59;

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

public class HashMapDemo {
    public static void main(String[] args) {
        // 2.创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<>();
        // 3.创建学生对象
        Student s1 = new Student("张三",30);
        Student s2 = new Student("李四",35);
        Student s3 = new Student("王五",33);
        Student s4 = new Student("王五",33);
        // 4.把学生添加到集合
        hm.put(s1,"西安");
        hm.put(s2,"武汉");
        hm.put(s3,"郑州");
        hm.put(s4,"北京");
        // 5.遍历集合
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet){
            String value = hm.get(key);
            System.out.println("姓名:"+key.getName()+",年龄:"+key.getAge()+",居住地:"+value);
        }
    }
}

案例三: ArrayList集合存储HashMap元素并遍历

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

思路: 1.创建ArrayList集合

2.创建HashMap集合，并添加键值对元素

3.把HashMap作为元素添加到ArrayList集合

4.遍历ArrayList集合

package test;

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

public class Test60 {
    public static void main(String[] args) {
        // 1.创建ArrayList集合
        ArrayList<HashMap<String,String>> al = new ArrayList<HashMap<String, String>>();
        // 2.创建HashMap集合，并添加键值对元素
        HashMap<String,String> hm1 = new HashMap<String, String>();
        hm1.put("孙策","大乔");
        hm1.put("周瑜","小乔");

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

        HashMap<String,String> hm3 = new HashMap<String, String>();
        hm3.put("令狐冲","任盈盈");
        hm3.put("林平之","岳灵珊");
        // 3.把HashMap作为元素添加到ArrayList集合
        al.add(hm1);
        al.add(hm2);
        al.add(hm3);
        // 4.遍历ArrayList集合
        for (HashMap<String,String> hm : al){
            Set<String> keySet = hm.keySet();
            for (String key : keySet){
                String value = hm.get(key);
                System.out.println(key+","+value);
            }
            System.out.println("--------");
        }
    }
}

案例四: HashMap集合存储ArrayList元素并遍历

需求: 创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList

每一个ArrayList的元素是String，并遍历

思路: 1.创建HashMap集合

2.创建ArrayList集合，并添加元素

3.把ArrayLIst作为元素添加到HashMap集合

4.遍历HashMap集合

package test;

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

public class Test61 {
    public static void main(String[] args) {
        // 1.创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
        // 2.创建ArrayList集合，并添加元素
        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("诸葛亮");
        al1.add("赵云");

        ArrayList<String> al2 = new ArrayList<String>();
        al2.add("唐僧");
        al2.add("孙悟空");

        ArrayList<String> al3 = new ArrayList<String>();
        al3.add("武松");
        al3.add("鲁智深");
        // 3.把ArrayLIst作为元素添加到HashMap集合
        hm.put("三国演义",al1);
        hm.put("西游记",al2);
        hm.put("水浒传",al3);
        // 4.遍历HashMap集合
        Set<String> keySet = hm.keySet();
        for (String key : keySet){
            System.out.println(key);
            ArrayList<String> al = hm.get(key);
            for (String str : al){
                System.out.println("\t"+str);
            }
        }
    }
}

案例五: 统计自渡船中每个字符出现的次数

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

举例: 键盘录入 "aababcabcdabcde" 在控制台输出: "a(5)b(4)c(3)d(2)e(1)"

分析: 1.我们可以把结果分成几个部分来看: a(5)，b(4)，c(3)，d(2)，e(1)

2.每一个部分可以看成是: 字符和字符对应的次数组成

3.这样的数据，我们可以通过HashMap集合来存储，键是字符，值是字符出现的次数

注意: 键是字符，类型应该是Character; 值是字符出现的次数，类型应该是Integer

思路: 1.键盘录入一个字符串

2.创建HashMap集合，键是Character，值是Integer

3.遍历字符串，得到每一个字符

4.拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值

如果返回值是null: 说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储

如果返回值不是null: 说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值

5.遍历HashMap集合，得到键和值，按照要求进行拼接

6.输出结果

package test;

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

public class Test62 {
    public static void main(String[] args) {
        // 1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串:");
        String str = sc.nextLine();
        // 2.创建HashMap集合，键是Character，值是Integer
        HashMap<Character,Integer> hm = new HashMap<Character, Integer>();
        // 3.遍历字符串，得到每一个字符
        for (int i = 0; i<str.length(); i++){
            char key = str.charAt(i);
            // 4.拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);
            if (value == null){
                // 如果返回值是null: 说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key,1);
            }else {
                // 如果返回值不是null: 说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
        }
        // 5.遍历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();
        // 6.输出结果
        System.out.println(result);
    }
}

案例六: ArrayList存储学生对象并排序

需求: ArrayList存储学生对象，使用Collections对ArrayList进行排序

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

思路: 1.定义学生类

2.创建ArrayList集合对象

3.创建学生对象

4.把学生添加到集合

5.使用Collections是对ArrayList集合排序

6.遍历集合

学生类

package test.test63;

// 1.定义学生类
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;
    }
}

测试类

package test.test63;

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

public class CollectionsDemo {
    public static void main(String[] args) {
        // 2.创建ArrayList集合对象
        ArrayList<Student> al = new ArrayList<Student>();
        // 3.创建学生对象
        Student s1 = new Student("zhangsan",30);
        Student s2 = new Student("lisi",35);
        Student s3 = new Student("wangwu",33);
        Student s4 = new Student("zhaoliu",33);
        // 4.把学生添加到集合
        al.add(s1);
        al.add(s2);
        al.add(s3);
        al.add(s4);
        // 5.使用Collections是对ArrayList集合排序
        Collections.sort(al, 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;
            }
        });
        // 6.遍历集合
        for (Student s : al){
            System.out.println("姓名:"+s.getName()+",年龄:"+s.getAge());
        }
    }
}

案例七: 模拟斗地主

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

思路: 1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现

2.往牌盒里面装牌

3.洗牌，也就是把牌打撒，用Collection是的shuffle()方法实现

4.发牌，也就是遍历集合，给三个玩家发牌

5.看牌，也就是三个玩家分别遍历自己的牌

package test;

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

public class Test64 {
    public static void main(String[] args) {
        // 1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> al = new ArrayList<String>();
        // 2.往牌盒里面装牌
        /*
            ♦2,♦3,...♦K,♦A
            ♣2...
            ♥2...
            ♠2...
            小王,大王
         */
        // 定义花色数组
        String[] colors = {"♦","♣","♥","♠"};
        // 定义点数数组
        String[] numbers = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        for (String color : colors){
            for (String number : numbers){
                al.add(color+number);
            }
        }
        al.add("小王");
        al.add("大王");
        // 3.洗牌，也就是把牌打撒，用Collection是的shuffle()方法实现
        Collections.shuffle(al);
        // 4.发牌，也就是遍历集合，给三个玩家发牌
        // 三名玩家
        ArrayList<String> p1 = new ArrayList<String>();
        ArrayList<String> p2 = new ArrayList<String>();
        ArrayList<String> p3 = new ArrayList<String>();
        // 底牌
        ArrayList<String> cards = new ArrayList<String>();

        for (int i = 0; i<al.size(); i++){
            String poker = al.get(i);
            if (i >= al.size()-3){
                cards.add(poker);
            }else if (i%3 == 0){
                p1.add(poker);
            }else if (i%3 == 1){
                p2.add(poker);
            }else if (i%3 == 2){
                p3.add(poker);
            }
        }
        // 5.看牌，也就是三个玩家分别遍历自己的牌
        lookPoker("张三",p1);
        lookPoker("李四",p2);
        lookPoker("王五",p3);
        lookPoker("底牌",cards);
    }

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

案例八: 模拟斗地主升级版

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

要求: 对牌进行排序

思路: 1.创建HashMap，键是编号，值是牌

2.创建ArrayList，存储编号

3.创建花色数组和点数数组

4.从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号

5.洗牌(洗的是编号)，用Collection是的shuffle()方法实现

6.发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接受)

7.定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

8.调用看牌方法

package test;

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

public class Test65 {
    public static void main(String[] args) {
        // 1.创建HashMap，键是编号，值是牌
        HashMap<Integer,String> hm = new HashMap<Integer, String>();
        // 2.创建ArrayList，存储编号
        ArrayList<Integer> al = new ArrayList<Integer>();
        // 3.创建花色数组和点数数组
        String[] colors = {"♦","♣","♥","♠"};
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        // 4.从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
        int index = 0;
        for (String number : numbers){
            for (String color : colors){
                hm.put(index,color+number);
                al.add(index);
                index++;
            }
        }
        hm.put(index,"小王");
        al.add(index);
        index++;
        hm.put(index,"大王");
        al.add(index);
        // 5.洗牌(洗的是编号)，用Collection是的shuffle()方法实现
        Collections.shuffle(al);
        // 6.发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接受)
        TreeSet<Integer> p1 = new TreeSet<Integer>();
        TreeSet<Integer> p2 = new TreeSet<Integer>();
        TreeSet<Integer> p3 = new TreeSet<Integer>();
        TreeSet<Integer> cards = new TreeSet<Integer>();

        for (int i = 0; i<al.size(); i++){
            int x = al.get(i);
            if (i >= al.size()-3){
                cards.add(x);
            }else if (i%3 == 0){
                p1.add(x);
            }else if (i%3 == 1){
                p2.add(x);
            }else if (i%3 == 2){
                p3.add(x);
            }
        }
        // 8.调用看牌方法
        lookPoker("张三",p1,hm);
        lookPoker("李四",p2,hm);
        lookPoker("王五",p3,hm);
        lookPoker("底牌",cards,hm);
    }

    // 7.定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
    public static void lookPoker(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();
    }
}

原文链接：https://blog.csdn.net/weixin_52993606/article/details/121337499