JAVA集合之Arraylist使用方法

Posted 2023-02-02

Java的集合的集成体系如下

ArrayList实现List接口，具有有序和线程不安全，高效的特点（相比vector）。

1.ArrayList的常用方法

public class ArrayLists 
    public static void main(String[] args) 
        //ArrayList的装箱
        ArrayList arrayList=new ArrayList();
        arrayList.add(1);
        arrayList.add(true);
        arrayList.add("tom");
        System.out.println(arrayList);
        //按索引的顺序移除
        arrayList.remove(0);
        //遍历输出arraylist
        System.out.println(arrayList);
        //查看是否含有tom
        System.out.println(arrayList.contains("tom"));
        System.out.println(arrayList);
        //查看是否为空
        System.out.println(arrayList.isEmpty());
        //清除list
        //arrayList.clear();
        System.out.println(arrayList);
        ArrayList arrayList1=new ArrayList();
        //arrayList1.add(1);
        arrayList1.add(true);
        arrayList1.add("tom");
        //查看arraylist是否包含arrylist1的全部元素
        System.out.println(arrayList.containsAll((arrayList1)));
        //删除arraylist包含arrylist1的全部元素
        System.out.println(arrayList.removeAll(arrayList1));
        System.out.println(arrayList);


    

二 ArrayList源码解读

ArrayList的扩容机制

ArrayList的初始化的长度大小为10，每次添加前判断是否还有空间，若不足，则扩充为当前容量的1.5倍，使用debug代码，将断点打在ArrayList

public class ArraylistSourceCode 
    public static void main(String[] args) 
        ArrayList list=new ArrayList();
        list.add("张");
        list.add("王");
        list.add("周");
        list.add("李");
        list.add("张");
        list.add("王");
        list.add("周");
        list.add("李");
        list.add("张");
        list.add("王");
        list.add("周");
        list.add("李");

    

//ArrayList维护一个Object数组，modcount计数，初始化定义数组长度为10
 public ArrayList() 
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    

//计数+1
private void ensureExplicitCapacity(int minCapacity) 
        modCount++;
        // 如果队列的容量小于 minCapacity是队列的当前的数量
        //判断是否越界
        if (minCapacity - elementData.length > 0)
        //增加空间
            grow(minCapacity);
    

/**
*arraylist第一次插入数据和空间不足都会执行此方法
*  */
    private void grow(int minCapacity) 
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //容量直接扩为1.5倍
        //>>表示右移一位 /2
        //<<表示左移一位   *二
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //将队列重新复制一遍，并重新设置容量
        elementData = Arrays.copyOf(elementData, newCapacity);
    

ArrayList线程不安全以及解决办法

public class ListTest 
    public static void main(String[] args) 
        //这是个普通list集合添加的操作，如果不加限制，在多线程的环境下会出现 java.util.ConcurrentModificationException
        List<String> alist = new ArrayList<>();
        for(int i=0;i<=10;i++)

            new Thread(()->
                alist.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(alist);
            ).start();
        
    

官方说法是不允许一个线程在修改集合时，另外的线程对其遍读，否则会抛出异常

//修改的方法如下，使用vector，vector线程安全如果排除contains方法和remove方法不具有原子性的话，因为集合添加会有这个问题
 List<String> alist = new Vector<>(); //jdk1.0的东西
  for(int i=0;i<=10;i++)

            new Thread(()->
                alist.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(alist);
            ).start();
        

没有问题

//使用synchonrizedlist
List<String> alist =  Collections.synchronizedList(new ArrayList<>()); //一般的解决方法
   for(int i=0;i<=10;i++)

            new Thread(()->
                alist.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(alist);
            ).start();
        

可以实现

//synchronizedList的源码如下 ==》都添加synchonrized
//除了遍历的listIterator方法需要编程人员添加synchonrized
static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> 
    private static final long serialVersionUID = -7754090372962971524L;

    final List<E> list;

    SynchronizedList(List<E> list) 
        super(list);
        this.list = list;
    
    SynchronizedList(List<E> list, Object mutex) 
        super(list, mutex);
        this.list = list;
    

    public boolean equals(Object o) 
        if (this == o)
            return true;
        synchronized (mutex) return list.equals(o);
    
    public int hashCode() 
        synchronized (mutex) return list.hashCode();
    

    public E get(int index) 
        synchronized (mutex) return list.get(index);
    
    public E set(int index, E element) 
        synchronized (mutex) return list.set(index, element);
    
    public void add(int index, E element) 
        synchronized (mutex) list.add(index, element);
    
    public E remove(int index) 
        synchronized (mutex) return list.remove(index);
    

    public int indexOf(Object o) 
        synchronized (mutex) return list.indexOf(o);
    
    public int lastIndexOf(Object o) 
        synchronized (mutex) return list.lastIndexOf(o);
    

    public boolean addAll(int index, Collection<? extends E> c) 
        synchronized (mutex) return list.addAll(index, c);
    

    public ListIterator<E> listIterator() 
        return list.listIterator(); // Must be manually synched by user
    

    public ListIterator<E> listIterator(int index) 
        return list.listIterator(index); // Must be manually synched by user
    

    public List<E> subList(int fromIndex, int toIndex) 
        synchronized (mutex) 
            return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                        mutex);
        
    

    @Override
    public void replaceAll(UnaryOperator<E> operator) 
        synchronized (mutex) list.replaceAll(operator);
    
    @Override
    public void sort(Comparator<? super E> c) 
        synchronized (mutex) list.sort(c);
    
    ... ...

终极方案

/*****
         * 读写分离的思想
         * 添加容器时，复制容器，往容器添加数据后，使容器指向新的容器，简单来说，类似快照，在用快照替代了原始的
         * **/
        List<String> alist = new CopyOnWriteArrayList<>();
        for(int i=0;i<=10;i++)

            new Thread(()->
                alist.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(alist);
            ).start();
        

参考链接
​​​ConcurrentModificationException​​

​​CopyOnWriteArrayList​​