面向对象集合

需要：会使用集合存储设局
会遍历集合，把数据取出来
掌握每种集合的特性

List接口（1.有序的集合【存储和取出元素顺序相同】 2.允许存储重复元素 3.有索引可以使用普通的for循环遍历）
set接口 （1.不允许存储重复元素 2.每索引不能使用普通for循环遍历）
Collection接口（定义的所有单列集合中共性的方法 所有单列集合都可以使用共性方法 没有带索引的方法）
集合框架的学习方法：
学习顶层：学习顶层接口/抽象类中的共性方法，所有子类都可以使用
使用底层：底层不是接口就是抽象类，无法创建对象使用，需要用底层子类创建对象使用

Collection集合常用功能（所有单列集合最顶层的接口）
共性方法有七个
public boolean add(E a) 给定的对象添加到当前集合中

Collection<String> coll = new ArrayList<>();
System.out.println(coll);       //空的
boolean b1 = coll.add("张三");   //可以去掉 boolean b1直接coll.add()
System.out.println(coll);      //张三

public boolean remove(E a) 把给定的对象在当前集合中删除

coll.remove("张三");      //本来是[张三, 李四, 王五, 赵六, 田七]
System.out.println(coll);    //用了remove之后变成了[李四, 王五, 赵六, 田七]

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

boolean b2 = coll.contains("李四");
System.out.println(b2);   //true

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

boolean b3 = coll.isEmpty();
System.out.println(b3);

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

int i = coll.size();
System.out.println(i);    //4

public object[] toArray() 把集合中的元素保存到数组

Object[] arr = coll.toArray();         //变成数组
for (int j = 0; j < arr.length; j++) { //遍历数组
    System.out.println(arr[j]);        //打印数组

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

coll.clear();
System.out.println(coll);  //集合还在就是内容清空了

Iterator接口 迭代器（对集合进行遍历）
迭代：即Collection集合元素的通用获取方式，再取元素之前先判断集合中有没有元素，如果有就把这个元素取出来，再继续判断，直到全部取出，这种取出方法专业术语叫迭代
是一个接口无法直接使用，需要使用实现类对象
迭代器使用步骤：
1.使用集合中的方法iterator()，获取迭代器实现类对象，使用Iterator接口接收
2.使用Iteratar接口中的方法hasNext判断还有没有下一个元素
3.使用Iteratar接口中的方法next取出集合中的下一个元素
获取迭代器

Iterator<String> it = coll.iterator(); //多态   接口 = 实现类对象

Iterator接口常用方法如下：
public E next() 返回迭代的下一个元素

String s = it.next();
System.out.println(s);  //姚明

public boolean hasNext() 如果元素可以迭代则返回true

boolean b = it.hasNext();   //判断集合中是否有元素
 System.out.println(b);

发现用迭代器太长，就用循环（一直数量用for 位置数量用while）

while (it.hasNext()){        //条件是it.hasNext
    String s1 = it.next();   //满足条件就取出
    System.out.println(s1);
}

增强for循环（foreach）
专门用于遍历集合和数组 底层使用的也是迭代器，使用for循环的格式简化了迭代器的书写
for（集合/数组的数据类型 变量名：集合名/数组名）{
sout（变量名）;
}

ArrayList<String> arr = new ArrayList<>();
arr.add("长度为");
arr.add("得到");
arr.add("测测");
arr.add("尺寸为");
arr.add("人才网");
for (String i:arr) {
    System.out.println(i);
}

泛型
就是集合中 <> 中的部分·
有使用数据类型的时候都使用泛型 E
定义的时候不写数据类型写泛型，创建对象的时候在定义数据类型
含有泛型的类：

public class Deom<E> {
    private E name;

    public E getName() {
        return name;
    }

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

调用：

public static void main(String[] args) {
   Deom<String> d1 = new Deom<>();
   d1.setName("hcduis");
}

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

public <M> void eat(M m){
    
} 

调用

d1.eat(1);  //传递什么类型泛型就是什么类型  这是int类型
  d1.eat("黑暗时代");  //这是Sering类型

含有泛型的接口
在接口名后面加上

public interface Dopd<Q> {
    public abstract void ert(Q q);   //接口的抽象方法
}

有泛型接口的第一种使用方法：定义接口实现类，实现接口，指定接口的泛型
public final class 类名 implements 接口名<数据类型>{

}

public  class Dopdd implements Dopd<String>{
    @Override
    public void ert(String s) {        
    }
}

有泛型接口的第二种使用方法：接口使用什么泛型，那么接口类就使用什么泛型（相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型）
public class 类名<泛型> implements 接口名<泛型>{ }

public  class Dopdd<Q> implements Dopd<Q>{


    @Override
    public void ert(Q q) {
    }
    Dopd<String> dopd = new Dopdd<>();
}

泛型通配符
泛型的通配符“？”代表任意的数据类型
使用方式： 不能创建对象使用 只能作为方法的参数使用
定义一个方法能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符 ？来接收数据

public  class Dopdd {
    public static void main(String[] args) {
        ArrayList<Integer> arra1 = new ArrayList<>();
        arra1.add(1);
        arra1.add(2);
        arra1.add(3);
        arra1.add(4);
        ArrayList<String> arra2 = new ArrayList<>();
        arra2.add("A");
        arra2.add("B");
        printArray(arra1);
        printArray(arra2);
    }
    public static void printArray(ArrayList<?> list){
        Iterator<?> it = list.iterator(); //使用迭代器
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}

通配符高级使用
泛型的上限
格式：? extends E
意义：只能接收该类型及其子类 代表使用的泛型只能是E类型的子类或者本身
泛型的下限
格式：? super E
意义：只能接收该类型及其父类型 代表使用的泛型只能是E类型的弗雷或者本身