day15 （ 集合框架）

集合框架

   概述：数组长度是固定的，当添加的元素超过了数组的长度时需要对数组重新定义，太麻烦，Java内部给我们提供了集合类，能存储任意对象，长度是可以改变的，随元素的增加而增加，随元素的减少而减少。

数组和集合的区别：

     数组既可以存储基本数据类型，又可以存储引用数据类型。（基本数据类型存储的是值，引用数据类型存储的是地址值）

     集合只能存储引用数据类型（对象） 

                   *集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。

 数组和集合的使用 ：

       如果元素个数是固定的推荐用数组。

        如果元素个数不是固定的推荐用集合。

        Collection c = new ArrayList();
        c.add(new Student("张三", 23));
        c.add(new Student("李四", 23));
        c.add(new Student("王五", 23));
        Object[] arr = c.toArray();                                 // 将集合转换成数组
          for (int i = 0; i < arr.length; i++) {
                Student s=(Student)arr[i];                          //向下转型
                System.out.println(s.getName()+"...."+s.getAge());  //获取到值（用这种方法可以进行赋值或进行存储....)
            //  System.out.println(arr[i]);                         //这个紧紧为了打印显示 
            }

        Collection c1 = new ArrayList();
          c1.add("a"); // 添加
          c1.add("b");
          c1.add("c");
          c1.add("d");

        Collection c2 = new ArrayList();
          c2.add("a"); // 添加
          c2.add("b");
          c2.add("c");
          c2.add("d");
        
//        c1.addAll(c2);                  //addAll()将c2中的每一个元素添加到c1集合中。
//        c1.add(c2);                     //add()将c2看成一个对象添加到c1中。
//        c1.removeAll(c2);               //removeAll()删除的是交集。
//        Boolean b = c1.containsAll(c2); //containsAll() 判断调用的集合是否包含传入的集合。
          Boolean b = c1.retainAll(c2);     // retainAll()取交集。如果调用的集合改变就返回true,不变就返回false。
          System.out.println(b);

集合框架（ 集合的遍历之迭代器遍历 ）

       概述:集合是用来存储数据，存储数据需要查看，那么就需要迭代(遍历)。

       原理：迭代器是对集合进行遍历。而每一个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样，那么就需要在每一个类中定义hasNext( ) 和Next( )方法，这样做是可以的，但是会让整个集合体系过于                    臃肿。迭代器是将这样的方法向上抽取出接口，然后在每个类的内部，定义自己迭代方法。

       好处： 1.规定了整个集合体系的遍历方式都是hasNext( )和Next( )方法。

                   2.代码有底层内部实现，使用者不需要管什么实现的，会用即可。

        Collection c1 = new ArrayList();
        c1.add(new Student("张三", 23));
        c1.add(new Student("李四", 23));
        
         Iterator it=c1.iterator();               //获取迭代器
         while (it.hasNext()) {                   //集合中的迭代方法(遍历)
            Student s=(Student) it.next();        //向下转型
            System.out.println(s.getName()+"..."+s.getAge());
            }

集合框架（List集合特有功能）

    

   List list =new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);
        
        list.add(1,555);             //add(index, element)通过索引添加元素
        list.remove(2);              //remove(index)通过索引删除元素，删除时不会自动装箱
        Object s=list.get(1);        //get(index)通过索引获取元素
        list.set(1, 222);            //get(index)通过索引修改元素
        Iterator it=list.iterator(); // 获取迭代器    
        // 对集合中的元素迭代(遍历)
        while (it.hasNext()) {    //判断判断集合中是否有元素，有就返回true
            System.out.println(it.next()); 
            
        }

     // 需求：判断List集合中是否含有"world"这个元素，如果有就添加"javaee"元素
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("world");
        list.add("c");

        ListIterator it = list.listIterator(); // 获取迭代器(List集合特有的)
        while (it.hasNext()) {
            String s = (String) it.next(); // 向下转型
            if ("world".equals(s)) {
                it.add("javaee");
            }

        }
        System.out.println(list);

集合框架（Vector的特有功能）

    

Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");

        Enumeration e = v.elements();
        while (e.hasMoreElements()) {
            System.out.println(e.nextElement());

        }

集合框架（数据结构之数组和链表）

   数组：

       * 查询快 ，修改也快。

       * 增删慢 。

   链表：

       * 查询慢，修改也慢 。

       * 增删快。 

集合框架（List的三个子类的特点）

     ArrayList：

          * 底层数据结构是数组，查询快，增删慢。

          * 线程不安全，效率高。

     Vector（已被ArrayList 替代）：

          * 底层数据结构是数组，查询快，增删慢。

          * 线程安全，效率慢。

     LinkedList：

          * 底层数据结构时链表，查询慢，增删快。

          * 线程不安全，效率快。

  Vector相对ArrayList查询慢（线程安全的）。

  Vector相对LinkedList增删慢（数组结构）。