Collection集合和泛型

Collection集合

1.集合的定义：集合是java中提供的一种可变容器，可以用来存储多个数据。
2.集合框架的介绍：

3.集合常用功能：
public boolean add(E e):把给定的对象添加到当前集合

		Collection<String> coll = new HashSet<>();
        coll.add("张三");
        coll.add("赵四");
        coll.add("赵六");

public void clear():清空集合中的所有元素

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

public boolean remove(E e):把给定的元素从当前集合删掉

		boolean b3 = coll.remove("李四");
 		 System.out.println(b3);

public boolean contain(E e):判断当前集合中是否包含给定的对象

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

public boolean isEmpty():判断当前集合是否为空

		 System.out.println(coll.isEmpty());

public int size():返回集合元素的个数

		 System.out.println(coll.size());

public Object[] toArray():把集合的元素，存储到数组中

 		 Object[] arr= coll.toArray();
         for(int i=0;i<arr.length;i++)
         System.out.println(arr[i]);

4.Iterator接口的介绍
迭代器使用的两个步骤：
1.使用集合的方法iterator()获取迭代器的实现对象，使用Iterator接受多态
2.使用Iterator接口的方法hasNext判断是否有下一个元素
3.使用Iterator接口的方法next取出集合的元素，并将指针后移

		Collection<String> coll=new ArrayList<>();    
 		coll.add("姚明");
        coll.add("科比");
        coll.add("詹姆斯");
        coll.add("欧文");
        coll.add("杜兰特");
        Iterator<String> it=coll.iterator();  //获取迭代的实现对象，并且会把指针(索引)指向-1索引
         while (it.hasNext()) {                  //判断集合中还有没有下一个元素
         System.out.println(it.next());		//1.取出下一个元素 2.会把指针后移一位
         }

5.增强for循环：用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名称：集合名/数组名）{
sout(变量名)；
}

		int [] ary={1,2,3,4,5};
        for (int i : ary) {                            //增强for循环
            System.out.println(i);
        }

泛型

1.泛型的概念：

2.使用泛型的好处
创建对象，使用泛型的好处：
1.避免了类型转换的妈烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常(代码运行后抛出的异常),提升到了编译器(写代码）
弊端：
泛型是什么类型，只能存储什么类型的数据。

		ArrayList<String> list=new ArrayList<>();       //使用泛型创建ArrayList对象
        list.add("abc");                                           
        Iterator it=list.iterator();                           //使用迭代进行输出
         while(it.hasNext()){
            	Object obj=it.next();
        }

3.定义和使用含有泛型的类
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个位置的数据类型，不确定是什么数据类型时，可以使用泛型
泛型可以接受任意数据类型
创建对象的时候确定数据类型

public class Generic<E> {              //定义一个泛型
    	private E name;
    	public E getName() {
        return name;
    }
    	public void setName(E name) {
        this.name = name;
    }
}

		Generic gc=new Generic();       //不写泛型，默认为Object类型
        gc.setName("abc");

 		Generic<Integer> gc2=new Generic<>();     //使用Integer类型
        gc2.setName(1);
        System.out.println(gc2.getName());

		Generic<String> gc3=new Generic<>();              //使用String类型
        gc3.setName("abc");
        System.out.println(gc3.getName());

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

	public class GenericMethod {
    public <M> void method01(M m) {             //创建泛型成员方法
        System.out.println(m);
    }
    public static <E> void method02(E e) {
        System.out.println(e);
    }
}

 GenericMethod gm=new GenericMethod();       //创建对象
        gm.method01(1);                                         //传递什么类型的泛型参数，泛型就是什么类型
        gm.method01("abc");
        gm.method01(8.8);
        GenericMethod.method02("fasd");

5.定义和使用含有泛型的接口
含有泛型接口的两种使用方法：
1.定义接口的实现类，实现接口，指定接口的泛型
2.接口是什么泛型，实现类就是用什么泛型，类跟着走

public interface GenerisInterface<I> {      //定义含有接口的泛型
    public abstract void method(I i);
}

public class GenericInterfaceImpli implements GenerisInterface<String> {   //对接口进行覆盖重写
    @Override                                          //定义接口的实现类，实现接口，指定接口的泛型
    public void method(String s) {
        System.out.println(s);
    }
}
		GenericInterfaceImpli gl1=new GenericInterfaceImpli();          //实现类已经指定泛型，直接使用
        gl1.method("abc");
public class GenericInterfaceImpl2<I> implements GenerisInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}
GenericInterfaceImpl2<Integer> gl2=new GenericInterfaceImpl2<>();     //实现类没有指定，创建时进行指定泛型，再使用
        gl2.method(10);

6.泛型的通配符
泛型的通配符：不知道使用什么类型来接受时，可以收用？表示未知通配符
使用方式：
不能创建对象使用
只能 作为参数使用

public static void main(String[] args) {
        ArrayList<Integer>  list01=new ArrayList<>();       //创建Integer类型集合
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02=new ArrayList<>();           //创建String类型集合
        list02.add("a");
        list02.add("b");
        printArray(list01);
        printArray(list02);
    }
   public static void printArray(ArrayList<?> list){           //使用泛型通配符进行使用
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    } 

斗地主

public static void main(String[] args) {
//准备牌
        ArrayList<String> poker=new ArrayList<>();     //泛型是String类型
        String[] colors={"♥","♠","♣","♦"};          //定义两个数组，一个数组存储牌的花色，一个数组存储牌的序号
        String[] numbers={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        poker.add("大王");
        poker.add("小王");
        for (String number : numbers) {    //循环嵌套
            for (String color : colors) {
                poker.add(color+number);
            }
        }
// 洗牌
		Collections.shuffle(poker);              //使用shuffle方法对集合进行打乱
//发牌
		ArrayList<String> player01=new ArrayList<>();
        ArrayList<String> player02=new ArrayList<>();
        ArrayList<String> player03=new ArrayList<>();
        ArrayList<String> dipai=new ArrayList<>(); 
        for (int i = 0; i < poker.size(); i++)
            {
                String p=poker.get(i);
                if(i>=51)
                {
                    dipai.add(p);
                }
                else if(i%3==0)
                {
                    player01.add(p);
                }
                else if(i%3==1)
                {
                    player02.add(p);
                }
                else if(i%3==2)
                {
                    player03.add(p);
                }
            }
//看牌
			 System.out.println("刘德华的牌"+player01);
            System.out.println("周润发的牌"+player02);
            System.out.println("周星驰的牌"+player03);
            System.out.println("底牌"+dipai);