javase-collection-210621-01

javase-collection-210621-01

• LinkedList
• Vector

---

LinkedListTest01.java

package bgy_linkedlist01;

/*
    LinkedList 的数据结构是 双向链表
        基础单元为节点node
        每一个节点node都有两个属性：
            1. 存储的数据
            2. 下一个节点的内存地址

    LinkedList集合底层也是有下标的
    ArrayList集合之所以检索效率高不是因为有下标，而是他底层用的是数组
    LinkedList集合也有下标，但是检索/查找某个元素的时候效率较低，因为只能从头结点开始一个一个遍历

    链表优点：
        链表的元素在空间存储上的内存地址不连续，
        所以随机增删元素的时候不会有大量元素位移，所以随机增删效率比较高。
    链表缺点：
        不能通过数学表达式计算被查找元素的内存地址，
        每一次都是从头节点开始遍历，知道找到为止，
        所以LinkedList的查找效率较低。

 */

import java.util.LinkedList;
import java.util.List;

public class LinkedListTest01 {
    public static void main(String[] args) {
        List list = new LinkedList();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}

VectorTest01.java

package bgy_vector01;

/*
    Vector 集合底层也是一个数组
    初始化容量为10
    Vector 中的所有方法都被synchronized关键字修饰，
    是线程安全的，效率较低

    集合工具类：
        java.util.Collections
    集合接口：
        java.util.Collection

    可通过集合工具类，
    将线程不安全的ArrayList集合变成线程安全的
        Collections.synchronizedList(arrayList);
 */

import java.util.*;

public class VectorTest01 {
    public static void main(String[] args) {
        List vecotor = new Vector();

        vecotor.add(1);
        vecotor.add(2);
        vecotor.add(3);
        vecotor.add(4);

        Iterator iterator = vecotor.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }



        // 非线程安全
        List arrayList = new ArrayList();
        arrayList.add("bgy01");
        arrayList.add("bgy02");
        arrayList.add("bgy03");

        // 运行这段代码，arrayList集合就变成了线程安全的了
        Collections.synchronizedList(arrayList);

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
    }
}