2020年9月23日 Vector、ArrayList、Stack、LinkedList源码跟踪

package com.atguigu.test03;

import java.util.Vector;

import org.junit.Test;

/*
 * Vector源码跟踪：
 * （1）new Vector()：初始化长度为10的数组，默认增量是0
 * （2）add(E e)：
 * 默认扩容为原来的2倍
 * 如果你手动指定了capacityIncrement的值，那么可以按照你指定增量进行扩容。
 * （3）add(index,e)：
 * ①考虑扩容
 * ②移动元素
 * ③添加元素
 * ④元素个数增加
 * （4）remove(index)：
 * ①计算要移动元素的个数
 * ②如果需要移动，调用System.arraycopy方法进行移动
 * ③elementData[--elementCount] = null;
 * （5）remove(Object obj)
 * ①查找obj的下标
 * ②如果不是-1就调用remove(index)进行删除
 * （6）indexOf(Object obj)
 * 对obj分情况讨论：（1）是null（2）不是null
 */
public class TestVector {
    @Test
    public void test1(){
        Vector v = new Vector();
        
        v.add("1");
        v.add(0, "2");//[0]
        
        v.remove(1);
        
        v.remove("1");
        
        int index = v.indexOf("1");
    }
}

package com.atguigu.test03;

import java.util.ArrayList;

/*
 * ArrayList动态数组：源码跟踪
 * (1)new ArrayList()：
 * JDK1.8版本：发现内部初始化为了一个长度为0的空数组  DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * JDK1.7版本：也是初始化为长度为0的空数组  EMPTY_ELEMENTDATA;    
 * JDK1.6版本：初始化为长度为10的数组
 * 
 * 为什么要初始化为空数组呢？
 * 因为开发中，很多时候创建了ArrayList的对象，但是没有装元素，这个时候的话，如果初始化为10的数组，就浪费空间了。
 * 
 * (2)add(Object e）
 *JDK1.8 第一次添加元素，扩容为长度为10的数组
 *JDK1.8  如果不够了，再扩容为1.5倍
 *
 *
 */
@SuppressWarnings("all")
public class TestArrayList {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("chai");
        list.add("lin");
        
        ArrayList all = getAll(list);
        System.out.println(all);
    }
    
    /*
     * 这个方法，是一个查询的方法，把查询结果返回
     * 例如：查询list中，字符串长度超过5个字符串
     */
    public static ArrayList getAll(ArrayList list){
        //....
        ArrayList result = new ArrayList();
        for (Object object : list) {
            String str= (String) object;
            if(str.length()>5){
                result.add(str);
            }
        }
        return result;
    }
}

package com.atguigu.test03;

import java.util.Stack;

/*
 * Stack：栈   源码分析
 * 
 * （1）peek
 * 返回size-1位置的元素
 * （2）pop
 * ①先peek()返回栈顶元素
 * ②删除size-1位置的元素
 * （3）push：等价于add
 * 把元素添加到[size++]位置
 */
public class TestStack {
    public static void main(String[] args) {
        Stack s  = new Stack();
        s.push(1);
        s.peek();
        s.pop();
    }
}

package com.atguigu.test03;

import java.util.LinkedList;

/*
 * LinkedList：源码分析
 * (1)new LinkedList()：什么也没干，没有创建结点
 * (2)add(e)
 *     void linkLast(E e) {
        final Node<E> l = last;
        
        //新结点的pre是刚刚的最后一个结点
        //新结点的下一个结点是null，没有
        final Node<E> newNode = new Node<>(l, e, null);
        
        //新结点成为了最后一个结点
        last = newNode;
        
        //如果之前的最后一个结点是null，表示刚才链表是空的
        if (l == null)
            //新结点同时也是第一个结点
            first = newNode;
        else
            //如果刚才不是空的，原来的最后一个结点的next指向新结点
            l.next = newNode;
        size++;//元素个数增加
        modCount++;
    }
 *
 * （3）删除
E unlink(Node<E> x) {
        //x是要被删除的结点
        final E element = x.item;//被删除的结点的数据
        final Node<E> next = x.next;//被删除结点的下一个结点
        final Node<E> prev = x.prev;//被删除结点的上一个结点

        if (prev == null) {//说明被删除结点是第一个结点
            first = next;//被删除结点的下一个结点称为了第一个结点
        } else {//被删除结点不是第一个结点
            prev.next = next;//被删除结点的上一个结点的next指向被删除结点的下一个结点
            x.prev = null;//把被删除结点与上一个结点断开
        }

        if (next == null) {//被删除结点是最后一个结点
            last = prev;//被删除结点的上一个结点成为了最后一个结点
        } else {//被删除结点不是最后一个结点
            next.prev = prev;//被删除结点的下一个结点的prev指向被删除结点的上一个结点
            x.next = null;//把被删除结点与下一个结点断开
        }

        x.item = null;//把被删除结点的数据清空
        /*
        x.prev = null;
        x.next = null;
        x.next = null;
        x彻底称为垃圾
        *  /
        size--;//元素个数减少
        modCount++;
        return element;
    }
 */
public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        
        list.add("xx");
        list.remove("xx");
    }
}