JavaEE基础知识

---

ArrayList

一、ArrayList基本使用方法

public static void main(String[] args) {
		/**
		 * 使用ArrayList常用方法
		 */

		//创建集合对象 - 泛型规定该集合只能存储String类型的数据
		ArrayList<String> 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(2, "北条麻衣");

		//添加集合
		//		ArrayList<String> newList1 = new ArrayList<>();
		//		Collections.addAll(newList1, "aaa","bbb","ccc","ddd");//使用集合工具类批量添加元素
		//		list.addAll(newList1);//把newList1集合中所有的元素添加到list集合中

		//在指定下标上添加集合
		ArrayList<String> newList1 = new ArrayList<>();
		Collections.addAll(newList1, "aaa","bbb","ccc","ddd");//使用集合工具类批量添加元素
		list.addAll(2, newList1);//在指定下标把newList1集合中所有的元素添加到list集合中

		//删除
		list.remove(4);//根据下标删除元素
		list.remove("ddd");//根据元素删除元素
		list.removeIf(new Predicate<String>() {//根据条件删除元素
			@Override
			public boolean test(String t) {
				if(t.length() >= 5){
					return true;
				}
				return false;
			}
		});

		//删除交集
		ArrayList<String> newList2 = new ArrayList<>();
		Collections.addAll(newList2, "aaa","xxx","yyy");
		list.removeAll(newList2);

		//设置指定下标上的元素
		list.set(1, "爱田奈奈");

		//保留交集
		ArrayList<String> newList3 = new ArrayList<>();
		Collections.addAll(newList3, "bbb","北条麻衣","yyy","杨晨","陈希");
		list.retainAll(newList3);

		//获取指定下标上的元素
		System.out.println("获取指定下标上的元素：" + list.get(1));

		//获取长度
		System.out.println("获取集合中元素的个数：" + list.size());

		//清空集合中所有的元素
		//list.clear();

		System.out.println("查询集合中是否包含某个元素：" + list.contains("aaa"));
		System.out.println("查询该元素在集合中的下标：" + list.indexOf("aaa"));
		System.out.println("判断该集合中是否没有元素：" + list.isEmpty());//没有元素-true 有元素-false

		//获取指定下标区间的元素
		List<String> newList4 = list.subList(1, 3);
		System.out.println(newList4);
		System.out.println(Arrays.toString(newList4.toArray()));//集合->数组->字符串
		
		System.out.println("---------------------------");

		//遍历集合

		//1.for循环
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("---------------------------");
		
		//2.foreach
		for (String e : list) {
			System.out.println(e);
		}
		
		System.out.println("---------------------------");
		
		//3.Iterator
		Iterator<String> it = list.iterator();
		while(it.hasNext()){//判断是否有可迭代的数据
			String next = it.next();//返回下一个数据
			System.out.println(next);
		}
		
		System.out.println("---------------------------");
		
		//4.ListIterator
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){//判断是否有可迭代的数据
			String next = listIterator.next();//返回下一个数据
			System.out.println(next);
		}
	}

二、源码分析

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    
    //用于空实例的共享空数组实例。
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //存放数据的容器
    private transient Object[] elementData;
    //元素个数
    private int size;
    //默认初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    //数组的最大值
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
    
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0){
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
        this.elementData = new Object[initialCapacity];
    }
    
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        //判断是否是第一次添加元素
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
		//判断扩容的长度一定要比数组的长度要更大，才会扩容
       
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        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);
    }
    
    private static int hugeCapacity(int minCapacity) {//2147483640
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
}

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>{
    //操作数
    protected transient int modCount = 0;
    
    protected AbstractList() {
    }	
}

1. ArrayList的数据结构是什么？

   Object类型的一维数组

2. ArrayList使用无参构造创建对象，数组长度是多少？

   数组长度为0

3. ArrayList中数组默认长度是多少？

   10

4. ArrayList中数组最大长度是多少？

   Integer.MAX_VALUE-8

5. ArrayList中数组最大长度为什么要-8？

   因为-8的空间用于存储数组的基本信息

6. ArrayList的扩容机制/扩容倍数？

   原数组长度的1.5倍

7. ArrayList无限扩容后，数组最大值可以到多少？

   Integer.MAX_VALUE

这里有推荐一篇关于ArrayLsit的文章

https://blog.csdn.net/qq_42080839/article/details/108126688