Collection类，泛型

Collection（接口）
所有超级接口：
Iterable<E>
一.集合
　　1.集合的介绍&集合和数组的区别
　　　　什么是集合：java中的一种容器
　　　　什么是数组：java中的一种容器
　　　　区别：
　　　　　　数组的长度是固定的，如果增加长度，只能创建另一个数组
　　　　　　集合的长度是可变的，数据可以理论无限调价，自动扩容
　　　　小区别：
　　　　　　数组的元素必须是同一种类型。例子：int[] nums=new int[10];
　　　　　　集合的元素可以不同类型。例子：ArrayList<Obiect> nums=new ArrayList<Interfger>();
　　2.集合框架的介绍
　　　　在JDK1.1的时候，只有一种集合Vector<泛型>
　　　　在JDK1.5的时候，出现集合框架（一大堆类在一起）
　　　　集合框架顶层接口：Collection<E>
　　　　子接口： List<E> ：列表 　　　　　　　　 Set<E>集 　　　　　　　　 Queue<E>
　　　　　　有序，有下标，可重复 　　　　　　 无序(LinkedHashSet除外)，无下标，不可重复
　　　　实现类：ArrayList,LinkedList,Vector 　　 HashSet 　　 TreeSet
　　　　　　　　数组列表，链式列表， 　　　　 哈希集 　linkedHashSet
　　　　　　　　　　　　　　　　　　　　　　　　　　　　链式哈希集
　　3.collection中的通用方法：
　　　　增：public boolean add（E e）；------E的意思是泛型
　　　　删：public void remove（E e）；
　　　　改：无（需要下标）
　　　　查：无
　　　　其他：
　　　　　　public void clear();//清空，删除集合中的所有元素
　　　　　　public int size();//获取集合的长度（元素个数）
　　　　　　public boolean contains(E e);//判断当前集合中是否包含了给定的对象
　　　　　　public boolean isEmpty();//判断当前集合是否有元素
　　　　　　public Object[] toArray();//转成数组
　　　　注：
　　　　　　集合直接打印为数组。
　　　　　　数组直接打印为地址值
三.集合的通用遍历方式--------迭代器
　　1.集合迭代器的原理：
　　　　仓库管理员（迭代器对象）-----Iterator
　　　　获取迭代器对象:调用集合.iterator()

/*
public static void main(String[] args) {
Collection<String> collection=new ArrayList<String>();
collection.add("a");
collection.add("b");
collection.add("c");
collection.add("d");
//迭代器遍历集合
//1.找到迭代器
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}

// //2.判断是否有下一个元素
// boolean b = iterator.hasNext();
// if (b){
// String next = iterator.next();
// System.out.println(next);
// }
}
*/

　　借助了指针，只有next会让指针动。
　　hasNext只是用来判断
　　注意：
　　　　必须先判断，元素存在，再取出元素
　　2.集合迭代器的介绍和使用
　　　　　所谓的集合迭代器就是用来遍历集合的
　　　标准遍历代码：

Iterator<集合的泛型> iterator=集合.iterator();
while (iterator.hasNext()) {
集合的泛型 next = iterator.next();
System.out.println(next);
}

　　3.增强for循环：
　　　　语法糖：格式的省略版本，但是底层原理不变
　　例子：

int[] nums=new int[]{1,2,3,4,5};
存在栈中	存在堆（new）中
int[] nums={1,2,3,4,5};
迭代器的语法糖：是增强for循环：
格式：
for（数据类型 变量名：数组/集合）{
System.out.println(变量名);
}

　　注意：
　　　　迭代器遍历时，不能在遍历的过程中，对集合的元素进行添加和删除

　　　　报错：

　　　　　　ConcurrentModificationException

　　　　原因：

　　　　　　迭代，在获取时会记录集合的长度（记忆长度）

　　　　　　如果我们在遍历的过程中修改了集合的长度（添加，删除）

　　　　　　这时候迭代器就是比较记忆长度==舞台的实际长度

　　快捷键：
　　　　集合/数组.for 回车
三.泛型
　　1.什么是泛型
　　　　ArrayList<Integer> nums=new ArrayList<Integer>();
　　　　可以消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。
　　泛型：
　　　　一种不确定的类型
　　格式;
　　　　一个泛型：<E>
　　　　两个泛型：<K,V>
　　2.泛型的好处：
　　　　a.不使用泛型（前提想要取相同的类型，进行遍历）
　　　　　　1.需要手动的向下转型
　　　　　　2.编译时不报错，运行时直接崩溃，并出现类型转换异常
　　　　　　Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
　　　　　　例子：

ArrayList arrayList=new ArrayList();
arrayList.add("dad");
arrayList.add(11);
arrayList.add(3.14F);
arrayList.add(true);
for (Object o : arrayList) {
String s =(String) o;
System.out.println(s);
}
}

　　　　运行结果：
　　　　　　dad
　　　　　　Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
　　　　　　　at day02.demo04.main(demo04.java:13)

　　　　　　Process finished with exit code 1
　　　b.使用泛型
　　　　1.不需要手动向下转型
　　　　2.把运行时异常 转译到 编译时报错
　　　　　　JDK1.5之后强烈建议使用泛型。
　　　　3.泛型的定义和使用：
　　　　　　　a.泛型类
　　　　　　　　　　格式：
　　　　　　　　　　　　public class 类名<E>{
　　　　　　　　　　　　既可以使用E:E e
　　　　　　　　　　　　public void setE(E newE){
　　　　　　　　　　　　this.e=new E;
　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　例子：

public class GenericClass <E>{
private E a;

public E getA() {
return a;
}

public void setA(E a) {
this.a = a;
    }
}

　　

　　　　使用：
　　　　　　类名<Interger> 对象名=new 类名<Interger>();
　　2.泛型方法:泛型使用在方法上
　　　　格式：
　　　　　　　public <T> void 方法名（F f）{

　　　　　　}
　　　　例子：
　　　　　　public <String> void Generic(String s){

　　　　　　}
　　　　使用：
　　　　　　对象.方法名（具体的参数）
　　　　　　此时泛型方法中泛型确定了，是我们传入具体参数的类型
　　3.泛型接口
　　　　格式：
　　　　public interface 接口名<E>{
　　　　public abstract void show(E e)
　　　　}
　　　　注意：
　　　　　　public abstract（抽象类中不能省略）
　　　　使用：

a.实现类在实现接口时，直接确定泛型
public class 类名 implements 接口名<String>{
public abstract void show(String e);
}
b.实现类在实现接口时，不确定泛型，而是继续保留
public class 类名 implements 接口名<E>{
public abstract void show(E e);

}
使用实现类创建对象时，再去确认泛型
类名<String> 对象名=new 类名<String>();

　　4.泛型的优点：
　　　　安全简单，在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的
　　　　提高代码的重用率
　　5.泛型的通配符：
　　　　泛型通配符：？
　　　　例子：
　　　　　　当泛型有多种时：

ArrayList<Interger> arr1;
ArrayList<String> arr2;
定义方法。接收这两个集合，需要用到泛型通配符"?"
public static void show（ArrayList<?> arr）{

}

　　6.泛型的上下限：
　　　　上限：<? extends Animal>:表示 必须泛型必须是Animal 或者Animal的子类
　　　　下限：<? super Dog>:表示泛型必须是Dog或者Dog的父类
　　　　否则会报错
　　　　注意：
　　　　　　Number是所有包装类的父类
　　　　　　Integer extends Number extends Obiect
　　　　　　String extends Obiect

四，集合的案例
斗地主
实现步骤：
　　1.产生一副牌（54）
　　2.洗牌（打乱集合元素的顺序）
　　3.发牌（剩余3张，作为底牌）
　　4.看牌（遍历集合）

代码实现：

public static void main(String[] args) {
// 1.产生一副牌（54）
ArrayList<String> cardsBox=new ArrayList<String>();
String [] colars={"♠","♥","♣","♦"};
String [] Licensing={"A","2","3","4","5","6","7","8","9","10","j","Q","K"};
for (String colar : colars) {
for (String s : Licensing) {
cardsBox.add(colar+s);
}
}
cardsBox.add("小s");
cardsBox.add("大s");
System.out.println(cardsBox);
// 2.洗牌（打乱集合元素的顺序）
Collections.shuffle(cardsBox);
// 3.发牌（剩余3张，作为底牌）

ArrayList p1=new ArrayList();
ArrayList p2=new ArrayList();
ArrayList p3=new ArrayList();
ArrayList ps=new ArrayList();

for (int i = 0; i < cardsBox.size(); i++) {
String s = cardsBox.get(i);
if(i>=51){
ps.add(s);
}else {
if (i%3==0){
p1.add(s);
}else if (i%3==1){
p2.add(s);
}else {
p3.add(s);
}
}

}
// 4.看牌（遍历集合）
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(ps);

}

小知识点：
　　Collections（工具类）
方法：
　　public static shuffle(List<?> list)
　　使用默认随机源对指定列表进行置换。