Java学习3----Collection、迭代器、泛型、斗地主案例分析

1.Collection集合

集合ArrayList，是Java中提供的一种容器，可以用来存储多个数据。集合有很多种，除了ArrayList，还有Vector、LinkedList、TreeSet、HashSet、LinkedHashSet集合。

特点：
ArrayList:底层是数组实现的，查询快，增删慢；
LinkedList:底层是链表实现的，查询慢、增删快；
HashSet:底层是哈希表+红黑树实现的，无索引、不可重复存储元素、存取无序；

数组和集合区别：
1.数组长度固定，集合长度可变；
2.数组存储同一类型元素，可存储基本数据类型；集合存储的是对象，对象类型可以不一致，且不可存储基本数据类型。

1.1集合框架

List接口：
1.有序的集合（存储和取出元素顺序相同）；
2.允许存储重复的元素；
3.有索引，可以使用普遍的for循环遍历；
4.List接口子类包括：Vector、ArrayList、LinkedList

Set接口：
1.不允许存储重复元素；
2.没有索引（不能使用普通的for循环）
3.Set接口子类包括：TreeSet集合、HashSet（其子类又有LinkedHashSet集合；
4.TreeSet、HashSet是无序，存储和取出可能顺序不一致。LinkedHashSet是有序的。

List和Set是有共性的，所以可以向上抽取，形成Collection接口。

Collection接口：
1.定义所有单列集合中共性的方法；
2.是没有带索引的方法；
3.java.util.Collection，所有单列集合最顶层接口；

因此，集合框架的学习方式是：
1.学习顶层：学习顶层接口、抽象类中共性的方法，所有子类都可以使用的；
2.使用底层：底层不是接口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用。

1.2Collection常用功能

1.public boolean add(E e)；
2.public void clear(E e);//清空元素，不删集合
3.public boolean remove(E e);
4.public boolean contains(E e);//判断当前集合中是否包含给定的对象；
5.public boolean isEmpty();//判断当前集合是否为空
6.public int size();
7.public Object[] toArray(): 把集合中的元素，存储到数组中

//注：创建集合，可以使用多态
Collection<String> coll = new ArrayList<>();

2. Interator迭代器

Iterator主要用于迭代访问（遍历）Collection中的元素。对于没有索引的集合，是比较有用的。

java.util.Iterator

2.1常用方法

boolean hasNext() 如果仍然有元素可以迭代，则放回true；
E next() 返回迭代的下一个元素；

Iterator迭代器是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊。Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象，Iterator iterator() 返回在此collection的元素上进行迭代的迭代器。

迭代器的使用步骤：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）；
2.Iterator接口中的方法hasNext()判断是否有下一元素；
3.使用Iterator接口中的方法next取出集合中的下一元素；

public class Demo {
	public static void main（String[] args) {
		Collection<String> coll = new ArrayList<>();
		coll.add("y");
		coll.add("ww");
		//迭代器Iterator<E>接口是有泛型的，迭代器的泛型跟着集合走，集合什么泛型，迭代器什么泛型。
		//多态 			接口 				实现类对象
		Iterator<String> it = coll.iterator();
		boolean b = it.hasNext();
		String s = it.next();
		//也可循环遍历while
	}
}

2.2原理

collection.iterator();//
1.是为了获取迭代器的实现类对象，并且把指针（索引）志向集合的-1索引。
2.判断集合中还有没有下一元素；
3.取出下一元素，然后指针向后移动一位；

2.3增强for

高级for循环，专门用来遍历数组和集合，内部用的是Iterator迭代器，所以在遍历过程中，不能对集合进行增删改查。
Collection extends Iterable:所有的单列集合都可。

格式：

/*
for(元素数据类型		变量	：Collection集合or数组) {
	//操作代码
}
*/
int[] arr = {1,2,3,4};
for(int i:arr){
	System.out.println(i);
}

建议遍历的话，都是用增强for循环。
（注意：增强for必须有被遍历的目标，目标中能是Colletion或者是数组，且仅为遍历操作。）

3.泛型

泛型是一个未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。泛型可以看成一个变量，用来接收数据类型。
E e:Elemnet 元素
T t:Type 类型
ArrayList集合在定义的时候，不知到集合中会存储什么类型的数据类型，所以类型使用泛型。E:未知的数据类型。

public class ArrayList<E> {
	public boolean add(E e){}
	public E get(int index) {}
}
//创建集合对象的时候，就会确定泛型的数据类型
public class ArrayList<String> {
	public boolean add(String e) {}
	public String get(Int index) {}

3.1泛型的优劣

3.1.1不适用泛型
好处：集合不适用泛型，默认的类型就是Object，可以存储任意类型的数据。
弊端：不安全，会引发异常。
不适用泛型，例如：

	ArrayList list = new ArrayList();
	list.add("abd“);
	list.add(1);
	Iterator it = list.iterator();
	while(it.hasNext()){
		Object obj = it.next();
		System.out.println(obj);
		//想要使用String特有方法，length获取长度，但不能使用，因为多态，不能使用子类特有方法。因此需要向下转型
		//String s = (String)obj;//会抛出异常，为Integer类型不能转换为String类型。即1不能转为"1"。
	}

3.1.2使用泛型
好处：
1.避免了类型转换的麻烦，存储时什么类型数据，取出就是什么类型数据；
2.把运行期的异常（代码运行之后会抛出的异常），提升到了编译期（写代码时候会报错）。
弊端：
泛型是什么类型，只能存储什么类型数据。

ArrayList<String> list = new ArrayList<>();
list.add("abs");
//list.add(1);//报错，不能存储整数。

3.2泛型的定义和使用

含有泛型的类

/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型
*/
public class GenericClass<E> {
	private E name;
	public E getName() {
		return name;
	}
	public void setName(E name) {
		this.name = name;
	}
}
public class Demo1{
	public static void main(String[] args) {
		//不写泛型，默认为Object类型
		GenericClass gc = new GenericClass();
		gc.setName("sss");
		Object obj = gc.getName();

		//泛型使用Integer类型
		GenericClass<Integer> gc2 = new GenericClass<>();
		gc2.setName(1);
		Integer name = gc2.getName();
		
		//泛型使用String类型
		GenericClass<String> gc3 = new GenericClass<>();
		gc3.setName("ssd");
		String name1 = gc3.getName();
	}
}

含有泛型的方法

定义含有泛型的方法，泛型定义在方法的修饰符和返回值类型之间。
格式：
修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型)) { 方法体 ；}
含有泛型的方法，在调用方法的时候使用泛型的数据类型，传递什么类型的参数，泛型就是什么类型。

public class GenericMethod {
	public<M> void method1(M m){
		System.out.println(m);
	}
	public static <S> void method2(S s){
		System.out.println(s);
	}
}

public static void main(String[] args) {
	GenericMethod gm = new GenericMethod();
	//含有泛型的方法，传递什么类型，泛型就是什么类型
	gm.method0(10);
	gm.method0("ss");

	//静态方法
	gm.method2("静态方法，不建议创建对象使用");
	GenericMethod.method2("静态方法");
}

含有泛型的接口

含有泛型的接口，第一种方式：定义接口的实现类，实现接口时，要指定接口的泛型
public interface Iterator {
}

例如Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String。
public final Scanner implements Iterator {
public String next() { }
}

public class GenericInterfaceImp1 implements GenericInterface<String> {
		@Override
		public void method(String s) {
			System.out.println(s);
		}
}

public static void main(String[] args) {
	GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
	gi1.method("字符串");

	//创建GenericInterfaceImpl2对象
	GernericInterfaceImpl2 gi2 = new GernericInterfaceImpl2<>();
	gi2.method(10);
	
	GernericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
	gi3.method(8.8);	
}

含有泛型的接口第二种，接口使用什么泛型，实现类就使用什么泛型。相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。
public interface List {
boolean add(E e);
E get(int index);
}
public class ArrayList implements List {
public boolean add(E e) { }
public E get(int index) { }
}

public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
	@Override
	public void method(I i) {
		System.out.println(i);
	}
}

public static void main(String[] args) {
	GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
	gi1.method("字符串");

	//创建GenericInterfaceImpl2对象
	GernericInterfaceImpl2<integer> gi2 = new GernericInterfaceImpl2<>();
	gi2.method(10);
	
	GernericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
	gi3.method(8.8);	
}

public static void main(String[] args) {
//
Generi
}
‘’’

3.3泛型通配符

当使用泛型或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。此时只能接收数据，不能存储。

泛型的通配符：
	？：代表任意的数据类型
使用方式：
	不能创建对象使用；
	只能作为方法的参数使用；
	定义时候不能用?

public class demo {
	public static void main(String[] args) {
		ArrayList<Integer> list01 = new ArrayList();
		list01.add(1);
		list01.add(2);

		Arraylist<String> list02 = new ArrayList<>();
		list02.add("ss");
		list02.add("aa");
	}
/*
	定义一个方法，能遍历所有类型的ArrayList集合
	这时我们不知道ArrayList集合使用什么数据类型，可以使用泛型通配符?来接收数据类型
	注意：泛型没有继承概念，因此？处不能用Object代替
*/
	public static void printArray(ArrayList<?> list) {
		//遍历
		Iterator<?> it = list.Iterator();
		while(it.hasNext()) {
			//it.next()方法，取出的元素时Object，因此Object可以接收任意的数据类型
			Object o = it.next();
			System.out.println(o);
		}
	}
}

3.4 泛型的上限、下限限定

泛型的上限限定：？ extends E
泛型的下限限定：? super E

public static void main(String[] args) {
	Collection<Interger> list1 = new ArrayList<Integer>();
	Colleciton<String> list2 = new ArrayList<String>();
	Collection<Number> list3 = new ArrayList<Number>();
	Collection<Object> list4 = new ArrayList<Object>();
	
	getElement1(list1);
	getElement2(list2);//报错
	getElement3(list3);
	getElement4(list4);//报错
	
}

//泛型的上限：此时的泛型？，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll) { }
//泛型的下限：此时的泛型？，必须是Number类型或者Number类型的父类。
public static void getElement2(Collection<? super Number> coll) { }

应用：斗地主案例分析

1.准备牌54张，存储到一个集合中
特殊牌：大王小王
其他52张牌：
定义一个数组/集合，存储4种花色
定义也给数组/集合，存储13个序号
循环嵌套遍历两个数组/集合，组装52张牌

2.洗牌
使用集合工具类，Collection
static void shuffle(List<?> list) 随机打乱集合元素的顺序

3.发牌
要求：1人17张，剩余3张，一人一张发牌，集合的索引(0-53)%3
定义4个集合，存储3个玩家的牌和底牌。索引大于51时，给底牌发牌。

4.看牌
直接打印集合，遍历存储玩家和底牌集合。