集合之List

集合：List   里面的元素有序(存取顺序一致)，并且元素可以重复

           并且每一个元素都存在一个对应的索引

  List集合的特有功能：
                        void add(int index,E element):    在指定索引处添加元素
                        E remove(int index):     移除指定索引处的元素  返回的是移除的元素
                        E get(int index):   获取指定索引处的元素
                        E set(int index,E element):   更改指定索引处的元素 返回的而是被替换的元素

  遍历List集合： 

                       1）迭代器遍历

                       2）for循环+size()+get(i)遍历

   List自己特有的迭代器：  ListIterator  继承自 Iterator 

                     特有功能：

                                        boolean  hasPrevious():  是否存在前一个元素

                                        E    previous():   遍历前一个元素并将它返回

                       注意：  以上两个方法实现的是逆序遍历，但在逆序遍历之前，必须得先正序遍历一遍

                                    否则会报  NullPointerException 异常

 

ConcurrentModificationException ：集合的并发修改异常

           当我们在遍历集合时，已经获取到了迭代器对象了，在遍历过程中想要再修改集合（添加add()/删除remove()）时

       这时编译就会报  ConcurrentModificationException  ，因为已经获取到迭代器对象了，它就已经知道集合的 size() 了，

       所以此时想要修改时就会报错；

   解决方法： 1）使用Iterator迭代器本身的 add() 功能

                      2)   使用for()循环遍历的方式

 

List的三个子集合： 

            1）ArrayList:  底层数据结构是 数组，

                                  特点： 查询快，增删慢，线程不安全，效率高

            2）Vector:  底层数据结构也是 数组  (基本用 CopyOnWriteArrayList 代替)

                                   特点： 查询快，增删慢，线程安全，但效率低

            3）LinkedList: 底层数据结构是 链表( 双向循环链表 )

                                    特点： 查询慢，增删快，线程不安全，效率高

******面试题：

         Vector和ArrayList有什么差异?

               ArrayList与Vector的区别主要从两方面来说: 
                      1) 同步性:  Vector是线程安全的(同步),  而ArrayList是线程不安全的（非同步）; 
                      2) 扩容:      当需要扩容时,Vector默认增长一倍 ,而ArrayList却是一半.

 

ArrayList:  

      特有功能： 

              int indexOf (Object o)    返回此列表中指定元素的第一个出现的索引，或  如果此列表不包含元素，返回 - 1
              void sort (Comparator < ? super E > c)      分类列表使用提供的 Comparator 比较元素 （匿名内部类 重写 compare() ）

                   例： sort( new Comparator(){

                                 @override

                                  public int compare(Object o1, Object o2){

                                         ...

                                  }

                           });
              List<E> subList ( int fromIndex, int toIndex)   返回一个视图之间的指定 fromIndex，和 toIndex这份名单的部分
              Object[] toArray ()  返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一个到最后一个元素）

 

Vector : 可以实现可增长的对象数组

         Vector类特有功能
                         public void addElement(E obj):  添加集合元素
                         public E elementAt(int index) ： 根据索引返回该处的元素
                         public Enumeration elements() ： 返回此向量的组件的枚举

                         E firstElement()   返回第一个组件（在指数 0项目）这个载体
                         E lastElement()   返回向量的最后一个组件

         

  Vector 集合特有的遍历方式
        Enumeration<Integer> elements = integers.elements();
          while (elements.hasMoreElements()) {

                  System.out.println(elements.nextElement());
          }

 

LinkedList:  List 接口的链表实现 ( 双向链表 )

       特有功能：

                 public void addFirst(E e)及addLast(E e) ：在链表中的首 添加元素 或者 在链表中的尾 添加元素
                 public E getFirst()及getLast()：得到链表中的 首元素 或者 得到链表中的 尾元素
                 public E removeFirst()及public E removeLast()：删除链表中的 首元素 或者 删除链表中的  尾元素

 

泛型机制：为了给集合指定某种数据类型而产生的一种机制，把数据类型给明确了

                  可推迟到创建对象 或 调用方法时再去 明确数据类型

 泛型的格式： < 数据类型 >  该数据类型只能是 引用数据类型

 泛型好处
        (1):    把运行时期的问题提前到了编译期间
        (2):    避免了强制类型转换
        (3):    优化了程序设计，解决了黄色警告线
 注意：泛型只在编译期有效  但在运行期就擦除了  

  泛型的定义： 

        1）定义在 类 上：          

                    public class ObjectTools < K > {
    
                                 private K k ;

                                 public K getK() {
                                       return k;
                                 }

                                public void setK(K k) {
                                        this.k = k;
                                 }

                    }

       2)   定义在 接口 上

                     public interface Object < E >{

                    }

       3)  定义在 方法 上

                    public < E > void Object(){

                    }

泛型的高级通配符： 

        < ? >:   任意类型，如果没有明确，那么就是Object以及任意的Java类了
        < ? extends E >:    向下限定，E及其子类
        < ? super E  >:       向上限定，E及其父类

 

增强 for 循环：  简化数组和Collection集合的遍历

          格式：
                    for(元素数据类型 变量   :    数组 或者 Collection集合) {
                               使用变量即可，该变量就是元素
                     }

       注意事项：增强for的目标要判断是否为null

 

可变参数：定义方法时不知道定义几个参数，所以就产生了可变参数

           格式： public void Object (数据类型 E ... 变量名 )  {   //实际上， 相当于一个数组，存储了这一系列（...）的参数

                       }

       注意事项: 如果一个方法里面有可变参数，还有多个参数时，可变参数写在最后面；

 

数组    < ------------  >  集合： 

       1）数组 ----> 集合  :   Arrays.asList():  将一个数组转成一个集合

             注意事项:    得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
                                 只能获取元素(get)

       2）集合 ---->  数组： Object[] toArray ()  返回一个数组，包含在这个列表中的所有元素在适当的顺序