java中可变参数和简单游戏

最新推荐文章于 2024-09-25 20:00:24 发布
最新推荐文章于 2024-09-25 20:00:24 发布
阅读量1.2k 收藏 20
点赞数 10
分类专栏： java 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luosuss/article/details/137566086
版权

可变参数：
就是一种特殊形参，定义在方法，构造器的形参列表中，格式是：数据类型...参数名称

可变参数的好处：
灵活的接收数据

特点：可以不传数据给它，可以传一个数据或者多个数据给它，也可以传一个数组给它

可变参数的注意事项：

可变参数在方法内部就是一个数组

一个形参列表中的可变参数只有一个

可变参数必须在形参列表的最后面

public class test {
    public static void main(String[] args) {
        ttt();//可以不传数据

        ttt(1);//可以传一个数据
        ttt(1,2,3);//可以传多个数据

        ttt(new int[]{1,2,3});//可以传一个数组
    }
    public static void ttt(int...nums)
    {
        //可变参数在方法内部是一个数组
        System.out.println(Arrays.toString(nums));
    }
    //只能有一个可变参数，且必须在形参列表的最后
    public static void ppp(int age,int...s)
    {}
}

Collections类：
是一个用来操作集合的工具类

public static <T> boolean addAll(Collection<? super T> c, T... elements)

Adds all of the specified elements to the specified collection. Elements to be added may be specified individually or as an array.

往集合中批量添加数据

public static void shuffle(List<?> list)

Randomly permutes the specified list using a default source of randomness. 

打乱List集合中的元素顺序 

void sort(List<T> list)

对List集合中的元素进行升序排序 

public static <T> void sort(List<T> list, Comparator<? super T> c)

Sorts the specified list according to the order induced by the specified comparator. 

对List集合中的元素，按照比较器对象指定的规则进行排序 

public class test {
    public static void main(String[] args) {
        //1 addAll
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"java1","java2","java3");
        System.out.println(list);

        //2:shuffle
        Collections.shuffle(list);
        System.out.println(list);//[java2, java3, java1]

        //sort,默认升序
        Collections.sort(list);
        System.out.println(list);//[java1, java2, java3]

        //sort排序自定义对象
        ArrayList<Student>list1=new ArrayList<>();
        list1.add(new Student("aa",10));
        list1.add(new Student("bb",90));
        list1.add(new Student("cc",22));
        Collections.sort(list1, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();//按照年龄升序
            }
        });
        Collections.sort(list1,(o1,o2)->o1.getAge()-o2.getAge());
        System.out.println(list1);
    }
}public class test {
    public static void main(String[] args) {
        //1 addAll
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"java1","java2","java3");
        System.out.println(list);

        //2:shuffle
        Collections.shuffle(list);
        System.out.println(list);//[java2, java3, java1]

        //sort,默认升序
        Collections.sort(list);
        System.out.println(list);//[java1, java2, java3]

        //sort排序自定义对象
        ArrayList<Student>list1=new ArrayList<>();
        list1.add(new Student("aa",10));
        list1.add(new Student("bb",90));
        list1.add(new Student("cc",22));
        Collections.sort(list1, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();//按照年龄升序
            }
        });
        Collections.sort(list1,(o1,o2)->o1.getAge()-o2.getAge());
        System.out.println(list1);
    }
}

以下是一个简单的游戏：
牌类：

public class Card {
    private String number;
    private String color;
    private int size;

    public Card() {
    }

    public Card(String number, String color, int size) {
        this.number = number;
        this.color = color;
        this.size = size;//牌的大小
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return "Card{" +
                "number='" + number + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                '}';
    }
}

 操作牌类

public class Room {
    private ArrayList<Card>list=new ArrayList<>();

    public Room() {
        String []numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        int size=0;
        String []colors={"方块","梅花","红桃","黑桃"};
        for (String number : numbers) {
            size++;
            for (String color : colors) {
                Card c=new Card(number,color,size);
                list.add(c);
            }
        }
        Card c1=new Card("","小王",size++);
        Card c2=new Card("","大王",size);
        Collections.addAll(list,c1,c2);
        System.out.println(list);
    }
    public void randomCard()
    {
        System.out.println("开始洗牌");
        Collections.shuffle(list);
        //System.out.println(list);
    }
    public void devoteCard()
    {
        ArrayList<Card>list1=new ArrayList<>();
        ArrayList<Card>list2=new ArrayList<>();
        ArrayList<Card>list3=new ArrayList<>();

        for (int i = 0; i < list.size()-3; i++) {//只发51张牌
            Card c=list.get(i);
            if(i%3==0)
            {
                list1.add(c);
            }
            else if(i%3==1)
            {
                list2.add(c);
            }
            else
            {
                list3.add(c);
            }
        }
        sortCard(list1);
        sortCard(list2);//对牌进行大小排序
        sortCard(list3);

        System.out.println(list1);
        System.out.println(list2);
        System.out.println(list3);
        System.out.println("底牌是");
        List<Card> LastCard= list.subList(list.size()-3,list.size());//包前不包后
        System.out.println(LastCard);
    }

    private void sortCard(ArrayList<Card> list2) {
        /*Collections.sort(list2, new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o1.getSize()-o2.getSize();
            }
        });
    }*/
        Collections.sort(list2, (o1, o2) -> o1.getSize() - o2.getSize());
    }
}

test:

public class test {
    public static void main(String[] args) {
        Room r=new Room();
        r.randomCard();
        ArrayList<Card>[]lists=new ArrayList[3];
        r.devoteCard();

    }
}

 

 结果：

[Card{number='3', color='方块', size=1}, Card{number='3', color='梅花', size=1}, Card{number='3', color='红桃', size=1}, Card{number='3', color='黑桃', size=1}, Card{number='4', color='方块', size=2}, Card{number='4', color='梅花', size=2}, Card{number='4', color='红桃', size=2}, Card{number='4', color='黑桃', size=2}, Card{number='5', color='方块', size=3}, Card{number='5', color='梅花', size=3}, Card{number='5', color='红桃', size=3}, Card{number='5', color='黑桃', size=3}, Card{number='6', color='方块', size=4}, Card{number='6', color='梅花', size=4}, Card{number='6', color='红桃', size=4}, Card{number='6', color='黑桃', size=4}, Card{number='7', color='方块', size=5}, Card{number='7', color='梅花', size=5}, Card{number='7', color='红桃', size=5}, Card{number='7', color='黑桃', size=5}, Card{number='8', color='方块', size=6}, Card{number='8', color='梅花', size=6}, Card{number='8', color='红桃', size=6}, Card{number='8', color='黑桃', size=6}, Card{number='9', color='方块', size=7}, Card{number='9', color='梅花', size=7}, Card{number='9', color='红桃', size=7}, Card{number='9', color='黑桃', size=7}, Card{number='10', color='方块', size=8}, Card{number='10', color='梅花', size=8}, Card{number='10', color='红桃', size=8}, Card{number='10', color='黑桃', size=8}, Card{number='J', color='方块', size=9}, Card{number='J', color='梅花', size=9}, Card{number='J', color='红桃', size=9}, Card{number='J', color='黑桃', size=9}, Card{number='Q', color='方块', size=10}, Card{number='Q', color='梅花', size=10}, Card{number='Q', color='红桃', size=10}, Card{number='Q', color='黑桃', size=10}, Card{number='K', color='方块', size=11}, Card{number='K', color='梅花', size=11}, Card{number='K', color='红桃', size=11}, Card{number='K', color='黑桃', size=11}, Card{number='A', color='方块', size=12}, Card{number='A', color='梅花', size=12}, Card{number='A', color='红桃', size=12}, Card{number='A', color='黑桃', size=12}, Card{number='2', color='方块', size=13}, Card{number='2', color='梅花', size=13}, Card{number='2', color='红桃', size=13}, Card{number='2', color='黑桃', size=13}, Card{number='', color='小王', size=13}, Card{number='', color='大王', size=14}]
开始洗牌
[Card{number='3', color='方块', size=1}, Card{number='3', color='黑桃', size=1}, Card{number='4', color='黑桃', size=2}, Card{number='4', color='梅花', size=2}, Card{number='4', color='方块', size=2}, Card{number='6', color='方块', size=4}, Card{number='8', color='梅花', size=6}, Card{number='8', color='黑桃', size=6}, Card{number='9', color='梅花', size=7}, Card{number='10', color='黑桃', size=8}, Card{number='10', color='方块', size=8}, Card{number='J', color='红桃', size=9}, Card{number='J', color='梅花', size=9}, Card{number='J', color='黑桃', size=9}, Card{number='K', color='红桃', size=11}, Card{number='A', color='黑桃', size=12}, Card{number='2', color='黑桃', size=13}]
[Card{number='3', color='红桃', size=1}, Card{number='6', color='黑桃', size=4}, Card{number='6', color='红桃', size=4}, Card{number='7', color='方块', size=5}, Card{number='7', color='红桃', size=5}, Card{number='7', color='黑桃', size=5}, Card{number='10', color='梅花', size=8}, Card{number='J', color='方块', size=9}, Card{number='Q', color='黑桃', size=10}, Card{number='K', color='方块', size=11}, Card{number='K', color='梅花', size=11}, Card{number='K', color='黑桃', size=11}, Card{number='A', color='红桃', size=12}, Card{number='2', color='梅花', size=13}, Card{number='2', color='红桃', size=13}, Card{number='', color='小王', size=13}, Card{number='', color='大王', size=14}]
[Card{number='3', color='梅花', size=1}, Card{number='4', color='红桃', size=2}, Card{number='5', color='红桃', size=3}, Card{number='5', color='梅花', size=3}, Card{number='5', color='方块', size=3}, Card{number='5', color='黑桃', size=3}, Card{number='7', color='梅花', size=5}, Card{number='8', color='红桃', size=6}, Card{number='8', color='方块', size=6}, Card{number='9', color='黑桃', size=7}, Card{number='9', color='方块', size=7}, Card{number='9', color='红桃', size=7}, Card{number='10', color='红桃', size=8}, Card{number='Q', color='红桃', size=10}, Card{number='Q', color='梅花', size=10}, Card{number='Q', color='方块', size=10}, Card{number='2', color='方块', size=13}]
底牌是
[Card{number='A', color='梅花', size=12}, Card{number='6', color='梅花', size=4}, Card{number='A', color='方块', size=12}]
 

落落落sss
关注
专栏目录
Java小白入门200例77之Java方法的可变参数
编程界明世隐的博客
09-30 233
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 引言 很多Java初学者问我，新手明明很用心、很努力学习的Java知识，转头又忘记了，很让人犯愁，小白如何能够快速成长、成为大牛呢？ 其实要成为大神的技巧只有一个：“多学多练”，于是明哥就整理了比较典型的练习实例，通过练习能够快速提升编码技巧和熟练度，让你在成为大
f1-2018_telemetry:一个Java应用程序，可使用Codemaster F1 2018视频游戏中的UDP遥测数据
05-26
Java作为一种面向对象的语言，其丰富的库和强大的网络编程能力使得处理UDP数据变得简单且高效。开发者可以利用Java的Socket类和DatagramPacket类来接收和解析来自游戏的UDP数据包。 该项目的核心部分在于解析游戏...
Java的可变参数列表
markMe1024的博客
02-14 804
先写例子，再解释： private static void printVariableArgs(Object... args) { System.out.print(&amp;amp;amp;amp;amp;amp;amp;quot;argsLength: &amp;amp;amp;amp;amp;amp;amp;quot; + args.length + &amp;amp;amp;amp;amp;amp;amp;quot;; args: &amp;amp;amp;am
Java可变形参
深漂小码哥
05-09 238
package com.leo; /** * 可变个数形参 * 格式： 类型 ...变量名 * 可变参数必须放在参数列表的最后 */ public class MethodArgs { public static void main(String[] args) { MethodArgs methodArgs = new MethodArgs(); methodArgs.show(1688, "hello", "java"); } pu.
Java面向对象基础——构造器 可变形参 传参机制
最新发布
weixin_56273318的博客
09-25 498
在Java中，每个类都有它的构造函数，当类的对象被创建时，该构造函数将被自动调用。构造方法的名字必须和所在类的名字一致，当我们的一个方法的参数中有可变参数，我们在调用这个方法时，传入了一个数组，这个数组的内容就可以与可变参数匹配。可以使用权限修饰来修饰类及类的内部成员，当这些成员被调用时，体现可见性的大小。3) 可变参数在调用时，针对可变参数赋值的实参个数可以为0个、1个、2个。5）可变参数的方法与同一个类中，同名的多个方法之间可以构成重载。>若是引用类型的变量，则将此变量保存的地址传递出去。
java关于可变参数的笔记
baidu_39586935的博客
09-04 178
仅供学习使用，原文链接 https://www.cnblogs.com/xy-hong/p/7192796.html 我们在编写方法的过程中，可能会遇见一个方法有不确定参数个数的情况。一般我们会用方法重载来解决问题： 1 //方法重载，解决参数个数不确定问题 2 public void method(); 3 public void method(int i); 4 public void...
JAVA 可变形参
weixin_67259232的博客
03-24 742
可变个数得形参得方法----------我们最好声明到末尾 依旧可以通过数组来进行调 1. jdk 5.0 新增得内容 2. 具体使用 ：可变个数形参的格式 ： 数据类型 ...变量名 相当于动态匹配我们相同类型得可变个数参数 public void show (String ... strs){} 可变形参我们默认为与我们的数组是相同，如果我们在方法中出现就会默认为重写 如果我们在一个方法中出现有限个形参，我们会有限匹配我们有限个形参，后匹配可变个数的...
Java实现生命游戏.zip
09-10
在这个项目中，Java被用来编写代码，实现生命游戏的规则和交互功能。开发者可能使用了Java的基础语法，包括类、对象、变量、条件语句、循环、异常处理等，来构建游戏的核心逻辑。 生命游戏的规则相当简洁：在一个二...
Java作业，使用OpenCV实现的一个简单的贪吃蛇游戏+源代码+文档说明
12-21
2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象：计算机，电子信息工程、数学等专业的大学生...
生命游戏java实现.rar
11-03
棋盘颜色的可变性则增加了游戏的视觉吸引力。通过改变细胞的颜色和背景色，我们可以更清晰地分辨不同状态的细胞，使得游戏的视觉效果更加丰富多彩。同时，这也为未来的扩展提供了可能性，比如通过颜色编码来表示不同...
java---可变形参
chen_zan_yu_的博客
04-21 513
package cn.sxt.exer; /* *可变个数的形参方法 * *1.具体使用 * 2，可变个数形参的格式，数据类型。。。变量名 * 2.1当调用可变参数的方法时，传入的参数个数可以是0，1，2，3，。。。。 * 2.2可变个数形参的方法与本类中方法相同，参数不同的方法之间构成重载 * 2.3可变个数参数的方法与本类中方法名相同，参数类型也相同的数组之间不构成重载...
Java基础——可变个数的形参
Clannad191的博客
05-19 583
package com.atguigu.java1; /* 可变个数形参的方法： jdk5.0新增 具体使用： > 可变个数形参的格式：数据类型 ... 变量名 > 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个... > 可变个数形参的方法，与本类中方法名相同、参数列表不同的方法，也构成重载 > 可变个数...
Java可变参数的形参方法
beloved_yu的博客
10-20 835
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。总结一些，个人理解，传进去的可变参数就是一个数组，那么传进去的就可以是很多个数字，也可以直接传进去数组，也可以传进去的是空数组。返回值类型 方法名称(类型 参数一， 类型 参数二， 类型...参数三） {必须是方法的最后一个参数，其他的参数必须在它之前声明。可以直接在里边写入参数，用逗号隔开；在这里的0是给num的。
JAVA可变形参方法
sd_WangYaJun的博客
07-25 800
JAVA可变形参方法 (1) 格式 方法类型 方法名（数据类型 … 形参名）{}如：public void getName(int ... args){}(2) 可变个数形参在调用时，个数从0开始，到无穷多个都可以 (3) 若方法存在可变个数的形参，那么一定要申明在方法形参的最后。所以一个方法里最多只有一个可变形参 例如：public class TestA { public stati
java可变形参的使用
qq_51694024的博客
11-30 1115
java可变形参的使用 java类中可变个数的形参的使用; 格式：数据类型 + … + 变量名/参数名. 如下例： public void charater(String...name){ System.out.print(name); } 这个方法中的形参是可变个数的，即可以在调用时输入多个字符串，用逗号隔开即可。如下调用： public class ReallyTestone { public static void main(String[] args){
Java 可变个数形参的方法
@素素~的博客
02-20 910
Java 可变个数形参的方法直接看代码演示优先级多个参数传参情况总结简单测试代码 小小知识，不值一提，了解了也不能让你提高身价，但是不了解你就是比别人少知道点！事儿就是这么个事儿，直接正题吧！ 直接看代码 演示 优先级 当方法1无参和方法2有参存在时，执行上面的main方法调用并观看结果： 当只有可变参数方法存在时，再重新执行看看 多个参数传参情况 一是多个参数逗号隔开传参 二是直接可以传数组 总结 ①调用的时候参数可不传或传多个 ②如果有无参或者有可数个参数的重载方法存在时，调用同名
java中的可变形参的方法
dwjdj的博客
01-23 306
可变个数形参的方法 1.jdk5.0新增的内容 2.具体使用： 2.1 可变个数形参的格式： 数据类型 …变量名 2.2 当调用可变个数形参的方法时，传入的实参个数可以是零个，一个或一个以上 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法间构成了重载 2.4 可变个数形参的方法与本类中方法名相同，形参类型相同的数组之间不构成重载。 2.5 可变个数形参在方法中，必须声明在末尾 2.6 可变个数形参在方法的形参中，最多只能声明一个可变形参 public static void main(S.
Java毛毛虫小游戏完整项目下载学习指南
- 游戏初始化：设置游戏窗口和必要的游戏参数。 - 游戏循环：游戏主循环负责处理事件循环、游戏状态更新和画面渲染。 - 控制响应：监听玩家的输入并作出相应的控制动作。 - 碰撞检测：判断毛毛虫是否与食物或其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落落落sss

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值