jdk学习笔记

最新推荐文章于 2025-12-19 15:39:34 发布

转载最新推荐文章于 2025-12-19 15:39:34 发布 · 101 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/2610056/blog/883003

文章标签：

#java #数据结构与算法

一、ArrayList分析

1、基类

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

可以总结为： ArrayList 继承了AbstractList 实现了 List 、 RondomAcess 、 cloneable 、 serializable 对于一般的容器都会实现cloneable 用于克隆实现serializable 实现序列化

2、变量

主要有4个变量，在了解这些变量之前我们需要知道一些基本信息，ArrayList 底层用的是数组实现的，初始的默认容量是10 ，

private static final int DEFAULT_CAPACITY = 10;//初始的默认容量

private static final Object[] EMPTY_ELEMENTDATA = {}; //空数组

private transient Object[] elementData;//ArrayList 中真正存数据的容器

private int size;//当前数组中的数据个数

3、构造函数

ArrayList中总共有三个构造函数，分别是有初始化容量的构造函数，没有参数的构造函数，带有集合参数的构造函数

(1) 从源码中我们可以看到这只是一个很简单的创建数组对象的过程，不过在创建对象之前需要对初始容量值判断是否<0

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);
    }
}

(2)无参的构造函数，这里我们需要注意的是虽然数组默认容量是10 ，但是无参的情况下数组的初始化实际是个空数组而不是创建大小为10的数组

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

(3)集合因为是对数组操作所以用的是Arrays.copyOf 进行复制和类型转换

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

4、增加

（1）增加一个数的操作，size记录当前数组中的数个数所以实际操作是在数组下标为size位置赋值，然后 size++ ,但是在这之前得判断size+1是否越界，也就是是否需要进行扩容，扩容我们下面再讲，该函数的返回值是Boolean类型

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

（2）在指定的下标增加一个数的操作。在这里我们需要注意一个函数就是System.arraycopy（）这个是ArrayList中常用的API，主要用于数组移位，原先的数存在elementData[]中，一共size个对象，现在我们需要在下标为index插入新对象就需要我们将下标[index ,size-1]范围的对象移位到[index+1,size]

操作是 System.arraycopy(elementData, index, elementData, index + 1,size - index);

（源数组，复制开始下标，目标数组，目标数组开始下标，复制对象的个数）

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

（3）增加一个集合的操作。首先将集合转换为数组，再判断假如该集合数目的对象是否需要扩容，再调用System.arraycopy函数将新数组中的数复制到elementData[]中

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

5、删除

（1）删除下标为index的对象，先判断index是否有效，然后是向前移一位复制，最后size下标位置赋值为null，返回删除的对象

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);
   // 这里可能会疑惑为什么是elementData(index)而不是elementData[index] 
   // 因为elementData(index)是ArrayList的一个内部函数，实际也是返回下标为index的对象。
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //当别人问我ArrayList中对什么印象最深刻那么就是这个了
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

（2）删除某个对象操作。实际上这是个遍历数组顺便比较的过程，分两个条件去遍历，当删除的对象是 null的情况可非null的情况下进行，从中我们可以看出实际上在遇到第一个符合条件的对象就返回了，所以这个操作并不删除完所有

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

（3) 删除一个集合的操作。

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

6、修改

(1) 对index下标处的对象赋值新的对象，首先判断index是否有限，然后对数组下标为index位置赋值，返回旧对象

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

7、查找

（1）查找下标为index 的对象，先判断 index是否有效，再返回下标为index的数组

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

8、扩容分析

上面我们在分析增加一个对象操作之前会调用 ensureCapacityInternal(size + 1) ，现在我们将沿着这条线去分析扩容的过程

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    //当当前数组为空时取默认容量与最小容量的最大值
    }

    ensureExplicitCapacity(minCapacity);
    //用来比较当前的数组长度和最小容量
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
    //当需要的最小容量大于当前数组的长度时需要进行扩容
        grow(minCapacity);
}

//扩容函数

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //这里可以看出扩容的容量是旧容量的1.5倍
    if (newCapacity - minCapacity < 0)
    //还要将1.5倍旧容量与最小需要的容量比较取较大值
        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) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
    //从这里可以看出数组能够允许的最大扩容大小为Integer.MAX_VALUE
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;

总结： ArrayList 底层用的是数组实现，默认初始化容量为10 ，扩容规则为旧数组长度的1.5倍与当前需要的最小容量的最大值，最常用的操作是Arrays.copyOf() 和 System.arraycopy()

9、复制数组两种方式的区别。

System.arraycopy()

int[] arr = {1,2,3,4,5};
 
int[] copied = new int[10];
System.arraycopy(arr, 0, copied, 1, 5);//5 is the length to copy
 
System.out.println(Arrays.toString(copied));

运行结果：

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 2, 3, 4, 5, 0, 0, 0, 0]

Arrays.copyof()

int[] copied = Arrays.copyOf(arr, 10); //10 the the length of the new array
System.out.println(Arrays.toString(copied));
 
copied = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(copied));

运行结果：

[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[1, 2, 3]

2、两者间的主要区别

两者的区别在于，Arrays.copyOf()不仅仅只是拷贝数组中的元素，在拷贝元素时，会创建一个新的数组对象。而System.arrayCopy只拷贝已经存在数组元素。

如果我们看过Arrays.copyOf()的源码就会知道，该方法的底层还是调用了System.arrayCopyOf()方法。

public static int[] copyOf(int[] original, int newLength) { 
   int[] copy = new int[newLength]; 
   System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); 
   return copy; 
}

10、ConcurrentModificationException

即当modCount != expectedModCount时，执行next()就会抛出ConcurrentModificationException
而什么时候会造成modCount != expectedModCount呢？
ArrayList.remove()方法，每执行一次都会modCount++，但不改变expectedModCount的值。expectedModCount的值是在构建迭代的时候初始为expectedModCount=modCount的。
所以构建迭代器后，用迭代器来add和remove就没有问题。因为它会在改变modCount的值之后，又把值赋给了expectedModCount，从而保证modCount=expectedModCount

public E next() {
    checkForComodification();
    try {
        int i = cursor;
        E next = get(i);
        lastRet = i;
        cursor = i + 1;
        return next;
    } catch (IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

每次循环next都会调用checkForComodification方法来判断

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

11、线程不安全

在上述例子中，可以体现出在 add，size 和 toString 的执行过程中出现了一个方法执行到一半而执行了另一个方法的情况，由此产生了输出不一致的问题。针对上述情况，继承 ArrayList 进行同步限制：

private static class SafeArrayList<T> extends ArrayList<T> {

    private static final Object lock = new Object();

    @Override

    public boolean add(T o) {

        synchronized (lock) {

            return super.add(o);

        }

    }

    @Override

    public String toString() {

        synchronized (lock) {

            return super.toString();

        }

    }

    @Override

    public int size() {

        synchronized (lock) {

            return super.size();

        }

    }

}

二、LinkedList分析

1、LinkedList是双向链表但不是循环的列表

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

2、内部维护size，first，last，支持双向遍历，链表增删操作时，注意维护好这三个值；

private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

3、循环linkedList，不能使用for循环，可以使用foreach和iteritor

Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

来算一下：按照前一半算应该是（1 + 0.5N） * 0.5N / 2，后一半算上即乘以2，应该是（1 + 0.5N） * 0.5N = 0.25N2 + 0.5N，忽略低阶项和首项系数，得出结论，LinikedList遍历的时间复杂度为O(N2)，N为LinkedList的容量

4、增强for循环的原理

for (Integer i : list) {
    System.out.print(i + ",");
}

第一种是普通的for循环遍历、第二种是使用迭代器进行遍历，第三种我们一般称之为增强for循环（for each）。

实现原理

可以看到，第三种形式是JAVA提供的语法糖，这里我们剖洗一下，这种增强for循环底层是如何实现的。

我们对以下代码进行反编译：

    for (Integer i : list) {
       System.out.println(i);
   }

反编译后：

    Integer i;
    for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){
        i = (Integer)iterator.next();        
    }

转载于:https://my.oschina.net/u/2610056/blog/883003