Java集合中ArrayList、LinkedList异同(面试题)

为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？ 
1. 问题就在于List有多个实现类，如 LinkedList或者Vector等等，
现在你用的是ArrayList，也许哪一天你需要换成其它的实现类呢？，这时你只要改变这一行就行了：
List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。
假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。 
如果没有特别需求的话,最好使用
List list = new LinkedList(); 便于程序代码的重构. 这就是面向接口编程的好处。

2.	ArrayList不是继承List接口，是实现了List接口。
你写成
	ArrayList arrayList = new ArrayList();这样不会有任何问题。
	和List list = new ArrayList();相比这2个写是有区别的。arrayList是一个ArrayList对象，它可以使用ArrayList的所有方法。
List是接口，它是不可以被实例化的（接口是个抽象类），所以必须以它的实现类去实例化它。
list对象虽然也是被实例化为ArrayList但是它实际是List对象，list只能使用ArrayList中已经实现了的List接口中的方法，
ArrayList中那些自己的、没有在List接口定义的方法是不可以被访问到的。
我们说，用接口去做是有它的好处的，如果你把类型定义成ArrayList(也就是一个具体的实现类)那么你就只能接收这一种类型的数据了，
如果你要是定义为List那么你不仅可以接收ArrayList的对象还可以接收LinkedList的对象，这样你的程序就灵活了。

ArrayList、LinkedList异同(面试题)

/**
 * 1. List接口框架
 *
 *    |----Collection接口：单列集合，用来存储一个一个的对象
 *          |----List接口：存储有序的、可重复的数据。  -->“动态”数组,替换原有的数组
 *              |----ArrayList：作为List接口的主要实现类；查找效率比LinkedList高；线程不安全的，效率高；底层使用Object[] elementData存储
 *              |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
 *              |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
 *
 *
 2. ArrayList的源码分析：
 2.1 jdk 7情况下
       ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
       list.add(123);//elementData[0] = new Integer(123);
       ...
       list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
       默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
 
       结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
 *
 *   2.2 jdk 8中ArrayList的变化：
 *      ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组，（懒汉式）。
 *      即通过无参构造方法来创建ArrayList时，它的长度其实是为0的。
 *
 *      list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
 *      ...
 	如果使用的是带指定下标的add方法，则复杂度为O(n)，因为涉及到对数组中元素的移动，这一操作是非常耗时的。
 	ArrayList和Vector的add、get、size方法的复杂度都为O(1)，remove方法的复杂度为O(n);  
 	indexOf方法的作用是返回第一个等于给定元素的值的下标。它是通过遍历比较数组中每个元素的值来查找的，所以它的时间复杂度是O(n)。 
 	lastIndexOf的原理跟indexOf一样，而它仅仅是从后往前找起罢了。 
 *      后续的添加和扩容操作与jdk 7 无异。
 *   2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，
 *           而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。


	 * 3. LinkedList的源码分析：
 *      LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
 *      list.add(123);//将123封装到Node中，创建了Node对象。
 *
 *      其中，Node定义为：体现了LinkedList的双向链表的说法
 *      private static class Node<E> {
             E item;
             Node<E> next;
             Node<E> prev;

             Node(Node<E> prev, E element, Node<E> next) {
             this.item = element;
             this.next = next;
             this.prev = prev;
             }
         }
         
	因为 LinkedList 有头指针和尾指针，所以在表头或表尾进行插入元素只需要 O(1) 的时间，
	而在指定位置插入元素则需要先遍历一下链表，所以复杂度为 O(n)。 	
 	
    4. Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
 *      在扩容方面，默认扩容为原来的数组长度的2倍。
 *
 *  面试题：ArrayList、LinkedList、Vector三者的异同？
 *  同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
 *  不同：见上
 *
 *   5. List接口中的常用方法

### List的方法

add、indexOf、lastIndexOf、remove、set、subList

@Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        int index = list.indexOf(4567);
        System.out.println(index);//-1

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的 ---左闭右开 ---区间的子集合
         System.out.println(list);
        //[456,"cc",Person("Tom",12),456]
        List subList = list.subList(2, 4);//注意这里不是（2,3）    
        System.out.println(subList);
        //[Person("Tom",12),456]
    }

add(指定位置)、addAll

    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
//        list.add(list1); ---会把1,2,3当成一个对象
        System.out.println(list.size());//9

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

总结常用方法：


总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
     ② 增强for循环
     ③ 普通的循环

     */
    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("***************");

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }

        System.out.println("***************");

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
    }

面试题

//区分list中的remove(int index)和remove(Object obj)
@Test
public void testListRemove() {
   List list= new ArrayList();
    list.add(1);//包装类 1 2 3
    list.add(2);
    list.add(3);
    updateList(list);
    System.out.println(list);
}
privatestaticvoidupdateList(List list) {
    list.remove(2); //这里删除的是索引为2的值 删除的是数值3
    list.remove(new Integer(2));//这里删除的是值为2的数。
}

## List实现类之二：LinkedList

新增方法：

    void addFirst(Object obj)
    void addLast(Object obj)
    Object getFirst()
    Object getLast()
    Object removeFirst()
    Object removeLast()

LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。
同时，定义内部类Node，作为LinkedList中保存数据的基本结构。
Node除了保存数据，还定义了两个变量：
prev变量记录前一个元素的位置
next变量记录下一个元素的位置
在这里插入图片描述

List 实现类之三：Vector（基本不用）

Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
	在各种list中，最好把ArrayList作为缺省（默认）选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用.