JAVA集合部分_存储玩家的集合arraylist<player>-CSDN博客

本文链接：https://blog.csdn.net/weixin_53607277/article/details/127825010

@TOC# 集合-

第一章、集合框架介绍：

1、学习集合的目标：

1.会使用集合存储数据

2.会遍历集合，把数据提取出来

3.掌握每种集合的特性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QSDGOIAO-1668256169872)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221108202834175.png)]

2、集合常用功能：

import java.util.ArrayList;
import java.util.Collection;
//Collection 接口  顶层集合！！
/* collection的一些方法 ：
        public boolean add();
        public boolean isEmpty();
        public boolean contains();
         public boolean remove();
         public void clear();
         public int size();

 */
public class JiHe {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<>();
        c.add("张三");
        c.add("李四");
        c.add("王五");
        System.out.println(c);
        //c.clear();//清空集合内所有元素
        //System.out.println(c);
        boolean flag =c.contains("张三");
        System.out.println(flag);

        c.remove("张三");
        System.out.println(c);

        Object[] objs=c.toArray();
        System.out.println(objs);
        for (int i = 0; i <objs.length; i++) {
            System.out.println(objs[i]);
        }
        int size= c.size();
        System.out.println(size);
    }
}

第二章、 Iterator(接口)迭代器

1.1、迭代器

迭代器：是通用的取出集合中元素的方式。在取元素之前我们要判断集合中是否有元素存在（hasNext()），如果有则取出(Next())，继续再判断，如果还有就再取出来，一直到把集合中所有元素取出，这种取出方式的专业术语叫做迭代！

可以对集合进行遍历。

/*Iterator 接口:迭代器 可以对集合进行遍历！
有两个常用的方法：
    boolean hasNext() 如果仍有元素可以迭代，则输出true；判断集合中是否有下一个元素，有就返回true，
    没有就返回false；
    E Next():返回迭代的下一个元素。去除集合中的下一个元素；
    Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象
    获取实现类的方式比较特殊！
    Collection接口中有一个方法叫做iterator() ,这个方法返回的就是实现类的对象！
    Iterator<> iterator () 返回在此collection元素上进行迭代的迭代器！

    使用步骤：
       1.使用iterator()方法来获取迭代器的实例化对象，使用Iterator接口接收（多态）;
       2.使用Iterator中的方法hasNext()来判断还有没有下一个元素；
       3.使用next()方法来取出集合中的下一个元素。
 */
public class IteratorDemo {
    public static void main(String[] args) {

        Collection<String> coll=new ArrayList<>();//创建集合对象
        coll.add("阿迪");
        coll.add("阿玛尼");
        coll.add("耐克");
        coll.add("北面");
        coll.add("乔丹");
        System.out.println(coll);
        
        Iterator<String> it= coll.iterator();//import java.util.Iterator;
        boolean b= it.hasNext();
        System.out.println(b);
        /*在这里用next方法来取出集合中的元素时，发现有重复过程
        要进行while循环优化，因为不确定有多少元素，所以用while，否则用for循环。
        循环结束的条件是 hasNext()=false;
         */
        while (it.hasNext()==true){
            String n=it.next();
            System.out.println(n);
        }
    }
}

2.2 迭代器的实现原理

2.3、for循环增强

是jDK1.5出来以后的高级for循环，专门用来遍历数组和集合的！他的内部原理其实是个Iterator迭代器，所以不能直接对集合中的元素直接进行操作！

public class forDemo {
    public static void main(String[] args) {
      method01();
       // method02();   
    }
    //遍历数组
    private static void method01(){
      int arr[]={12,34,32};
      for (int a:arr) {
          System.out.println(a);
      }
      }
    //遍历集合
      private static void method02(){
         ArrayList<String> ar=new ArrayList<>();
         ar.add("中国");
         ar.add("日本");
         ar.add("法国");
         Iterator<String> it=ar.iterator();
         for (String r:ar){
             System.out.println(r);
         }
    }
}

第三章、泛型

在我们学习集合时，都知道集合中可以存放任意的对象，但是只要把对象存储集合后，这时他们都被提升为object类型，当我们再取出每一个对象，并进行相应的操作，就需要类型转换！

3.1、泛型的概念

当我们不知道使用什么数据类型时就可以用泛型，泛型也可以看出是一个变量，用来接收数据类型，

E e：element元素

T t： Type类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wh4CHHBi-1668256169874)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221110134454054.png)]

ArrayList 集合创建对象的时候就会确定泛型的数据类型：

ArrayList<String> arr=new ArrayList();

3.2、使用泛型的好处

public class GenericDemo {
    public static void main(String[] args) {
        show02();
    }
    private static void show01(){
        //创建一个集合对象，不使用泛型！
        ArrayList arr=new ArrayList();
        arr.add("abc");
        arr.add(2);

        //使用Iterator遍历！
        Iterator it=arr.iterator();
      while (it.hasNext()){
          Object obj=it.next();
          System.out.println(obj);

          /*如果我们想用String的特有方法 length来获取字符串的长度  不能使用！ 多态
           需要向下转型
           异常：ClassCastException：类型转换异常  不能把int类型转换成String类型！
           */
          String s=(String) obj;
          System.out.println(s.length());
      }
    }

    /*
    使用泛型！ 好处：
    1.不用进行类型转换，存储的什么类型，取出就是什么类型！
    2.不会出现编译器异常！
    弊端：
    就是泛型是什么类型，就只能存储什么类型！
     */
    private static void show02(){
        ArrayList<String> arr2 =new ArrayList<>();
        arr2.add("中国");
        arr2.add("日本");
        arr2.add("法国");
        Iterator<String> it=arr2.iterator();
        while (it.hasNext()){
            String s=it.next();
            System.out.println(s);
            System.out.println(s.length());
        }
    }
}

3.3、泛型的定义与使用

定义格式：

修饰符 class 类名 <代表泛型的变量> {}

/*
定义一个含有泛型的类，来模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定是一个什么数据类型的时候可以使用泛型
创建对象的时候来确定使用什么数据类型！
 */
public class GenericClass<E> {
    private E name;
    private E age;


    public E getAge() {
        return age;
    }

    public void setAge(E age) {
        this.age = age;
    }

    public E getName() {
        return  name;
    }

    public void setName(E name) {
        this.name=name;
    }
}

public class DemoGenericClass {
    public static void main(String[] args) {
        method02();
    }
    //创建一个GenericClass对象,泛型使用String类型
   private  static  void method01(){
        GenericClass<String> gc = new GenericClass<>();
        gc.setName("dong东");

        String n = gc.getName();
        System.out.println(n);
    }
    //创建一个GenericClass对象,泛型使用int类型
    private  static void method02(){
        GenericClass<Integer> gc2=new GenericClass<>();
        gc2.setAge(21);
        int age=gc2.getAge();
        System.out.println(age);
    }
}

3.4、泛型的使用方法（1）

/*
在方法里使用泛型,泛型定义在修饰符与返回值之间
    格式：
        修饰符<泛型> 返回值 方法名（使用泛型）{
        方法体；
        }
 */
public class GenericMethod {
    public <M> void method01(M m) {
        System.out.println(m);
    }
       //静态方法：
    public static<S> void method02(S s){
        System.out.println(s);

    }
}

public class DemoGenericMethod {
    public static void main(String[] args) {
        //创建一个GenericMethod对象
        GenericMethod gm=new GenericMethod();
        gm.method01("name");
        gm.method01("age");
        gm.method01(12);
        gm.method01(12.23);

        gm.method02("静态方法，不建议使用");
    }
}

3.5、定义泛型的接口

*
定义含有泛型的接口
 */
public interface GenericInterface<E> {
    public abstract void method(E e);
}

第一种使用方式：

/*
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
 */
public class GenericInterfaceimpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

第二种使用方式：

/*
第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型。
public interface List<E>{
     boolean add(E e);
 */
public class GenericInterfaceImpl2<E> implements GenericInterface<E>{

    @Override
    public void method(E e) {
        System.out.println(e);
    }
}

测试类：

//测试类
public class DemoGenericInteerface {
    public static void main(String[] args) {
      GenericInterfaceimpl1 gi1=new GenericInterfaceimpl1();
        gi1.method("中国");
        //gi1.method(123);//报错
        gi1.method("法国");

        GenericInterfaceImpl2<String> gi2=new GenericInterfaceImpl2();
        // gi2.method(123);//报错！
        gi2.method("刘振东");
    }
}

3.6、泛型的通配符？

/*
    泛型通配符：？  当不知道用什么类型时，就用？
 */
public class Demo02Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList();
        list.add(12);
        list.add(34);

        ArrayList<String> list1=new ArrayList<>();
        list1.add("东东");
        list1.add("冬冬");

        printArray(list1);
        printArray(list);

    } /*需求： 定义一个方法来遍历所有类型的ArrayList集合元素！
         这时我们不知道ArrayList使用的什么数据类型，我们可以使用通配符？来接收数据类型
         注意：
             泛型是没有继承概念的！
     */
    public static void printArray(ArrayList<?> list){
        Iterator<?> it1=list.iterator();
        while (it1.hasNext()){
            //it.next()方法取出的是Object（）类型，因为只有object可以接收任意类型！
            Object o = it1.next();
            System.out.println(o);
        }
    }
}

3.7、通配符的高级使用

/*
    泛型通配符：？  当不知道用什么类型时，就用？
 */
public class Demo02Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList();
        list.add(12);
        list.add(34);

        ArrayList<String> list1=new ArrayList<>();
        list1.add("东东");
        list1.add("冬冬");

        printArray(list1);
        printArray(list);

    } /*需求： 定义一个方法来遍历所有类型的ArrayList集合元素！
         这时我们不知道ArrayList使用的什么数据类型，我们可以使用通配符？来接收数据类型
         注意：
             泛型是没有继承概念的！
     */
    public static void printArray(ArrayList<?> list){
        Iterator<?> it1=list.iterator();
        while (it1.hasNext()){
            //it.next()方法取出的是Object（）类型，因为只有object可以接收任意类型！
            Object o = it1.next();
            System.out.println(o);
        }
    }
}

集合----斗地主综合案例

需求分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qn9gJgjh-1668256169875)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221112111158924.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-059Uv9vn-1668256169876)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221112111650153.png)]

代码实现

/*
斗地主综合案例：
      1.准备牌
      2.发牌
      3.看牌
 */
public class doudz {
    public static void main(String[] args) {
        //创建一个集合对象
        ArrayList<String> arr=new ArrayList<>();
        //创建两个数组，来分别放牌和花色！
        String[] ar1={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] ar2={"♦","♠","♥","♣"};
        //先把大王，小王来存到集合arr中
        arr.add("大王");
        arr.add("小王");
        //循环遍历两个数组，组装两个数组！
        for( String s1:ar1){
            for( String s2:ar2){
                System.out.println(s2+s1);
                arr.add(s2+s1);
            }
        }

        System.out.println(arr);
      //发牌！
        Collections.shuffle(arr);//打乱牌的顺序，来随机发牌！
        System.out.println(arr);

        String player1=("玩家1");
        String player2="玩家2";
        String player3="玩家3";
        String bt="底牌";
        //定义四个集合来存储玩家的牌和底牌！
        ArrayList<String> player01=new ArrayList<>();
        ArrayList<String> player02=new ArrayList<>();
        ArrayList<String> player03=new ArrayList<>();
        ArrayList<String> bottom=new ArrayList<>();
        //发牌
        for (int i = 0; i<arr.size() ; i++) {
           //获取每一张牌
            String pk = arr.get(i);
            if (i%3==0&&i<51){
                player01.add(pk);
            }else if (i%3==1&&i<51){
                player02.add(pk);
            }else if (i%3==2&&i<51){
                player03.add(pk);
            }else if (i>=51){
                bottom.add(pk);
            }
        }
        //看牌
        System.out.println(player1+player01);
        System.out.println(player2+player02);
        System.out.println(player3+player03);
        System.out.println(bt+bottom);
    }
}