集合的笼统介绍之Collection

作为处于容器最高层级的collection接口，它与下面的集合都处于和父子关系，如ArrayList是继承的抽象方法，抽象方法之上是list接口，它们之间的继承关系如下图。

其中，list是有序接口，set是无序接口。

如同所有的集合一样，作为顶层接口的collection也具有①创建方式②集合方法③遍历。

方式1：Collection<元素类型> 变量名 = new ArrayList<元素类型>();
方式2：Collection 变量名 = new ArrayList();

用案例来描述一下。①创建对象

package com.oracle.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//集合的接口
public class Demo03 {
    public static void main(String[] args) {
        //向上转型 父类对象 变量名=new 子类对象（）；
        Collection<String> col=new ArrayList<String>();
        col.add("你好");
        col.add("敖丙");
        col.add("龙王");
        col.add("李靖");

ps：集合所有的创建方式都是根据多态进行的。这里的意思就是一个一个string类型的collection接口指向new ArrayList，也就是一个string类型的ArrayList集合。

②常用方法

根据java面向对象的思想，我们知道ArrayList集合是实现了list接口，list又是继承了collection接口。那么，collection也有常用方法。如：

public class Jihe {
    public static void main(String[] args) {
        //因为它是接口，所以不能new对象，只能多态新建一个子类对象
        Collection<Integer> col =new ArrayList<Integer>();
        //添加元素add
        col.add(123);
        col.add(456);
        col.add(789);
        //删除元素
        col.remove(456);
        //清空集合
    //    col.clear();
        //向下转型,因为set和list接口不全都是有序的，所以这个下标不是公共的，需要调取list的独有方法
        if(col instanceof ArrayList){
        ArrayList<Integer> list=(ArrayList<Integer>)col;
        //无法便利的原因是collection接口中缺少get方法
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
            }
        }
其中collection可以向下转型，如
collection col=new Arraylist（）；//因为如果不声明类型的话直接提升到object类型

　　coll.add("abc");

　　coll.add("aabbcc");

　　coll.add("cat");

Iterator it=col.iterator（）；//有两种方式可以向下转型，一种是直接声明类型，Iterator <string> it=col.iterator（）；

while（it.hasnext）{

//第二种：多态向下转型。

String str = (String) it.next();

}
        //判断集合中是否包含某个元素
        boolean flag=col.contains(999);
        System.out.println(flag);
        //将集合转为数组,object可以直接转inteager，integer不能直接转object，数组没有继承关系
        Object [] arr=col.toArray();
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
            }
        }

③遍历。

从collection常用方法中，我们发现他没有可以用来提取元素的方法。这也是collection下的特性，这里有两个方法。

1.迭代器 Iterator

Iterator迭代器是一个抽象接口，它是collection为了可以遍历数组而实现的接口，继承了里面的方法，如

而根据方法重写的特性重写了Iterator方法。

它的流程图解是

也就是说，hasnext是判断集合中是否有元素，next是执行一次走一次，直到走到集合里面没有元素为止，划重点，hasnext会有一个初始值如上图的程序员，所以我们遍历的时候最好用数值接一下，以防next走两遍出现空值异常。

它的书写流程如下：

public static void main(String[] args) {
        //person类的collection接口
        Collection<Person> col =new ArrayList<Person>();
        col.add(new Person("司南",22));
        col.add(new Person("周戎",25));
        col.add(new Person("楚慈",27));
        //获取迭代器 这里需要注意的是迭代器也是采用的多态关系
        Iterator<Person> it=col.iterator();
        //
        while(it.hasNext()){
            //引用数据类型返回的是字符串
            System.out.println(it.next());
        }
    }

2.增强for

与普通for不同，它只适应于collection的集合和数组之中。它不能增删修改元素。数组可以用普通for的下标进行操作。

创建对象：可以基本数据类型也可以自定义数据类型

for(元素的数据类型变量 : Collection集合or数组){

}

public static void main(String[] args) {
        //容器
        Collection<Person>col1=new ArrayList();
        col1.add(new Person("敖丙",18));
        col1.add(new Person("哪吒",18));
        col1.add(new Person("李靖",30));
        //增强for循环
        for(Person p:col1){
            System.out.println(p);
        }

泛型。泛型的作用是声明集合整个是什么类型，用<>括起来。总共有三种应用场景。

第一种：定义泛型的类。

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

第二种：定义泛型的接口

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

<E>e表示的是万能泛型，也就是传入什么泛型都可以，传入String就是字符串类型

泛型的好处：

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

泛型通配符

因为泛型是为了定义类型，也就是说最开始就直接限定死，但是如果我们想打印操作别的数据类型怎么办呢？

当然是用<?>

package com.oracle.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo07 {
    public static void main(String[] args) {
        Collection<Person> col=new ArrayList<Person>();
        col.add(new Person("司南",18));
        col.add(new Person("二少",19));
        Collection<Student> col2=new ArrayList<Student>();
        col2.add(new Student("军爷","啦啦"));
        col2.add(new Student("秀秀","lalall"));
        //调用同一个方法，编辑集合
        get(col);
        get(col2);    
    }
    //给get方法传参，传递一个collection不知道啥类的变量，这里意味上面穿什么类型的参数都可以。
    public static void get(Collection<?> col){
        //获取迭代器
        Iterator<?> it=col.iterator();
        //判断下个是否有元素
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

但是问题接踵而至，如果我们不是相对集合进行全部的类型操作，只想操作其中的一部分，就要用到集合限定，集合的上限和下限。

上限比较好理解，也就是上限 <? extends 集合类型>所有及以上，如<? extends object>所有的object

下限 <? super 集合类型>也就是最少是当前类型及其以上<? extends string>最少是string，也可以是object

首先定义两个类emp顾客类

//顾客类
public class Emp {
    public void work(){
        System.out.println("员工工作");
    }

}
//服务员类
public class Waiter extends Emp {
    public void work(){
        //都有一个默认的无参构造
        System.out.println("服务员工作");
    }
//厨师类
public class Cook extends Emp{
    public void work(){
        System.out.println("厨师炒菜");
    }

package com.oracle.demo3;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Collection <Cook>col1=new ArrayList<Cook>();
        col1.add(new Cook());
        Collection <Waiter>col2=new ArrayList<Waiter>();
        col2.add(new Waiter());
        //掉一个方法遍历集合
        get(col1);
        get(col2);
        Collection <Scanner>col3=new ArrayList<Scanner>();
        //get(col3);Scanner不是emp的子类，所有不对
    }
    //定义一个方法
    //泛型的上限
    //泛型的下限
    //<? super Emp>,确定最少是emp，其他的可以是父类
    public static void get(Collection<? extends Emp> col){
        Iterator<?> id=col.iterator();
        while(id.hasNext()){
            System.out.println(id.next());
        }
    }//得出厨师炒菜，服务员服务
}