常见容器的重要知识点与多线程下的安全问题

@SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();           // 检查结构是否改变，改变抛出异常
        int i = cursor;         // 获取当前遍历的索引值
        if (i >= size)          // 如果超过了数组的容量就抛异常
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;         // 索引加1
        return (E) elementData[lastRet = i];       // 返回当前索引对应的值
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;        // 可以看到每次添加值都会改变 size
        return true;
    }

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // 存储容器数据的数组

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

 public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

public static void main(String[] args){
        ArrayList<Object> list = new ArrayList<>();
        for(int i = 1; i <= 30;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            }).start();
        }
    }

　　private transient volatile Object[] array;  //  虽然使用 volatile 修饰，但是只是对于这个数组是实时获取到的，数组内的元素还是不能保证可见性


   public E get(int index) {
        return get(getArray(), index);      // 读操作没有加锁，比前面两种方式效率高
    }


   public boolean add(E e) {
        final ReentrantLock lock = this.lock;       // 使用 lock 锁
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);    // 创建新的数组对象
            newElements[len] = e;       // 添加新值
            setArray(newElements);      // 替换数组属性的值
            return true;
        } finally {
            lock.unlock();
        }
    }

static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

 class Student implements Comparable<Student>{
    int id;
    int age;
    int length;
    
    public Student(int id, int age, int length) {
        super();
        this.id = id;
        this.age = age;
        this.length = length;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    @Override
    public String toString() {
        return "Student [>;
    }
    @Override
    public int compareTo(Student o) {
        // 优先按年龄从小到大排序，如果年龄相等就按id从小到大排序
        if(this.age>o.age) {
            return 1;
        }
        else if(this.age<o.age){
            return -1;
        }
        else if(this.id>o.id) {
            return 1;
        }
        else{
            return 0;
        }
    }
 }