源码阅读——ArrayList

1.size和capacity

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

size是ArrayList的理论大小，但实际上ArrayList内部的实际大小应该是看capacity，因为它在add()的时候其实会把size+1和目前的容量做一个比较，然后决定是否扩容（扩旧capacity的1.5倍）。所以在get()和set()操作的时候会调用rangeCheck()函数，它只检查index和size的关系，不检查index和0的关系，因为index在<0和>capacity的时候都会报错，而size是理论大小，如果list中只存了2个元素，理论上不能查找第3个元素。

2.ensureCpacity和ensureCapacityInternal的区别

//给用户使用，确保容量，指定的容量要大于默认容量
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0
            : DEFAULT_CAPACITY;
    if (minCapacity > minExpand) {++++++++++++++
        ensureExplicitCapacity(minCapacity);
    }
}

//给类内部使用，确保容量,用于内部优化,保证空间资源不被浪费, 主要用于add()方法
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity= Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

 

3.对象的序列化

对象中的被static和transient的字段都不可以被序列化。静态变量放在方法区，为类的状态，不是对象的状态；transient则是专门用来说明无需序列化的字段的修饰符。

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

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

 

4.sublist

根据文档说明，这个是返回目前存在的ArrayList中的一个部分视图，它可以做任何Collections中支持的方法，对它所进行的操作即为操作实际的list。它的意义之一是任何时候对列表的操作可以通过传递sublist视图而并非整个list来操作。常见的用法举例：

要移除list中的部分范围元素，可以 list.subList(from, to).clear();。

    public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }

5.函数式接口

由下述可见，该方法是一个自定义遍历输出内容的遍历方法。

    @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

在foreach里面看到了一个Consumer<T>，点进去一看：

函数式接口Consumer<T>：

 

Consumer <T>是java.util.function包中Java 8中引入的内置函数接口。消费者可以在需要消费对象的所有环境中使用，即。作为输入，对对象执行一些操作而不返回任何结果。这种操作的常见示例是打印，将对象作为打印功能的输入并打印对象的值。

好处：

在将对象作为输入并对其执行操作的所有场景中，可以使用内置功能接口Consumer <T>，而无需每次都定义新的功能接口。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

示例：

        Consumer<Integer> consumer = i->System.out.println(" I can print that  "+ i);
        for(int i = 0;i < 5;i++){
            consumer.accept(i);
        }

输出：

 I can print that  0
 I can print that  1
 I can print that  2
 I can print that  3
 I can print that  4

其具体定义和内容在文档中可查看，对于它的使用，还有优缺点介绍，在

https://www.javabrahman.com/java-8/java-8-java-util-function-consumer-tutorial-with-examples/

中说得很清楚。