Java之ArrayList

1.ArrayList的简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

1. ArrayList是以泛型方式实现的，使用时必须要先实例化
2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.ArrayList使用

2.1ArrayList的构造

我们发现在对ArrayList实例化时，有三种实例化方法，即ArrayList底部有三种构造方法

2.1.1 ArrayList() 无参构造

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

2.1.2 ArrayList(Collection<? extends E> c) 利用其他 Collection 构建 ArrayList

   public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

2.1.3ArrayList(int initialCapacity)|指定顺序表初始容量

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


private static final Object[] EMPTY_ELEMENTDATA = {};

2.2ArrayList常见操作

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List < E > subList(int fromIndex, int toIndex)	截取部分 list

2.2.1boolean addAll(Collection<? extends E> c) 尾插 c 中的元素

public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        List<Integer> list1=new ArrayList<>();
        list1.add(5);
        list.addAll(list1);
        System.out.println(list);
    }

2.2.2 boolean remove(Object o) 删除遇到的第一个 o

    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(4);
        list.add(4);
        list.remove(4);//只能删除4这个元素，并不能指定删除第几个元素
        list.remove(new Integer(4));//使用该方法可以指定删除4这个元素，但该方法已过时
        System.out.println(list);
    }

2.2.3 List < E > subList(int fromIndex, int toIndex) 截取部分 list

public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);
        List<Integer> list1=list.subList(1,3);
        System.out.println(list1);
        list1.remove(1);
        System.out.println(list1);
        System.out.println(list);
    }

总结：sublist 截取字符串后不会产生新的对象，而是记录截取部分的地址，并获得权限对地址范围内的字符串修改。

2.3ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //1.使用下标+for循环遍历
            for (int i = 0; i < list.size() ; i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        
         //2.使用foreach循环遍历
        for (Integer integer:list) {
            System.out.print(integer+" ");
        }
        System.out.println();
        //3.使用迭代器遍历
        System.out.println("======迭代器遍历1========");
        Iterator<Integer> it =list.listIterator();{
            while(it.hasNext()){
                System.out.print(it.next());
            }
        }
        System.out.println();
        
        System.out.println("======迭代器遍历2========");
        ListIterator<Integer> lit=list.listIterator();
        while (lit.hasNext()){
            System.out.print(lit.next());
        }
        System.out.println();
         
        System.out.println("======迭代器遍历3========");
        ListIterator <Integer> listPrev= list.listIterator(list.size());//从index位置逆序打印
        while(listPrev.hasPrevious()){
            System.out.print(listPrev.previous());
        }
}