List(1)

• List：列表

– 有序的Collection

– 允许重复元素

– {1，2，4，{5，2}，1，3}

• List 主要实现

– ArrayList(非同步的)

– LinkedList(非同步)

– Vector(同步)

List(2)

• ArrayList：

– 以数组实现的列表，不支持同步

• List list = Collections.synchronizedList(new ArrayList(...)); //支持同步

– 利用索引位置可以快速定位访问

– 不适合指定位置的插入、删除操作

– 适合变动不大，主要用于查询的数据

– 和Java数组相比，其容量是可动态调整的

– ArrayList在元素填满容器时会自动扩充容器大小的50%

– 查看程序ArrayListTest.java

ArrayListTest.java

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(3);
        arrayList.add(2);
        arrayList.add(1);
        arrayList.add(4);
        arrayList.add(5);
        arrayList.add(6);//自动装箱
        arrayList.add(new Integer(6));
        System.out.print("The fourth element is:");
        System.out.println(arrayList.get(3));//get(index)列表有序，索引获得值

        arrayList.remove(3);// remove(index)
        Iterator<Integer>iterator=arrayList.iterator();
        while (iterator.hasNext())
            System.out.print(iterator.next()+" ");//迭代器遍历

        System.out.println();
        arrayList.add(3,10);

        for (Integer i:arrayList)//for-each遍历
            System.out.print(i+" ");
        
        System.out.println();
    }

}

输出结果：

List(3)

• LinkedList：

– 以双向链表实现的列表，不支持同步

• List list = Collections.synchronizedList(new LinkedList(...)); //转化为支持同步

– 可被当作堆栈、队列和双端队列进行操作

– 顺序访问高效，随机访问较差，中间插入和删除高效

– 适用于经常变化的数据

– 查看程序LinkedListTest.java

LinkedListTest.java



public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<Integer>l1=new LinkedList<>();
        l1.add(3);
        l1.add(2);
        l1.add(5);
        l1.add(6);
        l1.add(6);
        System.out.println(l1.size());
        l1.addFirst(1);//头部添加元素
        l1.addLast(10);//尾部
        l1.add(4,8);//指定位置添加元素
        l1.remove(3);//删除指定位置元素

        for(Integer i:l1)
            System.out.print(i+" ");
        System.out.println();
        System.out.println("--------------华丽丽的分割线---------------");

        LinkedList<Integer>list=new LinkedList<>();//该对象为了测试LinkedList的各项性能
        for(int i=0;i<100000;i++)
        {
            list.add(i);
        }

 traverseByIterator(list);
 traverseByIndex(list);
 traverseByForEach(list);

    }
  public static void traverseByIterator(LinkedList<Integer>list){
      Iterator<Integer>iterator=list.iterator();

//获取系统当前时间，遍历完成后，再获取一次，计算差值即为遍历耗费时间 ，下同。   
     Long start=System.nanoTime();

      while (iterator.hasNext())
      {
          iterator.next();
      }

      Long end=System.nanoTime();
      System.out.println("Iterator遍历耗时： "+(end-start)+"纳秒");
  }

  public static void traverseByIndex(LinkedList<Integer>list){
      Long start=System.nanoTime();

   for(int i=0;i<list.size();i++)
   {
       list.get(i);
   }
      Long end=System.nanoTime();

      System.out.println("Index遍历耗时： "+(end-start)+"纳秒");
  }
    public static void traverseByForEach(LinkedList<Integer>list){
        Long start=System.nanoTime();
       for(Integer i:list)
       {
           ;//do nothing
       }
        Long end=System.nanoTime();

        System.out.println("for-each遍历耗时： "+(end-start)+"纳秒");
    }



}

[点击并拖拽以移动]

输出结果：

运行结果分析：因为LinkedList是用双向链表实现的列表，在利用索引遍历时，耗时最多。利用Iterator遍历与for-each遍历本质上差距不大。

List(4)

• Vector(同步)

– 和ArrayList类似，可变数组实现的列表

– Vector同步，适合在多线程下使用

– 原先不属于JCF框架，属于Java最早的数据结构，性能较差

– 从JDK1.2开始，Vector被重写，并纳入到JCF

– 官方文档建议在非同步情况下，优先采用ArrayList

– 查看程序VectorTest.java

VectorTest.java

public class VectorTest {
    public static void main(String[] args) {
        Vector<Integer>v1=new Vector<>();
        v1.add(1);
        v1.add(2);
        v1.add(3);
        v1.remove(2);
        v1.add(2,5);
        for (Integer i:v1)
            System.out.print(i+" ");
        System.out.println();
        System.out.println("----------------------------");

     Vector<Integer>v2=new Vector<>();//测试Vector的各项性能
     for (int i=0;i<100000;i++)
     {
         v2.add(i);
     }

     traverseByIterator(v2);
     traverseByIndex(v2);
     traverseByForEach(v2);
     traverseByEnu(v2);
    }
    public static void traverseByIterator(Vector<Integer> vector){
        Iterator<Integer> iterator=vector.iterator();

        Long start=System.nanoTime();
        while (iterator.hasNext())
        {
            iterator.next();
        }
        Long end=System.nanoTime();
        System.out.println("Iterator遍历耗时： "+(end-start)+"纳秒");
    }


    public static void traverseByIndex(Vector<Integer>vector){
        Long start=System.nanoTime();
        for(int i=0;i<vector.size();i++)
        {
            vector.get(i);
        }
        Long end=System.nanoTime();

        System.out.println("Index遍历耗时： "+(end-start)+"纳秒");
    }

    public static void traverseByForEach(Vector<Integer>vector){
        Long start=System.nanoTime();
        for(Integer i:vector)
        {
            ;//do nothing
        }
        Long end=System.nanoTime();
        System.out.println("for-each遍历耗时： "+(end-start)+"纳秒");
    }


    public static void traverseByEnu(Vector<Integer>vector){
        Long start=System.nanoTime();

        for(Enumeration<Integer> enu=vector.elements();enu.hasMoreElements();){
            enu.nextElement();
        }
        Long end=System.nanoTime();
        System.out.println("Enumeration遍历耗时： "+(end-start)+"纳秒");
    }

}

输出结果：