JAVA 集合进阶

编程语言 2025-04-12 17:40
0 阅读

可变参数

例如

package args;

public class argsDemo1 {
    public static void main(String[] args) {

        //JDK5
        //可变参数
        //方法形参的个数是可以发生变化的，0 1 2 3 ...
        //格式:属性类型...名字
        //int...args

        int sum=getsum(1,2,3,4,5,6,7,8,9,10);
        System.out.println(sum);
    }

    //底层：
    //可变参数的底层就是一个数组
    //只不过不需要我们自己创建了，Java会帮我们创建好
    public static int getsum(int... args){
        int sum=0;
        for(int i:args){
            sum+=i;
        }
        return sum;
    }
}

可变参数的小细节:
1.在方法的形参中最多只能写一个可变参数
可变参数，理解为一个大胖子，有多少吃多少
2.在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后

Collections

 

package mycollections;

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

public class CollectionsDemo1 {
    public static void main(String[] args) {

        //addAll 批量添加元素
        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.批量添加元素
        Collections.addAll(list,"abc","1234","qwer","zxcv","asdf");
        //3.打印集合
        System.out.println(list);

        //shuffle 打乱集合元素
        Collections.shuffle(list);
        System.out.println(list);
    }
}

习题

1.班里有n个学生，实现随机点名

package a06test;

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

public class Test1 {
    public static void main(String[] args) {
        //1.定义集合
        ArrayList<String> list = new ArrayList<>();
        //2.添加元素
        Collections.addAll(list, "a", "b", "c", "d", "e");

        //(1)
        //3.打乱集合
        Collections.shuffle(list);
        //4.输出
        System.out.println(list.get(0));

        //(2)
        //打乱
        Random r = new Random();
        int index=r.nextInt(list.size());
        System.out.println(list.get(index));
    }
}

2.班级里有N个学生
要求:
70%的概率随机到男生
30%的概率随机到女生

扫描二维码关注公众号，回复： 17624514 查看本文章 
package a06test;

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

public class Test2 {
    public static void main(String[] args) {
        Random r=new Random();
        int index=r.nextInt(10);
        ArrayList<String> boylist=new ArrayList();
        ArrayList<String> girllist=new ArrayList();
        Collections.addAll(boylist,"张无忌");
        Collections.addAll(girllist,"张三丰");

        if(index<7){
            int boyindex=r.nextInt(boylist.size());
            String boyname=boylist.get(boyindex);
            System.out.println("恭喜你，你是"+boyname);
        }else{
            int girlindex=r.nextInt(girllist.size());
            String girlname=girllist.get(girlindex);
            System.out.println("恭喜你，你是"+girlname);
        }
    }
}

3.
班级里有N个学生
要求:
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了，需要重新开启第二轮点名， 

package a06test;

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

public class Test3 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            //1.创建集合对象
            ArrayList<String> list = new ArrayList<>();
            //2.添加元素
            Collections.addAll(list, "1", "2", "3", "4", "5");
            //3.打乱集合元素顺序
            Collections.shuffle(list);
            //4.输出
            for (int j = 0; j < list.size(); j++) {
                System.out.println(list.get(j));
            }
            System.out.println("------------------");
        }
    }
}

阶段项目：斗地主

排序

1.如果原始数据的规律非常复杂，我们可以先手动排序让每一个数据跟唯一的序号产生对应关系。
序号就是数字，规律非常简单，后续的所有操作，我们以序号为准
当真正需要操作原始数据时候，再通过序号找到原始数据即可。

package doudizhu2;

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

public class PokerGame {

        //牌盒(静态只能访问静态)
        //此时我们只需要把牌和序号产生对应关系就可以了，不需要按照序号进行排序，所以只要HashMap即可
        //我们要对谁进行操作，就让谁当键
        static HashMap<Integer,String> hm=new HashMap<>();
        static ArrayList<Integer> list=new ArrayList<>();

        //静态代码块
        //特点：随着类的加载而加载，只加载一次，优先于主函数执行
        static{
            //准备牌
            String[] colors={"♦","♣","♥","♠"};
            String[] numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
            int serialNumber=1;
            //依次表示灭一个数字
            for(String number:numbers){
                //依次表示每一个花色
                for(String color:colors){
                    hm.put(serialNumber,color+number);
                    list.add(serialNumber);
                    serialNumber++;
                }
            }
            //添加大小王
            hm.put(serialNumber,"小王");
            list.add(serialNumber);
            serialNumber++;
            hm.put(serialNumber,"大王");
            list.add(serialNumber);
        }

        //构造函数
        public PokerGame(){
            //System.out.println(list);
            //洗牌
            Collections.shuffle(list);
            //发牌
            TreeSet<Integer> lord=new TreeSet<>();
            TreeSet<Integer> player1=new TreeSet<>();
            TreeSet<Integer> player2=new TreeSet<>();
            TreeSet<Integer> player3=new TreeSet<>();
            for(int i=0;i<list.size();i++){
                    int serialNumber=list.get(i);
                    if(i<=2){
                        lord.add(serialNumber);
                        continue;
                    }
                    if(i%3==0){
                        player1.add(serialNumber);
                    }
                    if(i%3==1){
                        player2.add(serialNumber);
                    }
                    if(i%3==2){
                        player3.add(serialNumber);
                    }
            }
            //看牌
            lookPoker("底牌",lord);
            lookPoker("玩家1",player1);
            lookPoker("玩家2",player2);
            lookPoker("玩家3",player3);
        }
        public static void lookPoker(String name,TreeSet<Integer> ts){
            System.out.print(name+"的牌是：");
            for(int serialNumber:ts){
                String poker=hm.get(serialNumber);
                System.out.print(poker+" ");
            }
            System.out.println();
        }
}

2.给每一张牌计算价值，并排序

package doudizhu3;

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

public class PokerGame {

        //牌盒(静态只能访问静态)
        static ArrayList<String> list=new ArrayList<>();

        //创建一个集合，用来添加牌的价值
        static HashMap<String,Integer> hm=new HashMap<>();
        //静态代码块
        //特点：随着类的加载而加载，只加载一次，优先于主函数执行
        static{
            //准备牌
            String[] colors={"♠","♥","♣","♦"};
            String[] numbers={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            for(String color:colors){
                for(String number:numbers){
                    list.add(color+number);
                }
            }
            //添加大小王
            list.add(" 小王");
            list.add(" 大王");

            //添加价值
            //牌上的数字到map集合中判断是否存在
            //存在，获取价值
            //不存在，本身的数字就是价值
            hm.put("J",11);
            hm.put("Q",12);
            hm.put("K",13);
            hm.put("A",14);
            hm.put("2",15);
            hm.put("小王",50);
            hm.put("大王",100);
        }

        //构造函数
        public PokerGame(){
            //System.out.println(list);
            //洗牌
            Collections.shuffle(list);
            //发牌
            ArrayList<String> lord=new ArrayList();
            ArrayList<String> player1=new ArrayList<>();
            ArrayList<String> player2=new ArrayList<>();
            ArrayList<String> player3=new ArrayList<>();
            for(int i=0;i<list.size();i++){
                    String poker=list.get(i);
                    if(i<=2){
                        lord.add(poker);
                        continue;
                    }
                    if(i%3==0){
                        player1.add(poker);
                    }
                    if(i%3==1){
                        player2.add(poker);
                    }
                    if(i%3==2){
                        player3.add(poker);
                    }
            }

            //排序
            order(lord);
            order(player1);
            order(player2);
            order(player3);

            //看牌
            lookPoker("底牌",lord);
            lookPoker("玩家1",player1);
            lookPoker("玩家2",player2);
            lookPoker("玩家3",player3);
        }

        //利用牌的价值进行排序
        //参数：集合
        public void order(ArrayList<String> list){
                Collections.sort(list,new Comparator<String>(){
                    @Override
                    public int compare(String o1, String o2) {
                        //o1:表示现在要插入到有序序列中的牌
                        //o2:表示已经存在在有序序列中的牌

                        //负数：o1小 插入到前面
                        //正数：o1大 插入到后面
                        //0：o1和o2的数字是一样的 需要按照花色进行排序
                        //1.计算o1的花色和价值
                        String color1=o1.substring(0,1);
                        int value1=getValue(o1);

                        //2.计算o2的花色和价值
                        String color2=o2.substring(0,1);
                        int value2=getValue(o2);

                        //3.比较o1和o2的价值
                        int i=value1-value2;
                        return i==0?color1.compareTo(color2):i;
                    }
                });
        }

        //计算牌的价值
        //参数：牌
        //返回值：牌的价值
        public int getValue(String poker){
            //1.截取数字
            String number=poker.substring(1);
            //2.判断数字是否存在
            if(hm.containsKey(number)){
                //存在
                return hm.get(number);
            }else{
                //不存在
                return Integer.parseInt(number);
            }
        }

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

猜你喜欢

目录

热门文章