Node和Vector

2021.03.18
第34次记录

课堂笔记1：
单链表中的节点
节点是单链表中的基本的单元。
每一个节点Node都有两个属性：
一个属性：是存储内存的数据
另一个属性是：下一个节点的内存地址

代码演示1：

public class Node {
    //存储的数据
    Object element;
    //下一个节点的内存地址
    Node next;
    public Node(){

    }
    public Node(Object element, Node next){
        this.element = element;
        this.next = next;
    }
}

public class Link {
    //头节点
    Node header = null;
    int size = 0;
    public int size(){
        return size;
    }
    //向链表中添加元素的方法
    public void add(Object element){
        //说明还没有节点，需要new一个新的节点对象，作为头节点的对象
        //此时的头节点既是头节点又是尾节点
        if (header == null){
            header = new Node(element, null);
        }else{
            //说明头节点不是空，头节点已经存在
            //找出当前末尾节点，让当前末尾节点的next是新节点
            Node currentLastNode = findLast(header);
            currentLastNode.next = new Node(element, null);
        }
        size++;
    }
    //专门查找末尾节点的方法
    private Node findLast(Node node) {
        if (node.next == null){
            return node;
        }
        return findLast(node.next);
    }

    //删除链表中某个数据的方法
    public void remove(Object obj){

    }
    //修改链表中某个数据的方法
    public void modify(Object newObj){

    }
    //查找链表中某个元素的方法
    public int find(Object obj){
        return 1;
    }
}

public class Test {
    public static void main(String[] args) {
        Link link = new Link();
        link.add(100);
        link.add(200);
        link.add(300);
        //获取元素个数
        System.out.println(link.size());
    }
}

输出结果：
3

课堂笔记2：
Vector:
1.底层也是一个数组；
2.初始化容量：10；
3.怎么扩容？
扩容之后是原容量的2倍
10—>20—>40—>80
4.ArrayList扩容特点：
原容量的1.5倍
10—>1.5*10
5.Vector中所有方法都是线程同步的，都带有synchronized关键字，是线程安全的。
效率较低，使用较少。
6.怎样将一个线程不安全的ArrayList集合转换成线程安全的呢？
使用集合工具类：
java.util.Collection 是集合接口；
java.util.Collection 是集合工具类；

代码演示2：

public class VextorTest {
    public static void main(String[] args) {
        //创建对象
        List vector = new Vector();
        //添加元素
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);
        //扩容
        vector.add(11);
        //遍历
        Iterator iterator = vector.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //以后可能会使用这个方法
        List myList = new ArrayList();//非线程安全的
        //编程线程安全的
        Collections.synchronizedList(myList);
        myList.add("111");
        myList.add("222");
        myList.add("333");
        Iterator it = myList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

输出结果：
1
2
3
4
5
6
7
8
9
10
11
111
222
333