常用容器（Collection）实现类总结（一）——ArrayList

ArrayList简略说明：

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

（Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list.）

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。

（Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. ）

 

ArrayList优、缺点分析：

优点：

• 线性有序存储，可重复存储
• ArrayList是一种动态数组，首先在构造一个实例的时候，构造方法会给实例一个初始大小，当元素长度不够时，调用Arrays.copyOf方法，拷贝当前数组到一个新的长度更大的数组
• 查找快且方便，查找某数据时通过下标直接获取元素

缺点：

• 插入、增添、删除元素速率较低
• 线程不安全（Vector是线程安全的，但是效率不如ArrayList）

 

基本实现：

public class MyArrayList {
    private Object[] elementDate;
    
    private int size;
    
    public Object get(int index) {
        if(index<0 || index>=size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return elementDate[index];
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public int size() {
        return size;
    }
    
    public MyArrayList(){
        this(10);          //调用有参构造方法，初始化数组大小为10
    }
    public MyArrayList(int initialCapacity){
        if(initialCapacity<0){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        elementDate = new Object[initialCapacity];
    }
    
    public void add(Object obj) {
        if(size==elementDate.length) {
            Object[] newArrayList = new Object[size*2+1]; //当数组达到上限，创建新的数组对象
　　　　　　//System.arraycopy(elementDate, 0, newArrayList, 0, elementDate.length);  //使用arraycopy方法也没问题，代码更简洁
            for(int i=0; i<newArrayList.length; i++) {
                newArrayList[i] = elementDate[i];   //遍历旧数组元素，存入新数组
                elementDate = newArrayList;      //将新数组地址传递给旧数组
            }
        }
        elementDate[size++] = obj;
    }

 

对于remove方法的详细说明：

• remove方法可以根据索引值（index）或者指定对象删除元素：

      public void remove(int index) {
          rangeCheck(index);
          elementDate[index] = null;
          System.arraycopy(elementDate, index+1, elementDate, index, elementDate.length-(index+1));
          size--;
      }

  当出现索引越界时，调用方法rangeCheck，代码：

  public void rangeCheck(int index) {
          if(index < 0 || index >= this.size) {   
              try {
                  throw new Exception();
              }catch(Exception e) {
                  e.printStackTrace();
              }
          }
      }

   

  
  
• remove方法还有个重载（override）方法：

  public boolean remove(Object o) {
          if (o == null) {
              for (int index = 0; index < size; index++)
                  if (elementData[index] == null) {
                      fastRemove(index);             //fastRemove方法类似于索引删除方法
                      return true;
                  }
          } else {
              for (int index = 0; index < size; index++)
                  if (o.equals(elementData[index])) {   //此处用的equals方法，为对象的值比较
                      fastRemove(index);
                      return true;　　　　　　　　　　　　//这里return后返回boolean，所以只会删除第一次出现的对象　　　　　　　　
                  }
          }
          return false;
      }

   

• remove方法的测试结果：

      public static void main(String[] args) {
          ArrayList list = new ArrayList();
          list.add("aa");
          list.add("bb");
          list.add(new Date());
          list.add(new Date());
          list.remove(new Date());
          for(int i = 0; i < list.size(); i++) {
              System.out.println(list.get(i));
          }
      }