Collection接口及其子类接口

定义

collection接口：
定义的是所有单列集合中共性的方法
所有的单列集合都可以使用共性的方法
没有带索引的方法

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

Set接口
1.不允许存储重复的元素
2.没有索引（不能使用普通的for循环遍历）
TreeSet集合 （无序的集合（存储和取出元素的顺序有可能不一致））
HashSet集合 <- LinkedHashSet集合（有序的集合）

Collection是所有单列集合的最顶层接口，任何单列集合都可以使用中的方法。
例：

public class Demo01Collection {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("hello");
        coll.add("world");
        coll.add("ni");
        System.out.println(coll);
    }
}

迭代器

使用步骤
1：使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
2：使用Iterator接口中的方法hasNext判断还有没有下一个元素
3：使用Iterator接口中的方法next去除集合中的下一个元素

迭代器的泛型跟集合一样

public class Iterator01 {
    public static void main(String[] args) {
        Collection<Integer> coll1 = new ArrayList<>();
        coll1.add(1);
        coll1.add(2);
        coll1.add(3);
        coll1.add(5);
        coll1.add(7);
        //迭代器的泛型跟着集合走
        Iterator<Integer> it = coll1.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-------------");
        for(Iterator<Integer> it1 = coll1.iterator();it1.hasNext();){
            System.out.println(it1.next());
        }
    }
}

增强for循环

增强for循环，底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写。

Collection<E> extends Iterable<E>：所有的单列集合都可以使用增强for循环
public interface Iterable<T>实现这个接口允许对象成为“foreach”语句的目标
格式：for(集合/数组的数据类型 变量名： 集合名/数组名）{
       sout(变量名)
 }

public class Foreach {
    public static void main(String[] args) {
        int[] i1 = new int[]{1,2,3,4,1,22,3};
        Collection<String> colle = new ArrayList<>();
        colle.add("nimen");
        colle.add("hai");
        colle.add("hao");
        colle.add("ma");
        for(String coll : colle){
            System.out.println(coll);
        }
        for(int i : i1){
            System.out.println(i);
        }
    }
}

泛型

接口的泛型

创建集合对象，不使用泛型
好处：
集合不使用泛型，默认就是Object类型，可以存储任意类型的数据

创建对象使用泛型
好处：
避免了类型转换的麻烦，存储是什么类型，取出就是什么类型

public class FanXing {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("sss");
        list.add(123);
        list.add("asdasd");
        list.add(111);
        Iterator list1 = list.iterator();
        while (list1.hasNext()){
            //取出元素也是Object类型
            Object o1 = list1.next();
            System.out.println(o1);
            System.out.println(list1.next());
            //要想使用String类特有的方法，length获取字符串的长度，不能使用  多态 Object obj = “sss”。
            //需要向下转型,会报错，不能将Integer类型转换为String类型
            /*String s = (String)o1;
            System.out.println(s.length());*/
        }
    }
}

泛型类

定义一个含有泛型的类，泛型是个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型。
泛型可以接受任意的数据类型，创建对象的时候确定泛型的数据类型

public class GenericClass<E>{
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

测试它

public class TestGenericClass {
    public static void main(String[] args) {
        GenericClass genericClass = new GenericClass();
        genericClass.setName("只能传递字符串");
        //不写泛型默认为Object类型
        Object s =genericClass.getName();//返回也只能是字符串

        GenericClass<Integer> genericClass1 = new GenericClass<>();
        genericClass1.setName(1);
        Integer i1 = genericClass1.getName();
        System.out.println(i1);
    }
}

泛型方法

定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

格式：
修饰符 <泛型> 返回值类型 方法名（参数列表（使用泛型））{
    方法体；
}

含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型

public class GenericMethod<I extends Number> {

    public <E> void method01(E e){
        System.out.println(e);
    }
    //定义含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

public class TestGeneticMethod {
    public static void main(String[] args) {
        GenericMethod<Number> gm = new GenericMethod<Number>();
        /*调用含有泛型的方法
        * 传递什么类型，泛型就是什么类型*/
        gm.method01("woaini");
        gm.method01(1);
        gm.method01(true);
        gm.method01(8.2);
        //静态方法最好通过类名.方法名（）使用
        gm.method02("静态方法不建议创建对象调用");
        GenericMethod.method02(111);
    }
}

泛型接口

定义含有泛型的接口第一种使用方式： 定义接口的实现类，实现接口，指定接口的泛型

public interface GenericInterface<I> {
    public abstract void method(I i);
}

接口的实现类

public class ImpGenericInterface implements GenericInterface<Integer>{

    public void method(Integer i){
        System.out.println(i);
    }
}

调用

public class TestImpGenericInterface {
    public static void main(String[] args) {
        ImpGenericInterface impGenericInterface = new ImpGenericInterface();
        impGenericInterface.method(123);
    }
}

含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型

 public interface List<E>{
  	boolean add(E e);
  	E get(int index);
 }

public interface GenericInterface111<I>{
    public void method01(I i );
}

public class ImpGenericInterface111<I> implements GenericInterface111<I>{
    @Override
    public void method01(I i){
        System.out.println(i);
    }
}

在创建类的时候就定义泛型的类型，方法

public class TestImpGenericInterface111 {
    public static void main(String[] args) {
        ImpGenericInterface111<Integer> integerImpGenericInterface111 = new ImpGenericInterface111<>();
        integerImpGenericInterface111.method01(111);
    }
}

泛型的通配符

不知道使用什么类型来接收的时候，此时可以使用？ ， ？表示未知通配符
但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合元素自身方法无法使用。
使用方式：
不能创建对象使用
只能作为方法的参数使用

public class GenericCom {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("sss");
        list02.add("wewe");
        print(list01);
        print(list02);
    }
    /*定义一个方法，能够遍历所有类型的ArrayList集合
    * 这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符？来接收数据类型*/

    public static void print(ArrayList<?> list){
        /*for(int i = 0 ;i<=list.size()-1;i++){
            System.out.println(list.get(i));
        }*/
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            //取出的元素为Object类型
            //Object obj = iterator.next();
            System.out.println(iterator.next());
        }
    }
}

泛型的上线限定： ？ extends E 代表使用的泛型只能是E类型的子类或者是他本身
泛型的下限限定： ？ super E 代表使用的泛型只能是E类型的父类/或者是本身

public class GenericUpLow {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();

        getE1(list1);
        //getE1(list2);
        getE1(list3);
        //getE1(list4);

        //getE2(list1);
        //getE2(list2);
        getE2(list3);
        getE2(list4);
        /*
        类与类之间的继承关系
        Interger extends Number Extends Object
        String extends Object
        */
    }
    public static void getE1(Collection<? extends Number> coll){

    }
    public static void getE2(Collection<? super Number> coll){}
}