Day02 Collection集合、迭代器、泛型、斗地主案例

Day 02

第一章 Collection集合

1.1集合概述

​ 集合是java提供的一种容器，它与数组的区别是，数组一旦创建，它的长度是固定的，而集合可以随着需要扩容。

​ 数组储存的元素是同一类型的，这在创建的时候就已经确定了，而集合可以存储不同类型的数据，如：

...{...
    Collection list = new ArrayList();
list.add(555);
list.add("abc");
list.add(true);
}

1.2集合框架

​ 集合的框架如图所示：

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

Collection是集合的根接口，其下又有Set与List两个子接口。Set的特点是元素无序且不可重复，List的特点是元素有序而且可以重复。

常用功能

• 增public boolean add(E e);
• 删public boolean remove(E e);
• 清空public void clear();
• 判断是否含有某个元素public boolean contains(E e);
• 判断是否空集合public boolean isEmpty();
• 转换为数组public Object[] toArray();
• 查询个数public int size();

...
Collection<String> coll = new ArrayList<String>();
		coll.add("5");
		coll.add("6");
		System.out.println(coll);
		System.out.println(coll.contains(5));
		System.out.println(coll.isEmpty()+" "+coll.size());
		
		Object [] a=coll.toArray();
		for(int i = 0 ; i <a.length;i++) {
			System.out.println(a[i]);
		}
		System.out.println(coll.remove("5"));
		coll.clear();
		System.out.println(coll);
...

第二章 Iterator迭代器

2.1 Iterator接口

生成方式：

Collection<String> list = new ArrayList<String>();
Iterator it = list.iterator();

迭代器常用于集合元素的遍历，常用方法有：

• public E next();
• public booelan hasNext();

在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

2.2 简述迭代器的原理

生成一个迭代器时，其内部采用指针方式标记集合中的元素。

调用之前，迭代器的索引位于第一个之前，每调用一次，迭代器索引向后移动一位。以此类推，直至hasNext()方法返回负值。

for-each循环

for-each循环又称为增强for循环:用于遍历数组与集合

int [] a = {1,2,3,4,5,6};
for(int c : a){
    System.out.print(c+" ");
}//1 2 3 4 5 6

格式：

for(元素对应的数据类型 元素变量 ： 欲遍历的数组对象){
	//方法块
}

它的内部原理其实是个Iterator迭代器

第三章 泛型

3.1泛型概述

泛型的目的：在类以及方法等中预先使用未知的类型

Collection s = new ArrayList();
/*采用这种方法构造集合时，s中可以放入任何一种元素，此时没有指定泛型，因为此时默认Collection的类型是Object类（所有类型的父类)
这种方法的缺点是，要取出元素给对应类型的变量时，要向下造型，运行容易报java.lang.ClassCastExcption的错误，如果采用泛型，可以在编译过程发现错误*/

3.2 使用泛型的好处

• 运行时期的错误可以在编译的时候就发现
• 避免了类型强转

3.3泛型的定义与使用

• 定义类时使用泛型

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

  class Text<T>{...}

  • 在创建对象时确定泛型Text<String> test=new Text<String>();

• 定义方法时使用泛型

  格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

  public <T> T function(T t){};

  • 在调用方法时确定泛型

    String s = "dsa";
    ...//生成一个包含上面function函数的类的变量test
    test.function(s);//调用时确定泛型为String类
    

• 定义接口时使用泛型

  格式：修饰符 interface接口名<代表泛型的变量> { }

  interface Text<T>

  • 建立类的时候确定泛型

    class Text1 implements Text<String>{}

  • 建立类的时候仍旧保持泛型，在建立对象的时候再确定

    interface Text<T>{}
    class Text1<T> implements Text<T>{}/*此时类后代表泛型的字母必须与接口后的字母保持一致*/
    ...
        Text1<String> t1 = new Text1<String>();
    

3.4泛型通配符

通配符的常用方式:使用泛型类或者接口，传递数据时，泛型的类型还不能确定，可以通过通配符<?>表示。

一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用,此时只能接受数据,不能往该集合中存储数据

Collection<Integer> list1 = new ArrayList<Integer>();
...
    public static void get(Collection<?> coll)
    //? 代表可以接收任意对象

3.5受限泛型

• function(<? extends T>):只能接收T及其子类
• function(<? super T>):只能接收T及其父类

斗地主案例

按照斗地主的规则，完成洗牌发牌的动作。
具体规则：

使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

package Day02;
import java.util.ArrayList;
import java.util.Collections;
public class Day02 {

	public static void main(String[] args) {
		ArrayList<String> card = new ArrayList<String>();
		ArrayList<String> number = new ArrayList<String>();
		ArrayList<String> flower = new ArrayList<String>();
		String[] str1 = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
		String[] str2 = {"❤","◇","♠","♣"};
		ArrayList<String> undercard = new ArrayList<String>();
		for(String e:str1) {
			number.add(e);
		}
		for(String e:str2) {
			flower.add(e);
		}
		for(int i = 0 ; i<flower.size();i++) {
			String tem =flower.get(i);
			for(int j =0;j<number.size();j++) {
				card.add(tem+number.get(j)+" ");
			}
		}
		card.add("大王");
		card.add("小王");
		Player p1 = new Player();
		Player p2 =new Player();
		Player p3 = new Player();	
		ArrayList<Player> pp = new ArrayList<Player>();
		pp.add(p1);
		pp.add(p2);
		pp.add(p3);
		Collections.shuffle(card);
		for(int i =0;i<=50;i++) {
			pp.get(i%3).getCard(card);
		}
		for(int i = 0; i <3;i++) {
			undercard.add(card.remove(0));
		}
		p1.showCard();
		p2.showCard();
		p3.showCard();
		System.out.println(undercard.toString());	
	}
}
class Player{
	private ArrayList<String> cards=new ArrayList<String>();
	
	public void getCard(ArrayList<String> ss) {
		cards.add(ss.remove(0));
	}
	public void showCard() {
		System.out.println(cards.toString());
	}
}//[◇K , ◇Q , ❤J , ◇9 , ♣7 , ◇8 , ❤3 , ♠10 , ♣10 , ❤6 , ♠7 , ♠4 , ♣3 , ◇5 , ◇J , ❤5 , 小王]
[♣2 , ❤10 , ♠3 , ❤7 , ♣8 , ♣5 , ♠9 , ❤Q , ♣4 , ◇7 , ♠8 , ♠Q , ◇10 , ❤A , ❤9 , ❤K , ♠2 ]
[大王, ♠6 , ♠5 , ♠A , ♣K , ❤4 , ◇3 , ◇4 , ♠J , ♣A , ♣9 , ♣J , ◇6 , ♣6 , ♣Q , ❤8 , ◇A ]
[♠K , ❤2 , ◇2 ]