谈谈ArrayList与Vector的理解？

目录

 扩容机制

ArrayList扩容源码

Vector扩容源码

二者区别

扩展：stack(栈）

1.创建stack对象

 2. 入栈(先进后出）

3.出栈

 扩展：举个例子：实现下字符串逆置，利用stack栈来实现。

从接口实现上，ArrayList与Vector都是基于动态数组实现的List接口的集合实现类。

 扩容机制

ArrayList扩容源码

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        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);

• 当传入的是无参构造时候，add(11)个元素时候，会进行扩容，新容量为oldCapacity>>1+oldCapacity；
• 当传入的是带参构造，扩容时候，会按照它的传入的扩容容量+扩容容量<<1进行计算；

Vector扩容源码

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

• Vector 的无参构造，数组的初始化容量为10，每次扩容不足，扩容为原来的二倍
  

• 初始化提供数组的初始化容量和每次的扩容值，当容量不足时候，已指定扩容值进行扩容操作

二者区别

初始容量：

1. ArrayList初始默认容量为0，添加一个元素时候，扩容为10；
2. Vector 初始容量为10；

扩容方式：

1. ArrayList:在原有容量基础上，扩容1.5倍。
2. Vector:在原有容量基础上，扩容2倍。

线程安全：

1. ArrayList:线程不安全（可使用CopyWriteArrayList集合解决）
2. Vector:线程安全，操作方法使用sychronized(同步锁）实现线程同步。

执行效率：

1. Vector的方法加入了同步锁，实现线程安全，所以在方法执行时许加锁，释放锁，产生额外的性能开销，所以Vector性能会低于ArrayList.

 // 栈 先进后出
        Stack<String> stack = new Stack<>();
        // 入栈
        stack.push("张三");
        stack.push("李四");
        stack.push("王五");
        System.out.println(stack);
        // 获取到栈顶元素，并让栈顶元素出栈
        // String item = S1.POP();
        // 获取栈顶元素，元素不出栈。
        String item = stack.peek();
        System.out.println(item);
        System.out.println(stack);


        // 字符串逆置

        System.out.println(reverse("abcdefg"));
    }
    public static String reverse(String str){
        Stack<Character> stack = new Stack<>();

        // 字符串中的元素入栈
        char[] c1 = str.toCharArray();
        for (char c : c1){
            stack.push(c);
        }
        StringBuilder sb = new StringBuilder();

        // 出栈
        while (!stack.isEmpty()){
            sb.append(stack.pop());
        }
        return sb.toString();
    }

扩展：stack(栈）

1.创建stack对象

        Stack<Character> stack = new Stack<>();

 2. 入栈(先进后出）
 

        stack.push("张三");

3.出栈

        // 获取到栈顶元素，并让栈顶元素出栈
        // String item = S1.pop();

        // 获取栈顶元素，元素不出栈。
        String item = stack.peek();

 扩展：举个例子：实现下字符串逆置，利用stack栈来实现。

public static String reverse(String str){
        Stack<Character> stack = new Stack<>();

        // 字符串中的元素入栈
        char[] c1 = str.toCharArray();
        for (char c : c1){
            stack.push(c);
        }
        StringBuilder sb = new StringBuilder();

        // 出栈
        while (!stack.isEmpty()){
            sb.append(stack.pop());
        }
        return sb.toString();
    }