Collection集合
1.数组长度是固定的，集合长度是可以改变的
2.数组存储的是同一类型的元素，可以存储基本数据类型，也可以存储对象，
集合只能存储对象。对象类型可以不一致。
int[] arr = new int[10];
Student [] arr = new Student[3];
ArrayList<Stusent String 等
=========================================================
Collection接口共用方法
java.util.Collection接口
所有单列集合的最顶层，定义了所有单列集合的共性方法
任何单列集合都可以使用Collection接口中的方法
共性方法：
1. public boolean add(E e) 把给定的对象添加到当前集合中
2.public void clear():清空集合中所有的元素
3. public boolean remove(E e): 把给定的对象在当前集合中删除
4.public boolean contains(E e):判断当前集合中是否包含给定的对象
5.public boolean isEmpty():判断当前集合是否为空
6.public int size(): 返回集合中元素的个数
7.public Object[] toArray()：把集合中的元素，存储到数组中
public class Demo {
public static void main(String[] args) {
Collection<String> arr = new ArrayList<>();
System.out.println(arr);//[]
//add方法
arr.add("张三");
arr.add("李四");
arr.add("王五");
System.out.println(arr);//[张三, 李四, 王五]
//remove方法
arr.remove("李四");
System.out.println(arr);//[张三, 王五]
//contations方法
boolean b1 = arr.contains("王五");
System.out.println(b1);//true
//判断是否为空
System.out.println(arr.isEmpty());//false
//打印集合对象个数
System.out.println(arr.size());//2
//集合转化为数组
Object[] all = arr.toArray();
for(int i=0 ; i<all.length;i++){
System.out.println(all[i]);//张三 李四 王五
}
//清空集合中元素，但是集合依然存在
arr.clear();
System.out.println(arr);//[]
}
}
==================================================
Iterator迭代器
Iterator接口（迭代器）
集合不能遍历元素，JDK提供了一个接口java.util.Iterator
Iterator接口也是JAVA集合中的一元。主要用于遍历Collection中的元素（Collection集合中元素的通用获取方式）
因此 Iterator接口也被称为迭代器
原理:在取元素之前判断集合中有没有元素，如果有，就把这个元素取出来，继续判断，如果有在取出来。一直把集合中所有元素取出。
常用两个方法
1. boolean hasNext() 如果仍有元素可以迭代，则返回true
判断集合中还有没有下一个元素，有就返回true
2.E next()返回（取出）迭代的下一个元素。
Iterator是一个接口，我们无法直接使用，需要使用一个Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中有一个方法，叫iterator()，这个方法返回的是迭代器的实现类对象
Iterator<E> integer()返回此Collection的元素上进行迭代的迭代器
使用步骤：
1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
3.使用Iterator接口中的方法next（）取出集合中的下一个元素
====================================================
迭代器的使用
public class Iter {
public static void main(String[] args) {
Collection<String> str = new ArrayList<>();
str.add("孙胜顺");
str.add("何淳登");
str.add("白旭博");
//Iterator接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
Iterator<String> it = str.iterator();//左边接口，右边实现类对象，多态
while(it.hasNext()){
System.out.println(it.next());
/*for(Iterator<String> it2= str.iterator();it2.hasNext();){
System.out.println(it.next());
}*/
}
}
}
============================================
迭代器实现原理
============================================
增强for循环
只能遍历
只能是Collection或者数组
public class For {
public static void main(String[] args) {
demo1();
demo2();
}
public static void demo1() {
int[] arr = {
1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println(i);
}
}
public static void demo2 () {
ArrayList<String> str = new ArrayList<>();
str.add("张三");
str.add("李四");
str.add("王五");
for(String h : str){
System.out.println(h);
}
}
}
=============================================================
泛型
一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
也可以看成是一个变量，用来接收数据类型
E e :Element元素
T t ：Type类型
ArrayList集合在定义的时候，不知道集合中都会储存什么类型的数据，所以类型使用泛型
public class Fanxing {
public static void main(String[] args) {
demo1();//不使用泛型
demo2();//使用泛型
}
//创建集合对象，使用泛型
//好处：1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
// 2.把运行期异常（代码运行之后抛出的异常），提升到了编译期异常
//弊端：泛型是什么类型，就只能存储什么类型数据
public static void demo2(){
ArrayList<String> list = new ArrayList<>();
list.add("王老五");
//list.add(1);
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s.length());
}
}
//创建集合对象，不使用泛型，
//好处：集合不适用泛型，默认类型就是Object类型，可以存储任意类型数据
//弊端：不安全，会引发异常
public static void demo1(){
ArrayList In = new ArrayList();
In.add("张三");
In.add(3);
Iterator It = In.iterator();
while(It.hasNext()){
Object obj = It.next();
System.out.println(obj);//张三 3
//查看字符串长度，向下转型，转成字符串类型，但是Integer类型转换为String类型
//抛出异常
String s = (String)obj;
System.out.println(s.length());
}
}
}
===========================================
定义和使用一个含有泛型的类
泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
泛型可以是任意数据类型，可以使用Integer，String,Student…
创建对象的时候确定泛型的数据类型
Gener gen = new Gener();
public class Gener<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
public class Demo {
public static void main(String[] args) {
Gener<Integer> gen = new Gener<Integer>();
gen.setName(1);
Integer obj = gen.getName();
System.out.println(obj);
Gener<String> gen1 = new Gener<>();
gen1.setName("刘邦");
String s = gen1.getName();
System.out.println(s);
}
}
===========================================
含有泛型的方法
public class Cals {
public <E> void meth( E m){
System.out.println(m);
}
public static <E> void meth1(E m){
System.out.println(m);
}
}
public class Dem {
public static void main(String[] args) {
Cals ca = new Cals();
//调用含有泛型的方法
ca.meth(1);
ca.meth("燕双鹰");
ca.meth(true);
ca.meth1("静态方法，不建议这种使用");
Cals.meth1("静态方法，建议直接使用");
}
}
===================================================
含有泛型的接口
//定义含有泛型的接口
public interface Cal<I> {
public abstract void meth(I i);
}
/*
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
public interface Iterator<E{
E next();
}
例子：Scanner类中实现了Iterator接口，并指定接口的泛型为String。所以重写next方法泛型
默认是String
public final class Scanner implements Iterator<String{
public String next(){}
}
*/
public class CalImpl implements Cal<String>{
@Override
public void meth(String s) {
System.out.println(s);
}
/*含有泛型的接口的第二种使用方法：接口使用什么泛型，实现类就使用什么泛型,类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
例子
public interface List<E>{
boolean add(E e);
E get(int index);
}
public class ArrayList<E> implement List<E>{
public boolean add (E e){
}
public E get(int index){
}
}
*/
public class CalImpl1<I> implements Cal<I> {
@Override
public void meth(I i) {
System.out.println(i);
}
}
public class Dem {
public static void main(String[] args) {
CalImpl cal = new CalImpl();
cal.meth("字符串");
CalImpl1<String> c = new CalImpl1<>();
c.meth("第二种");
CalImpl1<Integer> c1 = new CalImpl1<>();
c1.meth(2);
}
}
==============================================
泛型通配符
？：代表任意数据类型
使用方法：不能创建对象使用
只能作为方法的参数使用
public class Tpf {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(2);
ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("b");
// ArrayList<?> list03 = new ArrayList<?>();
// 错误，不能创建对象时使用。只能作为方法的参数使用
Printrray(list01);
Printrray(list02);
}
//定义一个方法，遍历所有类型的ArrayList集合
//这时候我们不知道ArrayList集合是什么数据类型，可以用泛型通配符来接收数据
public static void Printrray(ArrayList<?> list) {
Iterator<?> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());//Object i = it.next();
}
}
}
======================================================
斗地主案例
public class Pocker {
public static void main(String[] args) {
//1.准备牌
ArrayList <String> pock = new ArrayList<>();
String[] clos = {
"红桃","黑桃","梅花","方片"};
String[] nums = {
"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
pock.add("大王");
pock.add("小王");
for(String col:clos){
for(String num:nums){
pock.add(col+num);
}
}
//2.洗牌
Collections.shuffle(pock);
//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<pock.size();i++){
String p = pock.get(i);
if(i>=51){
dipai.add(p);
}
else if(i%3==0){
player1.add(p);
}
else if(i%3==1){
player2.add(p);
}
else if(i%3==2){
player3.add(p);
}
}
//4.查看牌
System.out.println("刘德华："+player1);
System.out.println("周润发："+player2);
System.out.println("周星驰："+player3);
System.out.println("底牌："+dipai);
}
}
================================================