Java重要类详解之ArrayList类

2018-07-12 07:34:38来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

 

https://blog.csdn.net/shengmingqijiquan/article/details/52634640

 

一.ArrayList概述

  • ArrayList 是一个数组队列,相当于动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List,RandomAccess[随机访问],Cloneable[可克隆], java.io.Serializable[序列化]这些接口。
  • ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
  • ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。稍后,我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
  • ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
  • ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
  • 和Vector不同,ArrayList中的操作不是线程安全的。所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList。
PS:以上继承关系可以表示为以下形式:

 

二.ArrayList之API  

 

1.ArrayList和Collection之间的关系

*实线代表直接继承的父类,虚线代表实现的接口;

2.ArrayList类的API

  1.  
    <span style="font-family:Microsoft YaHei;">// Collection中定义的API
  2.  
    boolean             add(E object)//添加一个数组对象
  3.  
    boolean             addAll(Collection<? extends E> collection)//添加一个包含Collection的对象
  4.  
    void              clear()//清空
  5.  
    boolean             contains(Object object)//包含
  6.  
    boolean             containsAll(Collection<?> collection)
  7.  
    boolean             equals(Object object)//判等
  8.  
    int               hashCode()
  9.  
    boolean             isEmpty()//判空
  10.  
    Iterator<E>         iterator()
  11.  
    boolean             remove(Object object)//删除
  12.  
    boolean             removeAll(Collection<?> collection)
  13.  
    boolean             retainAll(Collection<?> collection)
  14.  
    int               size()
  15.  
    <T> T[]             toArray(T[] array)
  16.  
    Object[]            toArray()
  17.  
    // AbstractCollection中定义的API
  18.  
    void              add(int location, E object)
  19.  
    boolean             addAll(int location, Collection<? extends E> collection)
  20.  
    E                get(int location)//获取某个元素值
  21.  
    int               indexOf(Object object)
  22.  
    int               lastIndexOf(Object object)
  23.  
    ListIterator<E>     listIterator(int location)
  24.  
    ListIterator<E>     listIterator()
  25.  
    E                remove(int location)
  26.  
    E                set(int location, E object)
  27.  
    List<E>             subList(int start, int end)
  28.  
    // ArrayList新增的API
  29.  
    Object             clone()//
  30.  
    void              ensureCapacity(int minimumCapacity)//保证容量不小于元素个数
  31.  
    void              trimToSize()
  32.  
    void              removeRange(int fromIndex, int toIndex)
  33.  
    </span>

3.ArrayList的源码解析

  1.  
    <span style="font-family:Microsoft YaHei;">package java.util;
  2.  
    public class ArrayList<E> extends AbstractList<E>
  3.  
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  4.  
    {
  5.  
        // 序列版本号
  6.  
        private static final long serialVersionUID = 8683452581122892189L;
  7.  
        // 保存ArrayList中数据的数组
  8.  
        private transient Object[] elementData;
  9.  
        // ArrayList中实际数据的数量
  10.  
        private int size;
  11.  
        // ArrayList带容量大小的构造函数。
  12.  
        public ArrayList(int initialCapacity) {
  13.  
            super();
  14.  
            if (initialCapacity < 0)
  15.  
                throw new IllegalArgumentException("Illegal Capacity: "+
  16.  
                                                   initialCapacity);
  17.  
            // 新建一个数组
  18.  
            this.elementData = new Object[initialCapacity];
  19.  
        }
  20.  
        // ArrayList构造函数。默认容量是10。
  21.  
        public ArrayList() {
  22.  
            this(10);
  23.  
        }
  24.  
        // 创建一个包含collection的ArrayList
  25.  
        public ArrayList(Collection<? extends E> c) {
  26.  
            elementData = c.toArray();
  27.  
            size = elementData.length;
  28.  
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
  29.  
            if (elementData.getClass() != Object[].class)
  30.  
                elementData = Arrays.copyOf(elementData, size, Object[].class);
  31.  
        }
  32.  
        // 将当前容量值设为 =实际元素个数
  33.  
        public void trimToSize() {
  34.  
            modCount++;
  35.  
            int oldCapacity = elementData.length;
  36.  
            if (size < oldCapacity) {
  37.  
                elementData = Arrays.copyOf(elementData, size);
  38.  
            }
  39.  
        }
  40.  
        // 确定ArrarList的容量。
  41.  
        // 若ArrayList的容量不足以容纳当前的全部元素,设置 新的容量=“(原始容量x3)/2 + 1”
  42.  
        public void ensureCapacity(int minCapacity) {
  43.  
            // 将“修改统计数”+1
  44.  
            modCount++;
  45.  
            int oldCapacity = elementData.length;
  46.  
            // 若当前容量不足以容纳当前的元素个数,设置 新的容量=“(原始容量x3)/2 + 1”
  47.  
            if (minCapacity > oldCapacity) {
  48.  
                Object oldData[] = elementData;
  49.  
                int newCapacity = (oldCapacity * 3)/2 + 1;
  50.  
                if (newCapacity < minCapacity)
  51.  
                    newCapacity = minCapacity;
  52.  
                elementData = Arrays.copyOf(elementData, newCapacity);
  53.  
            }
  54.  
        }
  55.  
        // 添加元素e
  56.  
        public boolean add(E e) {
  57.  
            // 确定ArrayList的容量大小
  58.  
            ensureCapacity(size + 1);  // Increments modCount!!
  59.  
            // 添加e到ArrayList中
  60.  
            elementData[size++] = e;
  61.  
            return true;
  62.  
        }
  63.  
        // 返回ArrayList的实际大小
  64.  
        public int size() {
  65.  
            return size;
  66.  
        }
  67.  
        // 返回ArrayList是否包含Object(o)
  68.  
        public boolean contains(Object o) {
  69.  
            return indexOf(o) >= 0;
  70.  
        }
  71.  
        // 返回ArrayList是否为空
  72.  
        public boolean isEmpty() {
  73.  
            return size == 0;
  74.  
        }
  75.  
        // 正向查找,返回元素的索引值
  76.  
        public int indexOf(Object o) {
  77.  
            if (o == null) {
  78.  
                for (int i = 0; i < size; i++)
  79.  
                if (elementData[i]==null)
  80.  
                    return i;
  81.  
                } else {
  82.  
                    for (int i = 0; i < size; i++)
  83.  
                    if (o.equals(elementData[i]))
  84.  
                        return i;
  85.  
                }
  86.  
                return -1;
  87.  
            }
  88.  
            // 反向查找,返回元素的索引值
  89.  
            public int lastIndexOf(Object o) {
  90.  
            if (o == null) {
  91.  
                for (int i = size-1; i >= 0; i--)
  92.  
                if (elementData[i]==null)
  93.  
                    return i;
  94.  
            } else {
  95.  
                for (int i = size-1; i >= 0; i--)
  96.  
                if (o.equals(elementData[i]))
  97.  
                    return i;
  98.  
            }
  99.  
            return -1;
  100.  
        }
  101.  
        // 反向查找(从数组末尾向开始查找),返回元素(o)的索引值
  102.  
        public int lastIndexOf(Object o) {
  103.  
            if (o == null) {
  104.  
                for (int i = size-1; i >= 0; i--)
  105.  
                if (elementData[i]==null)
  106.  
                    return i;
  107.  
            } else {
  108.  
                for (int i = size-1; i >= 0; i--)
  109.  
                if (o.equals(elementData[i]))
  110.  
                    return i;
  111.  
            }
  112.  
            return -1;
  113.  
        }
  114.  
     
  115.  
        // 返回ArrayList的Object数组
  116.  
        public Object[] toArray() {
  117.  
            return Arrays.copyOf(elementData, size);
  118.  
        }
  119.  
        // 返回ArrayList的模板数组。所谓模板数组,即可以将T设为任意的数据类型
  120.  
        public <T> T[] toArray(T[] a) {
  121.  
            // 若数组a的大小 < ArrayList的元素个数;
  122.  
            // 则新建一个T[]数组,数组大小是“ArrayList的元素个数”,并将“ArrayList”全部拷贝到新数组中
  123.  
            if (a.length < size)
  124.  
                return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  125.  
            // 若数组a的大小 >= ArrayList的元素个数;
  126.  
            // 则将ArrayList的全部元素都拷贝到数组a中。
  127.  
            System.arraycopy(elementData, 0, a, 0, size);
  128.  
            if (a.length > size)
  129.  
                a[size] = null;
  130.  
            return a;
  131.  
        }
  132.  
        // 获取index位置的元素值
  133.  
        public E get(int index) {
  134.  
            RangeCheck(index);
  135.  
            return (E) elementData[index];
  136.  
        }
  137.  
        // 设置index位置的值为element
  138.  
        public E set(int index, E element) {
  139.  
            RangeCheck(index);
  140.  
            E oldValue = (E) elementData[index];
  141.  
            elementData[index] = element;
  142.  
            return oldValue;
  143.  
        }
  144.  
        // 将e添加到ArrayList中
  145.  
        public boolean add(E e) {
  146.  
            ensureCapacity(size + 1);  // Increments modCount!!
  147.  
            elementData[size++] = e;
  148.  
            return true;
  149.  
        }
  150.  
        // 将e添加到ArrayList的指定位置
  151.  
        public void add(int index, E element) {
  152.  
            if (index > size || index < 0)
  153.  
                throw new IndexOutOfBoundsException(
  154.  
                "Index: "+index+", Size: "+size);
  155.  
            ensureCapacity(size+1);  // Increments modCount!!
  156.  
            System.arraycopy(elementData, index, elementData, index + 1,
  157.  
                 size - index);
  158.  
            elementData[index] = element;
  159.  
            size++;
  160.  
        }
  161.  
        // 删除ArrayList指定位置的元素
  162.  
        public E remove(int index) {
  163.  
            RangeCheck(index);
  164.  
            modCount++;
  165.  
            E oldValue = (E) elementData[index];
  166.  
            int numMoved = size - index - 1;
  167.  
            if (numMoved > 0)
  168.  
                System.arraycopy(elementData, index+1, elementData, index,
  169.  
                     numMoved);
  170.  
            elementData[--size] = null; // Let gc do its work
  171.  
            return oldValue;
  172.  
        }
  173.  
        // 删除ArrayList的指定元素
  174.  
        public boolean remove(Object o) {
  175.  
            if (o == null) {
  176.  
                    for (int index = 0; index < size; index++)
  177.  
                if (elementData[index] == null) {
  178.  
                    fastRemove(index);
  179.  
                    return true;
  180.  
                }
  181.  
            } else {
  182.  
                for (int index = 0; index < size; index++)
  183.  
                if (o.equals(elementData[index])) {
  184.  
                    fastRemove(index);
  185.  
                    return true;
  186.  
                }
  187.  
            }
  188.  
            return false;
  189.  
        }
  190.  
        // 快速删除第index个元素
  191.  
        private void fastRemove(int index) {
  192.  
            modCount++;
  193.  
            int numMoved = size - index - 1;
  194.  
            // 从"index+1"开始,用后面的元素替换前面的元素。
  195.  
            if (numMoved > 0)
  196.  
                System.arraycopy(elementData, index+1, elementData, index,
  197.  
                                 numMoved);
  198.  
            // 将最后一个元素设为null
  199.  
            elementData[--size] = null; // Let gc do its work
  200.  
        }
  201.  
        // 删除元素
  202.  
        public boolean remove(Object o) {
  203.  
            if (o == null) {
  204.  
                for (int index = 0; index < size; index++)
  205.  
                if (elementData[index] == null) {
  206.  
                    fastRemove(index);
  207.  
                return true;
  208.  
                }
  209.  
            } else {
  210.  
                // 便利ArrayList,找到“元素o”,则删除,并返回true。
  211.  
                for (int index = 0; index < size; index++)
  212.  
                if (o.equals(elementData[index])) {
  213.  
                    fastRemove(index);
  214.  
                return true;
  215.  
                }
  216.  
            }
  217.  
            return false;
  218.  
        }
  219.  
        // 清空ArrayList,将全部的元素设为null
  220.  
        public void clear() {
  221.  
            modCount++;
  222.  
            for (int i = 0; i < size; i++)
  223.  
                elementData[i] = null;
  224.  
            size = 0;
  225.  
        }
  226.  
        // 将集合c追加到ArrayList中
  227.  
        public boolean addAll(Collection<? extends E> c) {
  228.  
            Object[] a = c.toArray();
  229.  
            int numNew = a.length;
  230.  
            ensureCapacity(size + numNew);  // Increments modCount
  231.  
            System.arraycopy(a, 0, elementData, size, numNew);
  232.  
            size += numNew;
  233.  
            return numNew != 0;
  234.  
        }
  235.  
        // 从index位置开始,将集合c添加到ArrayList
  236.  
        public boolean addAll(int index, Collection<? extends E> c) {
  237.  
            if (index > size || index < 0)
  238.  
                throw new IndexOutOfBoundsException(
  239.  
                "Index: " + index + ", Size: " + size);
  240.  
            Object[] a = c.toArray();
  241.  
            int numNew = a.length;
  242.  
            ensureCapacity(size + numNew);  // Increments modCount
  243.  
            int numMoved = size - index;
  244.  
            if (numMoved > 0)
  245.  
                System.arraycopy(elementData, index, elementData, index + numNew,
  246.  
                     numMoved);
  247.  
            System.arraycopy(a, 0, elementData, index, numNew);
  248.  
            size += numNew;
  249.  
            return numNew != 0;
  250.  
        }
  251.  
        // 删除fromIndex到toIndex之间的全部元素。
  252.  
        protected void removeRange(int fromIndex, int toIndex) {
  253.  
        modCount++;
  254.  
        int numMoved = size - toIndex;
  255.  
            System.arraycopy(elementData, toIndex, elementData, fromIndex,
  256.  
                             numMoved);
  257.  
        // Let gc do its work
  258.  
        int newSize = size - (toIndex-fromIndex);
  259.  
        while (size != newSize)
  260.  
            elementData[--size] = null;
  261.  
        }
  262.  
        private void RangeCheck(int index) {
  263.  
        if (index >= size)
  264.  
            throw new IndexOutOfBoundsException(
  265.  
            "Index: "+index+", Size: "+size);
  266.  
        }
  267.  
        // 克隆函数
  268.  
        public Object clone() {
  269.  
            try {
  270.  
                ArrayList<E> v = (ArrayList<E>) super.clone();
  271.  
                // 将当前ArrayList的全部元素拷贝到v中
  272.  
                v.elementData = Arrays.copyOf(elementData, size);
  273.  
                v.modCount = 0;
  274.  
                return v;
  275.  
            } catch (CloneNotSupportedException e) {
  276.  
                // this shouldn't happen, since we are Cloneable
  277.  
                throw new InternalError();
  278.  
            }
  279.  
        }
  280.  
        // java.io.Serializable的写入函数
  281.  
        // 将ArrayList的“容量,所有的元素值”都写入到输出流中
  282.  
        private void writeObject(java.io.ObjectOutputStream s)
  283.  
            throws java.io.IOException{
  284.  
        // Write out element count, and any hidden stuff
  285.  
        int expectedModCount = modCount;
  286.  
        s.defaultWriteObject();
  287.  
            // 写入“数组的容量”
  288.  
            s.writeInt(elementData.length);
  289.  
        // 写入“数组的每一个元素”
  290.  
        for (int i=0; i<size; i++)
  291.  
                s.writeObject(elementData[i]);
  292.  
        if (modCount != expectedModCount) {
  293.  
                throw new ConcurrentModificationException();
  294.  
            }
  295.  
        }
  296.  
        // java.io.Serializable的读取函数:根据写入方式读出
  297.  
        // 先将ArrayList的“容量”读出,然后将“所有的元素值”读出
  298.  
        private void readObject(java.io.ObjectInputStream s)
  299.  
            throws java.io.IOException, ClassNotFoundException {
  300.  
            // Read in size, and any hidden stuff
  301.  
            s.defaultReadObject();
  302.  
            // 从输入流中读取ArrayList的“容量”
  303.  
            int arrayLength = s.readInt();
  304.  
            Object[] a = elementData = new Object[arrayLength];
  305.  
            // 从输入流中将“所有的元素值”读出
  306.  
            for (int i=0; i<size; i++)
  307.  
                a[i] = s.readObject();
  308.  
        }
  309.  
    }
  310.  
    </span>
 

重点总结:

  • ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时;若使用默认构造函数,则ArrayList的默认容量大小是10。
  • 当ArrayList容量不足以容纳全部元素时,ArrayList会重新设置容量:新的容量=“(原始容量x3)/2 + 1”。
  • ArrayList的克隆函数,即是将全部元素克隆到一个数组中。
  • ArrayList实现java.io.Serializable的方式。当写入到输出流时,先写入“容量”,再依次写入“每一个元素”;当读出输入流时,先读取“容量”,再依次读取“每一个元素”。

三.ArrayList的使用实例

1.ArrayList的添加

将字符a添加到list当中

 

  1.  
    <span style="font-family:Microsoft YaHei;">package com.ArrayList;
  2.  
     
  3.  
    import java.util.ArrayList;
  4.  
     
  5.  
    /**
  6.  
    * @author shengmingqijiquan
  7.  
    * @since 2016.09.23
  8.  
    *
  9.  
    * */
  10.  
    public class MyArrayList{
  11.  
    public static void main(String[] args) {
  12.  
    ArrayList<String> list = new ArrayList<String>();
  13.  
    list.add("a");//按照顺序依次添加。将a添加到list中
  14.  
    System.out.println(list+" ");
  15.  
    list.add(1,"b");//在第1个元素后面添加E,ArrayList中必须有足够多的数据,例如ArrayList中没有任何数据,这个时候使用arraylist.add(1, "E");就会出现java.lang.IndexOutOfBoundsException异常。
  16.  
    System.out.println(list+" ");
  17.  
    ArrayList<String> list1 = new ArrayList<String>();
  18.  
    list1.addAll(list);//将list中的全部数据添加到list1中
  19.  
    System.out.println(list1+" ");
  20.  
    list1.addAll(1,list);//将一个ArrayList中的所有数据添加到另外一个ArraList中的第1个元素之后
  21.  
    System.out.println(list1+" ");
  22.  
     
  23.  
    }
  24.  
     
  25.  
    }
  26.  
    </span>

运行结果:

 

2.ArrayList的删除

  1.  
    <span style="font-family:Microsoft YaHei;">package com.ArrayList;
  2.  
     
  3.  
    import java.util.ArrayList;
  4.  
    /**
  5.  
    * @author shengmingqijiquan
  6.  
    * @since 2016.09.23
  7.  
    *
  8.  
    * */
  9.  
    public class ArrrayListRemove {
  10.  
    public static void main(String[] args) {
  11.  
    ArrayList<String> list = new ArrayList<String>();
  12.  
    list.add("a");
  13.  
    list.add("b");
  14.  
    list.add("c");
  15.  
    list.add("d");
  16.  
    list.add("e");
  17.  
    System.out.println(list+" ");
  18.  
     
  19.  
    //1.按照内容删除单个数据.注意:对于int,String,char这样的原始类型数据是可以删除的,但是对于复杂对象,例如自己编写的User类、Person类对象,需要重写equals方法,负责remove方法无法匹配删除。
  20.  
    list.remove("a");//将list中的数据"d"删除
  21.  
    System.out.println("删除单个数据a:"+list);
  22.  
     
  23.  
    //2.按照集合同时删除多个数据
  24.  
    ArrayList<String> list1 = new ArrayList<String>();
  25.  
    list1.add("a");
  26.  
    list1.add("b");
  27.  
    list.removeAll(list1);//按照list1的数据删除list
  28.  
    System.out.println("删除多个数据后,清空之前 "+list);
  29.  
     
  30.  
    //3.清空ArrayList
  31.  
    list.clear();
  32.  
    System.out.println("清空之后 "+list);
  33.  
     
  34.  
    }
  35.  
    }
  36.  
    </span>
运行结果:
 

3.ArrayList的修改

  1.  
    <span style="font-family:Microsoft YaHei;">package com.ArrayList;
  2.  
     
  3.  
    import java.util.ArrayList;
  4.  
    /**
  5.  
    * @author shengmingqijiquan
  6.  
    * @date 2016.09.23
  7.  
    * */
  8.  
    public class ArrayListSet {
  9.  
     
  10.  
    public static void main(String[] args) {
  11.  
    ArrayList<String> list = new ArrayList<>();
  12.  
    list.add("a");
  13.  
    list.add("b");
  14.  
    list.add("c");
  15.  
    list.add("d");
  16.  
    list.add("e");
  17.  
    System.out.println("修改前"+list);
  18.  
    list.set(1,"f");
  19.  
    list.set(2,"g");
  20.  
    System.out.println("修改后"+list);
  21.  
    }
  22.  
     
  23.  
    }
  24.  
    </span>
运行结果:
 

4.ArrayList的查询

  1.  
    <span style="font-family:Microsoft YaHei;">package com.ArrayList;
  2.  
     
  3.  
    import java.util.ArrayList;
  4.  
    /**
  5.  
    * @author shengmingqijiquan
  6.  
    * @date 2016.09.23
  7.  
    * */
  8.  
    public class ArrayListGet {
  9.  
     
  10.  
    public static void main(String[] args) {
  11.  
    ArrayList<String> list = new ArrayList<>();
  12.  
    list.add("a");
  13.  
    list.add("b");
  14.  
    list.add("c");
  15.  
    list.add("d");
  16.  
    list.add("e");
  17.  
    System.out.println("初始化数组:"+list);
  18.  
    String ele = list.get(1);
  19.  
    System.out.println("查询到的元素ele:"+ele);
  20.  
     
  21.  
    }
  22.  
     
  23.  
    }
  24.  
    </span>
运行结果:
 

5.ArrayList的遍历

ArrayList支持3种遍历方式

  • 第一种,通过迭代器遍历。即通过Iterator去遍历
  1.  
    <span style="font-family:Microsoft YaHei;">Integer value = null;
  2.  
    Iterator iter = list.iterator();
  3.  
    while (iter.hasNext()) {
  4.  
        value = (Integer)iter.next();
  5.  
    }
  6.  
    </span>
  • 第二种,随机访问,通过索引值去遍历
  1.  
    <span style="font-family:Microsoft YaHei;">Integer value = null;
  2.  
    int size = list.size();
  3.  
    for (int i=0; i<size; i++) {
  4.  
        value = (Integer)list.get(i);       
  5.  
    }
  6.  
    </span>
  • 第三种,for循环遍历
  1.  
    <span style="font-family:Microsoft YaHei;">Integer value = null;
  2.  
    for (Integer integ:list) {
  3.  
    value = integ;
  4.  
    }</span>

比较这三种遍历方式的效率

  1.  
    <span style="font-family:Microsoft YaHei;">import java.util.*;
  2.  
    import java.util.concurrent.*;
  3.  
    /*
  4.  
     * @title ArrayList遍历方式和效率的测试程序。
  5.  
     *
  6.  
     * @author shengmingqijiquan
  7.  
     */
  8.  
    public class ArrayListRandomAccessTest {
  9.  
        public static void main(String[] args) {
  10.  
            List list = new ArrayList();
  11.  
            for (int i=0; i<100000; i++)
  12.  
                list.add(i);
  13.  
            //isRandomAccessSupported(list);
  14.  
            iteratorThroughRandomAccess(list) ;
  15.  
            iteratorThroughIterator(list) ;
  16.  
            iteratorThroughFor2(list) ;
  17.  
     
  18.  
        }
  19.  
        private static void isRandomAccessSupported(List list) {
  20.  
            if (list instanceof RandomAccess) {
  21.  
                System.out.println("RandomAccess implemented!");
  22.  
            } else {
  23.  
                System.out.println("RandomAccess not implemented!");
  24.  
            }
  25.  
        }
  26.  
        public static void iteratorThroughRandomAccess(List list) {
  27.  
            long startTime;
  28.  
            long endTime;
  29.  
            startTime = System.currentTimeMillis();
  30.  
            for (int i=0; i<list.size(); i++) {
  31.  
                list.get(i);
  32.  
            }
  33.  
            endTime = System.currentTimeMillis();
  34.  
            long interval = endTime - startTime;
  35.  
            System.out.println("iteratorThroughRandomAccess:" + interval+" ms");
  36.  
        }
  37.  
        public static void iteratorThroughIterator(List list) {
  38.  
            long startTime;
  39.  
            long endTime;
  40.  
            startTime = System.currentTimeMillis();
  41.  
            for(Iterator iter = list.iterator(); iter.hasNext(); ) {
  42.  
                iter.next();
  43.  
            }
  44.  
            endTime = System.currentTimeMillis();
  45.  
            long interval = endTime - startTime;
  46.  
            System.out.println("iteratorThroughIterator:" + interval+" ms");
  47.  
        }
  48.  
        public static void iteratorThroughFor2(List list) {
  49.  
            long startTime;
  50.  
            long endTime;
  51.  
            startTime = System.currentTimeMillis();
  52.  
            for(Object obj:list)
  53.  
     
  54.  
            endTime = System.currentTimeMillis();
  55.  
            long interval = endTime - startTime;
  56.  
            System.out.println("iteratorThroughFor2:" + interval+" ms");
  57.  
        }
  58.  
    }
  59.  
    </span>
运行结果:
iteratorThroughRandomAccess:3 ms
iteratorThroughIterator:8 ms
iteratorThroughFor2:5 ms
由此可见,遍历ArrayList时,使用随机访问(即,通过索引序号访问)效率最高,而使用迭代器的效率最低!
 

6.ArrayList之toArray()补充

当我们调用ArrayList中的 toArray(),可能遇到过抛出“java.lang.ClassCastException”异常的情况。下面我们说说这是怎么回事。
ArrayList提供了2个toArray()函数:Object[] toArray()<T> T[] toArray(T[] contents)。调用 toArray() 函数会抛出“java.lang.ClassCastException”异常,但是调用 toArray(T[] contents) 能正常返回 T[]。
toArray() 会抛出异常是因为 toArray() 返回的是 Object[] 数组,将 Object[] 转换为其它类型(如如,将Object[]转换为的Integer[])则会抛出“java.lang.ClassCastException”异常,因为Java不支持向下转型。具体的可以参考前面ArrayList.java的源码介绍部分的toArray()。
解决该问题的办法是调用 <T> T[] toArray(T[] contents) , 而不是 Object[] toArray()。
调用 toArray(T[] contents) 返回T[]的可以通过以下几种方式实现。
  1.  
    <span style="font-family:Microsoft YaHei;">// toArray(T[] contents)调用方式一
  2.  
    public static Integer[] vectorToArray1(ArrayList<Integer> v) {
  3.  
        Integer[] newText = new Integer[v.size()];
  4.  
        v.toArray(newText);
  5.  
        return newText;
  6.  
    }
  7.  
    // toArray(T[] contents)调用方式二。最常用!
  8.  
    public static Integer[] vectorToArray2(ArrayList<Integer> v) {
  9.  
        Integer[] newText = (Integer[])v.toArray(new Integer[0]);
  10.  
        return newText;
  11.  
    }
  12.  
    // toArray(T[] contents)调用方式三
  13.  
    public static Integer[] vectorToArray3(ArrayList<Integer> v) {
  14.  
        Integer[] newText = new Integer[v.size()];
  15.  
        Integer[] newStrings = (Integer[])v.toArray(newText);
  16.  
        return newStrings;
  17.  
    }</span>
 

7.ArrayList综合实例

import java.util.*;
  1.  
    <span style="font-family:Microsoft YaHei;">/*
  2.  
     * @title ArrayList常用API的测试程序
  3.  
     * @author shengmingqijiquan
  4.  
     * @email 1127641712@qq.com
  5.  
     */
  6.  
    public class ArrayListTest {
  7.  
        public static void main(String[] args) {
  8.  
     
  9.  
            // 创建ArrayList
  10.  
            ArrayList list = new ArrayList();
  11.  
            // 将“”
  12.  
            list.add("1");
  13.  
            list.add("2");
  14.  
            list.add("3");
  15.  
            list.add("4");
  16.  
            // 将下面的元素添加到第1个位置
  17.  
            list.add(0, "5");
  18.  
            // 获取第1个元素
  19.  
            System.out.println("the first element is: "+ list.get(0));
  20.  
            // 删除“3”
  21.  
            list.remove("3");
  22.  
            // 获取ArrayList的大小
  23.  
            System.out.println("Arraylist size=: "+ list.size());
  24.  
            // 判断list中是否包含"3"
  25.  
            System.out.println("ArrayList contains 3 is: "+ list.contains(3));
  26.  
            // 设置第2个元素为10
  27.  
            list.set(1, "10");
  28.  
            // 通过Iterator遍历ArrayList
  29.  
            for(Iterator iter = list.iterator(); iter.hasNext(); ) {
  30.  
                System.out.println("next is: "+ iter.next());
  31.  
            }
  32.  
            // 将ArrayList转换为数组
  33.  
            String[] arr = (String[])list.toArray(new String[0]);
  34.  
            for (String str:arr)
  35.  
                System.out.println("str: "+ str);
  36.  
            // 清空ArrayList
  37.  
            list.clear();
  38.  
            // 判断ArrayList是否为空
  39.  
            System.out.println("ArrayList is empty: "+ list.isEmpty());
  40.  
        }
  41.  
    }
  42.  
    </span>
运行结果:
 
版权声明:本文为生命奇迹泉原创文章,转载请注明出处生命奇迹泉http://blog.csdn.net/shengmingqijiquan https://blog.csdn.net/shengmingqijiquan/article/details/52634640

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Spring Security OAuth2 SSO

下一篇:java并发编程与高并发解决方案