分享一下，大家有空也可以按要求自己练练
/*
        扑克牌程序
        1.得到52张扑克牌
        2.洗牌

        3.查找出红桃A在哪个位置

        分析:扑克牌有花色  值    可以定义一个Poker类

*/
import java.util.*;
class Test
{
        public static void main(String[] args)
        {
                Poker[] ps=PokerTools.getPokers();
                PokerTools.showPokers(ps);//没洗牌之前
                PokerTools.xiPai(ps);//洗牌操作
                System.out.println("\n--------------------------------------");
                PokerTools.showPokers(ps);//洗牌之后
                System.out.println("\n--------------------------------------");
                int index=PokerTools.findPoker(new Poker("红桃","A"),ps);
               
                System.out.println(index+1);
        }
}
//这个类作用是定义扑克的花色与面值
class PokerTools
{
        //花色
        public static final String[] cs={"黑桃","红桃","方块","梅花"};
        //面值
        public static final String[] ns={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        //得到52张牌
        public static Poker[] getPokers(){
               
                Poker[] ps=new Poker[cs.length*ns.length];//这个数组中的元素的默认值为null
               
                int index=0;
                for(int i=0;i<cs.length;i++){
                        
                        for(int j=0;j<ns.length;j++){
                                /*
                                ps[index]=new Poker();//通过无参构造初始化
                                //对每一张扑克牌的花色与面值进行初始化
                                ps[index].setColor(cs);
                                ps[index].setNumber(ns[j]);
                                */
                                ps[index]=new Poker(cs,ns[j]);//通过有参数构造
                                index++;
                        }
                }

                return ps;
        }
        //洗牌
        /*
                每一次得到两个在数组下标范围内的数值，
                通过这两个值来控制对应位置上的扑克对象
                进行位置交换。
        */
        public static void xiPai(Poker[] ps){
                Random ran=new Random();
                for(int i=0;i<100;i++){
                        //得到两个0-52之间的数不包含52
                        int n1=ran.nextInt(ps.length);
                        int n2=ran.nextInt(ps.length);
                        
                        //n1与n2位置上的元素交换
                        Poker p=ps[n1];
                        ps[n1]=ps[n2];
                        ps[n2]=p;
                }
        }
        //显示扑克牌
        public static void showPokers(Poker[] ps){
               
                for(int i=0;i<ps.length;i++){
                        
                        if(i%13==0){
                                System.out.println();
                        }
                        System.out.print(ps+"  ");
                }
        }
        // 查找指定的扑克所在的位置
        /*
                参数:1.要查找的扑克牌 2.所有扑克牌
                返回值:这个扑克牌所在位置
        */
        public static int findPoker(Poker p,Poker[] ps){
               
                for(int i=0;i<ps.length;i++){
                        if(ps.equals(p)){
                                return i;
                        }
                        /*
                        //当前的比较很麻烦，如果以后还要比较，还需要写这么多内容
                        if(ps.getColor().equals(p.getColor())&&ps.getNumber().equals(p.getNumber())){
                                
                                return i;
                        }*/                        
                }
                return -1;
        }
}

//定义一个扑克类
class Poker
{
        //私有化，要想外部访问，必须提供get  set方法
        private String color;
        private String number;
        /*
                构造方法重载，好处就是可以通过两种方式得到Poker对象
        */
        //提供无参构造方法
        public Poker(){
        
        }
        //提供有参构造
        public Poker(String color,String number){
                this.color=color;
                this.number=number;
        }
        //对color赋值
        public void setColor(String color){
                this.color=color;//通过this来区分局部与成员
        }
        //对number赋值
        public void setNumber(String number){
                this.number=number;
        }
        //取color值
        public String getColor(){
                return color;
        }
        //取number值
        public String getNumber(){
                return number;
        }
        //重写equals方法
        public boolean equals(Object obj){
               
                if(this==obj){
                        return true;
                }
                if(obj instanceof Poker){
                        
                        Poker p=(Poker)obj;
                        return p.color.equals(color)&&p.number.equals(number);
                }
                return false;
        }
        //重写toString
        public String toString(){
               
                return color+number;
        }
}

                                       分享一下，大家有空也可以按要求自己练练
/*
        扑克牌程序
        1.得到52张扑克牌
        2.洗牌

        3.查找出红桃A在哪个位置

        分析:扑克牌有花色  值    可以定义一个Poker类

*/
import java.util.*;
class Test
{
        public static void main(String[] args)
        {
                Poker[] ps=PokerTools.getPokers();
                PokerTools.showPokers(ps);//没洗牌之前
                PokerTools.xiPai(ps);//洗牌操作
                System.out.println("\n--------------------------------------");
                PokerTools.showPokers(ps);//洗牌之后
                System.out.println("\n--------------------------------------");
                int index=PokerTools.findPoker(new Poker("红桃","A"),ps);
               
                System.out.println(index+1);
        }
}
//这个类作用是定义扑克的花色与面值
class PokerTools
{
        //花色
        public static final String[] cs={"黑桃","红桃","方块","梅花"};
        //面值
        public static final String[] ns={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        //得到52张牌
        public static Poker[] getPokers(){
               
                Poker[] ps=new Poker[cs.length*ns.length];//这个数组中的元素的默认值为null
               
                int index=0;
                for(int i=0;i<cs.length;i++){
                        
                        for(int j=0;j<ns.length;j++){
                                /*
                                ps[index]=new Poker();//通过无参构造初始化
                                //对每一张扑克牌的花色与面值进行初始化
                                ps[index].setColor(cs);
                                ps[index].setNumber(ns[j]);
                                */
                                ps[index]=new Poker(cs,ns[j]);//通过有参数构造
                                index++;
                        }
                }

                return ps;
        }
        //洗牌
        /*
                每一次得到两个在数组下标范围内的数值，
                通过这两个值来控制对应位置上的扑克对象
                进行位置交换。
        */
        public static void xiPai(Poker[] ps){
                Random ran=new Random();
                for(int i=0;i<100;i++){
                        //得到两个0-52之间的数不包含52
                        int n1=ran.nextInt(ps.length);
                        int n2=ran.nextInt(ps.length);
                        
                        //n1与n2位置上的元素交换
                        Poker p=ps[n1];
                        ps[n1]=ps[n2];
                        ps[n2]=p;
                }
        }
        //显示扑克牌
        public static void showPokers(Poker[] ps){
               
                for(int i=0;i<ps.length;i++){
                        
                        if(i%13==0){
                                System.out.println();
                        }
                        System.out.print(ps+"  ");
                }
        }
        // 查找指定的扑克所在的位置
        /*
                参数:1.要查找的扑克牌 2.所有扑克牌
                返回值:这个扑克牌所在位置
        */
        public static int findPoker(Poker p,Poker[] ps){
               
                for(int i=0;i<ps.length;i++){
                        if(ps.equals(p)){
                                return i;
                        }
                        /*
                        //当前的比较很麻烦，如果以后还要比较，还需要写这么多内容
                        if(ps.getColor().equals(p.getColor())&&ps.getNumber().equals(p.getNumber())){
                                
                                return i;
                        }*/                        
                }
                return -1;
        }
}

//定义一个扑克类
class Poker
{
        //私有化，要想外部访问，必须提供get  set方法
        private String color;
        private String number;
        /*
                构造方法重载，好处就是可以通过两种方式得到Poker对象
        */
        //提供无参构造方法
        public Poker(){
        
        }
        //提供有参构造
        public Poker(String color,String number){
                this.color=color;
                this.number=number;
        }
        //对color赋值
        public void setColor(String color){
                this.color=color;//通过this来区分局部与成员
        }
        //对number赋值
        public void setNumber(String number){
                this.number=number;
        }
        //取color值
        public String getColor(){
                return color;
        }
        //取number值
        public String getNumber(){
                return number;
        }
        //重写equals方法
        public boolean equals(Object obj){
               
                if(this==obj){
                        return true;
                }
                if(obj instanceof Poker){
                        
                        Poker p=(Poker)obj;
                        return p.color.equals(color)&&p.number.equals(number);
                }
                return false;
        }
        //重写toString
        public String toString(){
               
                return color+number;
        }
}