【Collection、泛型】

Collection

集合：java存储数据的一个容器，常用的结合有List、Set，继承关系如图：

collection是所有集合的父接口，方法有：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(E e): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中。

import java.util.ArrayList;
import java.util.Collection;

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();

        //add
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        System.out.println(coll);
        //size
        System.out.println(coll.size());
        //isEmpty
        System.out.println(coll.isEmpty());

        //remove
        coll.remove("张三");
        System.out.println(coll);

        //contains
        System.out.println(coll.contains("李四"));

        //clear
        coll.clear();
        System.out.println(coll);
    }

}

Iterator迭代器

Iterator接口的常用方法：

• public E next()`:返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

import java.util.Iterator;
import java.util.List;

public class Demo4 {
    public static void main(String[] args) {
        List<String> list = List.of("张三", "李四", "王五", "赵六", "刘七");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.print(s+", ");
        }
    }
}
//结果：张三, 李四, 王五, 赵六, 刘七, 

增强for循环：

import java.util.List;

public class Demo5 {
    public static void main(String[] args) {
        List<String> list = List.of("张三", "李四", "王五", "赵六", "刘七");

        for (String s : list) {
            System.out.print(s+",");
        }
    }
}
//结果：张三, 李四, 王五, 赵六, 刘七, 

泛型

当我们在使用集合时，我们不知道集合存储的是什么类型的元素是，就可以用泛型代替，在使用是直接设置类型即可：
含有泛型的类：

class List<E>{}

含有泛型的方法：

public interface MyGenericInterface<E>{}

含有泛型的方法：

public <E> void f1(){}

含有泛型的成员变量：

private E name;

集合综合案例

按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
思路分析：

• 准备牌：

  牌可以设计为一个ArrayList,每个字符串为一张牌。
  每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
  牌由Collections类的shuffle方法进行随机排序。

• 发牌

  将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

• 看牌

  直接打印每个集合

package com.cyy.demo;

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

/*
    斗地主案例
    步骤：
        1、装牌
        2、洗牌
        3、发牌
        4、看牌

 */
public class Demo2 {
    public static void main(String[] args) {
        //定义装牌的集合
        ArrayList<String> puke = new ArrayList<>();

        //1、装牌
        puke.add("大☠");
        puke.add("小☺");
        String[] f1 = {"♠","♥","♣","♦"};
        String[] f2 = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        for (String s : f2) {
            for (String s1 : f1) {
                puke.add(s+s1);
            }
        }


        //2、洗牌
        Collections.shuffle(puke);
//        System.out.println(puke);

        //3、发牌
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();

        for (int i = 0; i < puke.size(); i++) {
            if(i >= 51){
                dipai.add(puke.get(i));
            }else if (i % 3 == 0){
                player1.add(puke.get(i));
            }else if (i % 3 == 1){
                player2.add(puke.get(i));
            }else if (i % 3 == 2){
                player3.add(puke.get(i));
            }
        }

        //4、看牌
        System.out.println("player1:"+player1);
        System.out.println("player2:"+player2);
        System.out.println("player3:"+player3);
        System.out.println("底牌:"+dipai);


    }
}
/*
	运行结果：
player1:
[6♥, 7♣, A♦, 7♦, 6♠, 7♠, 10♥, J♦, Q♠, A♠, Q♣, 9♦, K♠, 8♦, 10♦, 5♣, 2♣]
player2:
[Q♥, 4♣, 3♣, 7♥, A♣, J♣, 小☺, A♥, 8♥, 9♠, K♥, 6♣, J♥, 6♦, 9♣, K♦, 8♣]
player3:
[4♦, 2♠, J♠, 2♦, K♣, 3♠, 2♥, 5♠, 10♠, 4♥, Q♦, 5♦, 5♥, 3♥, 4♠, 3♦, 10♣]
底牌:
[8♠, 9♥, 大☠]
*/