工作之余第二篇（看源码自己实现ArrayList和LinkList）

阅读原文时间：2023年07月09日阅读：4

首先看构造器，构造器有三种，一种直接给定初始长度的，如下代码

public ArrayList(int initialCapacity) {
if (initialCapacity > 0) { //判断长度是否大于0 如果大于0 则直接将长度给他
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) { //如果等于0，定义一个空数组实例
this.elementData = EMPTY_ELEMENTDATA;
} else { //否则就抛出异常为负数
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}

第二种构造函数是不给定长度的，如下代码

public ArrayList() { //直接给定一个空数组实例 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

第三种构造函数，直接包含指定元素的构造器，放一个集合，如下

public ArrayList(Collection c) {
elementData = c.toArray(); //集合直接转换为数组 if ((size = elementData.length) != 0) { //在数组长度不为0的情况下 // c.toArray might (incorrectly) not return Object[] (see 6260652) 在c.toArray之后返回的可能不是一个数组是需要进行下一步操作
if (elementData.getClass() != Object[].class)
　　　　　　　　　　//通过copyOf将其转换为数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.如果为0只直接替换一个空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}

然后就是开始看添加了。

public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!! 标红的方式是要确定定义数组的容量是否足够，接下来有分析
elementData[size++] = e; //size是定义的全局变量没进行一次赋值 size++之后会改变哟，每增加一个值的时候就加1，第一次赋值是size是0，赋值完成后加1，第二次size就是1了。 return true;
}

private void ensureCapacityInternal(int minCapacity) { //这个minCapacity代表上边标红方法中的size+1,这个需要记住哟
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); //接下来先介绍红色方法，介绍完后在介绍绿色方法。
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //这个就是一个空数组实例

private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //判断如果是一个空数组实例的话就拿数组默认长度值（10）来和size+1的值作比较，谁大取谁 return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity; //不为空则直接返回size+1的值
}

接下来介绍绿色方法了。

private void ensureExplicitCapacity(int minCapacity) {
modCount++; //修改次数，具体用途还不清楚，下边有解释 // overflow-conscious code
if (minCapacity - elementData.length > 0) //判断size+1是否大于数组缓冲区的长度，如果大于则进行扩容了
grow(minCapacity); //grow这个方法就要开始扩容了
}

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; //首先把最初的数组长度暂存 int newCapacity = oldCapacity + (oldCapacity >> 1); //最初的数组长度正常一半的长度赋给newCapacity if (newCapacity - minCapacity < 0) //再次进行判断如果长度还是不够 newCapacity = minCapacity; //那么就直接将长度给size+1这个值 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 final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //这个值就是数组默认定义的最大值，下边有详细解释

private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? //检查是否超出数组最大值，如果超出了就将最大值给他，没有超出则给减去8之后的最大值。
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

以上就是添加方法了。带参数的其他添加跟这个类似，不过添加了下标验证。如下

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

addAll同上，先判断是否扩容以及扩容的大小，然后进行arraycopy

public boolean addAll(Collection 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;
}

获取元素：

public E get(int index) {
rangeCheck(index); //先检查下标是否在数组下标范围内，然后就取值 return elementData(index);
}

private void rangeCheck(int index) { //下标超出报异常 if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

删除元素：

public E remove(int index) {
rangeCheck(index); //检查下标

    modCount++;  
    E oldValue = elementData(index);  **//先将原来的数组保存** int numMoved = size - index - 1;  **//需要移动的值** if (numMoved > 0)  
        System.arraycopy(elementData, index+1, elementData, index,  
                         numMoved);  
    elementData\[--size\] = null; // clear to let GC do its work

    return oldValue;  
}

以下是自己实现的代码，比较粗糙

package com.interact.test.webService;

import java.util.Arrays;

public class ArrayListTest {

Object \[\] arr = new Object\[default\_size\];  
private static int size = 0;  
private static int default\_size = 10;

public int getSize(){  
    return size;  
}

//获取元素  
public Object getIndex(int index){  
    //需要校验index的值，是否大于0并且小于最大长度  
    if(index >= 0 && index < arr.length){  
        return arr\[index\];  
    }else{  
        return "数组下标越界";  
    }  
}

//添加元素  
public void add(Object o){  
    if(size >= default\_size){  //默认长度不够的时候 进行扩容  
        default\_size += default\_size/2;  //扩容到原来长度的1.5倍，就是就是加上原来长度的一半  
    }  
    arr = Arrays.copyOf(arr,default\_size);  //扩容之后通过底层的复制数组的方法，将之前保存的数据放到扩容之后的数组中  
    arr\[size++\] = o;  
}

public void remove(int index){  
    Object \[\] temp = new Object\[size-1\];  
    if(index >= 0 && index <= size){  //先进行校验  
        for (int i = 0; i < index; i++) {  
            temp\[i\] = arr\[i\];  
        }  
        for (int i = index + 1; i < size ; i++) {  
            temp\[i-1\] = arr\[i\];  
        }  
    }else{  
        System.out.println("下标越界");  
    }  
    arr = Arrays.copyOf(temp,size-1);  
    size--;  
}

public static void main(String \[\] args){  
    ArrayListTest arrayListTest = new ArrayListTest();  
    for (int i = 0; i < 16; i++) {  
        arrayListTest.add(i);  
    }  
    arrayListTest.remove(3);  
    for (int i = 0; i < arrayListTest.getSize(); i++) {  
        System.out.println(arrayListTest.getIndex(i));  
    }  
}

}

native关键字的作用

告诉编译器调用的方法是外部定义的，一般是指C写的底层方法。主要意思是java调用java以外的方法的标示。

毫秒以下的单位以及进度

微秒，纳秒，皮秒跟毫秒一样进度为1000,1000毫秒=1秒，1000微秒=1毫秒，1000皮秒=1微秒。

OutOfMemoryError

内存溢出，给定长度满足不了实际长度时就会导致内存溢出。

为什么有时候一下异常throw出去了，但是却没有在函数头部声明

异常分两种，Checked异常和Runtime异常，在使用checked异常时需要在函数头部声明，而Runtime异常则不需要，主要当发生非运行时异常你就需要try catch进行捕获，告诉你哪里出问题了，从而进行修改。而运行时异常，则是在运行过程中才可能出现的异常，编辑器无法帮助你定位，所以即使你声明throw，然后再由调用者try catch捕获也没有用，所以就不再需要在函数头部就行声明。

最大数组大小定义为Integer.MAX_VALUE - 8，减去8的原因

因为要存储2^31 = 2,147,483,648这些长度的数组需要8bytes，所以给定最大长度为Integer.MAX_VALUE - 8。

java中的>> <<的作用

位运算符，转换为二进制，左位移运算符，右位移运算符，三个>>>的跟两个的一样。

java的访问修饰符

public 同类同包不同包的子类不同包的非子类可以使用

protectd 同类同包不同包的子类可以使用

default 同类同包中可以使用

private 只有同类中可以使用

modCount

修改次数，找了找资料，理解之后的大概意思就是，ArrayList不是线程安全的，使用迭代器时，其他线程可能会同时对其进行修改，这时候就会报异常，ConcurrentModificationException，也就是所谓fail-fast策略。而这个策略实现的方式就是，modCount每次修改就会加1，而每次初始化就将这个值暂存起来，放到expectedModCount这个变量中，在迭代过程中会进行比较，如果一样则没问题，不相同则报异常。注意到 modCount 声明为 volatile，保证线程之间修改的可见性。

volatile

编译器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份，并且防止拿到的数据是编译器优化之后的代码。其实就是拿到最真实实时的数据。

泛型的实现原理

主要是类型擦除，在编译成字节码文件时，字节码文件是不包含泛型中的类型信息的，会将类型擦除掉。

还需要理解，参考链接：https://blog.csdn.net/aoxida/article/details/50774459

linkList的实现（已完善）

package com.interact.test.webService;

public class LinkListTest {

private static int size = 0;  
private static Node first;  
private static Node last;  
private static Node\[\] objects = new Node\[100\];  //用来存储数据

//定义一个静态内部类  
private static class Node {  
    private String current;  
    private Node next;  
    private Node prev;

    Node(String current, Node next, Node prev) {  
        this.current = current;  
        this.next = next;  
        this.prev = prev;  
    }  
}

public void add(Object o) {  
    Node temp = last;  
    Node newNode = new Node(o.toString(), null, temp);  
    last = newNode;  
    if (temp == null) {  
        first = newNode;  
    } else {  
        temp.next = newNode;  
    }  
    objects\[size++\] = newNode;  //用数组存数据是否有问题  
}

public Object getIndex(int index) {  //可能有问题  
    if(index < (size >> 1)){  //如果index小于总长度的一半 则从第一个开始找，从前往后推  
        Node node = first;  
        for (int i = 0; i < index; i++) {  
            node = objects\[i\].next;  
        }  
        return node.current;  
    }else{ //如果index大于总长度的一半 则从最后一个开始找，从后往前推  
        Node node = last;  
        for (int i = size-1; i > index; i--) {  //这里需要注意 当寻找的下标大于总长度一半的时候 不再是从0开始，而且i开始逐渐减去1  
            node = objects\[i\].prev;  
        }  
        return node.current;  
    }  
}

public void linkFirst(String element){  //将该值作为第一个节点  
    Node node = first;  //先将当前第一个值暂时保存  
    Node newNode = new Node(element,node,null);  //通过Node构造器获取一个新的节点  
    first = newNode; //然后将新的节点给全局变量第一个节点first  
    if(node == null){  //如果node是空的，也就说明当前first是空的，说明当前linkList没有值  
        last = newNode;  //此时第一个节点是刚创建的新节点，最后一个也是这个新节点  
    }else{  
        node.prev = newNode;  //如果不是空的，那么当前第一个节点的前一个节点应该是null，此时就需要将这个新的节点设置为之前第一个节点的前节点  
    }  
    size++;  
}

public void remove(Object o) {  
    for (int i = 0; i < size; i++) {  
        if (objects\[i\].current.equals(o)) {  
            final Node prev = objects\[i\].prev;  //前一个节点  
            final Node next = objects\[i\].next;

            prev.next = next;  //将前一个节点的下一个节点设置成当前节点的下一个节点，从而达到连接后面节点的效果  
            next.prev = prev;  //同样将要移除节点的前一个节点设置为移除节点的前一个节点。

            objects\[i\].current = null; //进行垃圾回收  
            objects\[i\] = null;  
            size--;

        }  
    }  
}

public static void main(String\[\] args) {  
    LinkListTest listTest = new LinkListTest();  
    listTest.add("111");  
    listTest.add("222");  
    listTest.add("333");  
    listTest.add("444");  
    listTest.add("555");  
    listTest.add("666");  
    System.out.println(listTest.getIndex(1));  
    System.out.println(listTest.getIndex(4));  
    listTest.remove("222");  
    listTest.linkFirst("999");  
    System.out.println(listTest.getIndex(1));  
    System.out.println(listTest.getIndex(0));  
}

}

vue组件：主要是拆分代码，减少vue实例的代码量，方便ui的重用。

　　　　　vue创建组件的方式，Vue.component(组件名称，组件构造器)，跟创建Vue对象相似，同样有data、methods、watch等，但是组件的data必须是一个函数，而且没有el获取根实例。

如下代码：

还有通过extend的几种方式来实现的