ArrayList的一些方法

ArrayList，善于随机访问元素，但插入和删除元素较慢。且ArrayList不是线程安全的，一般在单线程中使用

 

一：三种构造方法

1. 可以构造一个默认初始容量为10的空列表
2. 构造一个指定初始容量的空列表
3. 构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的​​​​​​

//1-----------------------
public ArrayList() {
        this(10);
        //调用ArrayList(10) 默认初始化一个大小为10的object数组。
    }

//2-------------------------
public ArrayList(int initialCapacity) {    
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
         //如果用户初始化大小小于0抛异常，否则新建一个用户初始值大小的object数组。                                      
        this.elementData = new Object[initialCapacity];
    } 

//3--------------------------
public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // 当c.toArray返回的不是object类型的数组时，进行下面转化。
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

 

 

二：存储数据

检查指定位置是否大于等于列表长度，如果大于则抛出异常

public void rangeCheck(int index) {
		if(index<0||index>=size) {
			try {
				throw new Exception();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
	

set(替换指定位置上的元素，并且返回替换之前的指定位置的元素 
其中rangeCheck(index)方法是检查指定位置是否大于等于列表长度，如果大于则抛出异常)

public Object set(int index,Object obj) {
		//替换指定位置上的元素，并且返回替换之前的指定位置的元素
		rangeCheck(index);//检查指定位置是否大于等于列表长度
		Object oldvalue= elementDate[index];
		elementDate[index]=obj;
		return oldvalue;
		
	}

add(01)

public void add(Object obj) {
		//数组的扩容和数组的拷贝
		
		if(size==elementDate.length) {
			Object[] newArray=new Object[size*2+1];
			System.arraycopy(elementDate, 0, newArray, 0, elementDate.length);
			
			Object[] newnewArray = null;
			elementDate=newnewArray;
		}
		elementDate[size++]=obj;
	}

add(02){System.arraycop()方法：将指定位置以及后续的元素向后移动一位。}

 

public void add(int index,Object obj) {
		//将元素插入到列表中指定的位置 
		//如果当前位置有元素，则向后移动当前位置的元素以及所有后续的元素（将其索引加+1） 
		rangeCheck(index);
		System.arraycopy(elementDate, index, elementDate, index+1, size-index);
		elementDate[index]=obj;
		size++;
		

remove(int index)

remove(Object o)

第一种：删除指定位置的元素

public void remove(int index) {
		rangeCheck(index);
		//删除指定对象的元素
		int numMoved=size-index-1;
		if(numMoved>0) 
			System.arraycopy(elementDate, index+1, elementDate, index, numMoved);
		elementDate[--size]=null;
		
	}

第二种：移除此列表首次出现的指定元素（如果存在），ArrayList可以存放重复的元素。

public void remove(Object obj) {
		//删除重复的数组
		for(int i=0;i<size;i++) {
			if(get(i).equals(obj)) {  //注意：底层调用的是equals方法 不是==
				remove(i);
			}
		}
	}

查找

正向查找

// 正向查找，返回元素的索引值
    public int indexOf(Object o) {
     
		if (o == null) {
            for (int i = 0; i < size; i++)
            if (elementDate[i]==null)
                return i;
            } else {
                for (int i = 0; i < size; i++)
                if (o.equals(elementDate[i]))
                    return i;
            }
            return -1;
        }

反向查找

// 反向查找，返回元素的索引值
        public int lastIndexOf1(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
            if (elementDate[i]==null)
                return i;
        } else {
            for (int i = size-1; i >= 0; i--)
            if (o.equals(elementDate[i]))
                return i;
        }
        return -1;
    }

// 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
            if (elementDate[i]==null)
                return i;
        } else {
            for (int i = size-1; i >= 0; i--)
            if (o.equals(elementDate[i]))
                return i;
        }
        return -1;
    }