 public static void main(String[] args) {
       Collection collection=new ArrayList();
// Collection是接口，ArrayList()是这个接口的实现类，类重写了Collection的抽象方法
//通过向上转型，collection可以调用Collection的内部方法，但是抽象方法被重写了，构成了多态
       collection.add("ui");
       collection.add(1);
       collection.add("67");
        System.out.println(collection);
    }

e的类型是object类型，可以增加任意类型的元素

boolean addAll（Collection c)---将集合c的所有元素增加到该集合

 public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
       collection.add("67");
        System.out.println(collection);
        collection.addAll(collection);
        System.out.println(collection);
    }

?void clear（）---删除该集合的所有元素

 public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
       collection.add("67");
        System.out.println(collection);
        collection.clear();
        System.out.println(collection);
    }

boolean remove（Object o）---?删除该集合中指定的元素（只删除一次）

  public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
       collection.add("67");
        System.out.println(collection);
        collection.remove(1);
        System.out.println(collection);
    }

?boolean removeAll（Collection c）---删除此集合中所有集合c的元素（重复元素全部删除）

   public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
       collection.add("67");
        System.out.println(collection);
     Collection collection1=new LinkedList();
     collection1.add(1);
     collection.removeAll(collection1);
        System.out.println(collection);
    }

?boolean isEmpty（）---判断集合是否为空

  public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
        System.out.println(collection);
        System.out.println(collection.isEmpty());
    }

?boolean contains（Object o）---判断是否含有某一个元素

public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
        System.out.println(collection);
        System.out.println(collection.isEmpty());
        System.out.println(collection.contains(1));
    }

??boolean containsAll（Collectio o）---判断这个集合是否包含集合o的所有元素

public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
        System.out.println(collection);
       Collection collection1=new LinkedList();
       collection1.add(1);
       collection1.add(3);
        System.out.println(collection1);
        System.out.println(collection.containsAll(collection1));
    }

?int size（）---获取该集合的元素个数

 public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
        System.out.println(collection);
        System.out.println(collection.size());
    }

?object【】 toArray（）---返回装有集合中所有元素的数组

public static void main(String[] args) {
       Collection collection=new ArrayList();
       collection.add("ui");
       collection.add(1);
        collection.add(1);
        Object[] s=collection.toArray();
        for (Object o:s) {
            System.out.print(o+" ");
        }
    }

?泛型

传入元素类型是Object时，因为Object类是所有类的父类，所以什么元素类型都可以存放

class MyarrayList {
    Object[] objects = new Object[10];
    int usedsize = 0;

    public void add(Object e) {
        objects[usedsize++] = e;
    }

    public Object getObjects(int pos) {
        return objects[pos];
    }

    public  void print() {
        for (int i = 0; i < usedsize; i++) {
            System.out.print(objects[i] + " ");
        }
        System.out.println();
    }
}
public class text {
    public static void main(String[] args) {
        MyarrayList myarrayList=new MyarrayList();
        myarrayList.add("1");
        myarrayList.add(1);
        myarrayList.add('o');
       myarrayList.print();
        System.out.println(myarrayList.getObjects(0));
    }
}

?但是如果我们进行了强制类型转化，常常会出现问题

  String str=(String) myarrayList.getObjects(1);//返回Object类型，需要强制类型转化
        System.out.println(str);

?泛型可以解决这个问题---限定操作的数据类型

?在实例化类时传入参数：这个实例化对象只能存放String的数据

   public static void main(String[] args) {
        MyarrayList<String> myarrayList=new MyarrayList<String>();
        //传入String类型的数据
        myarrayList.add("hello");

        //传入int类型的数据
        MyarrayList<Integer> myarrayList1=new MyarrayList<>();
        myarrayList1.add(1);

        //传入char类型的数据
        MyarrayList<Character> myarrayList2=new MyarrayList<>();
        myarrayList2.add('1');
    }

使用泛型的意义：自动进行类型检查、自动进行类型转化?

泛型的擦除机制

泛型在编译期间已经被擦除为了Object类型?

?使用泛型数组的注意问题

数组在运行期间存储和检查类型信息，但是泛型在编译期间检查错误，并且运行期间已经被擦除为Object类型

不能使用泛型来定义数组

E[]objects=new E[10];---这行代码错误

错误的原因：?

编译期间E类型被擦除为Object类型，如果上述代码成功，那么编译期间擦除为

Object[]objects=new Object[10];??

但是如果我们将这个数组强制转化为String类型的数组，就会产生错误，为了避免这样的错误，JVM底层不允许这样定义数组

?正确的泛型数组定义方式：使用映射

object数组的强制转化

java中，其余数组可以整体向上转型转化为Object数组，但是Object数组向下转型时不能整体转型，要将每个元素单独强转

object类不能引用8个普通类型，要引用普通类型的包装类

 public static void main(String[] args) {
        String []str=new String[10];
        System.out.println(str);
        Object[] s=new String[10];//String数组可以向上提升为Object数组
        System.out.println(s);
     //   String [] ret= (String[]) new Object[10];//编译通过
        //     System.out.println(ret);//运行时抛出异常---Object数组不可以整体强制转化为String数组
        
      //  Integer []dest= (Integer []) new Object[10];//编译通过
      //  System.out.println(dest);//运行抛出异常
        Object []dest=new Integer[10];
        System.out.println(dest);

Object a=new String[]{"hello","world"};//Object类是所有类的超类
        System.out.println(a);

    }

 public static void main(String[] args) {
        Object[] s = new String[]{"hello", "world"};
        System.out.println(Arrays.toString(s));

        Object[]objects=new Object[]{"hello", "world"};
        String []str=new String[objects.length];
        for (int i = 0; i < objects.length; i++) {
           str [i]=(String) objects[i];
        }
        System.out.println(Arrays.toString(str));
    }