Java笔记12-25

Vector容器类

Vector底层也是用数组来实现的，与ArrayList相比线程更安全，相关的方法都加了同步检查，因此“线程安全，效率低”。比如，indexOf方法就增加了synchronized同步标记。

Vector的使用

Vector的使用与ArrayList是相同的，因为他们都实现了List接口，对List接口中的抽象方法做了具体实现。
示例代码：

import java.util.List;
import java.util.Vector;

public class VectorTest {
    public static void main(String[] args) {
        // 实例化Vector
        List<String> vec = new Vector<>();
        vec.add("1");
        vec.add("2");
        vec.add("1");

        for (int i = 0; i < vec.size(); i++) {
            System.out.println(vec.get(i));
        }
        System.out.println("----------");
        for (String str:vec) {
            System.out.println(str);
        }
    }
}

Vector扩容分析

容器在创建是容量就是10，这点与ArrayList不同，而且扩容时是以原来两倍扩容。

Stack容器

Stack容器介绍

Stack栈容器，是Vector的一个子类，它实现了一个标准的后进先出的栈（LIFO：Last In Frist Out）

Stack特点

后进先出，通过5个操作方法对Vector进行扩展，允许将向量视为堆栈。

操作栈的方法

方法	说明
boolean empty()	测试如果这个栈是空的，返回true，否则返回false
E peek()	查看栈顶元素
E pop()	删除栈顶元素，并返回删除的元素对象（出栈）
E push(E item)	将一个元素添加到栈顶（入栈）
int search(Object o)	在栈中查找Object o对象的位置，如果查找到则返回元素位置，如果找不到则返回-1

Stack的使用

示例代码：

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        // 实例化栈容器
        Stack<String> stack_1 = new Stack<>();

        // 将元素添加到栈容器中
        stack_1.push("1");
        stack_1.push("2");
        stack_1.push("3");

        // 判断栈容器是否为空
        System.out.println(stack_1.empty());

        // 查看栈顶元素
        System.out.println(stack_1.peek());

        // 返回元素在栈容器中的位置
        System.out.println(stack_1.search("3"));

        // 获取栈容器中的元素
        String pop_1 = stack_1.pop();
        System.out.println(pop_1);
        pop_1 = stack_1.pop();
        System.out.println(pop_1);
        pop_1 = stack_1.pop();
        System.out.println(pop_1);

    }
}

栈操作是从栈顶向栈底操作的，所以搜索元素时，栈顶为起始位置，而且栈元素索引以1为开头。

Stack的使用案例

判断元素的对称性

String str = "{[()]}";

    // 匹配符号的对称性
    public void symmetry() {
        String str = "{[()]}(";
        // 实例化Stack
        Stack<String> stack1 = new Stack<>();

        // 标志位
        boolean flag = true;
        // 拆分字符串获取字符串的字符
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c == '{') {
                stack1.push("}");
            }
            if (c == '[') {
                stack1.push("]");
            }
            if (c == '(') {
                stack1.push(")");
            }
            // 判断符号是否匹配
            if (c == '}' || c == ']' || c == ')') {
                if(stack1.empty()) {
                    flag = false;
                    break;
                }
                String x = stack1.pop();
                if (x.charAt(0)!=c) {
                    flag = false;
                    break;
                }
            }
        }
        if (!stack1.empty()) {
            flag = false;
        }
        System.out.println(flag);
    }

LinkedList容器类

LinkedList底层用双向链表实现存储。特点：查询效率低，增删效率高，线程不安全。双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。

双向链表

class Node<E> {
	E item;
	Node<E> next;
	Node<E> prev;
}

LinkedList的使用（List标准）

LinkedList实现了List接口，所以LinkedList是具备List的存储特征的（有序，且元素可以重复）。
示例代码：

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

public class LinkedListTest {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        // 添加元素
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        // 获取元素
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("----------");
        for (String str:list) {
            System.out.println(str);
        }
    }
}

LinkedList的使用（非List标准）

操作双向链表

方法	说明
void addFirst(E e)	将指定元素插入到开头
void addLast(E e)	将指定元素插入到结尾
getFirst()	返回此列表的第一个元素
getLast()	返回此列表的最后一个元素
removeFirst()	移除此列表中的第一个元素，并返回这个元素
removeLast()	移除此列表中的最后一个元素，并返回这个元素
E pop()	从此列表所表示的堆栈处弹出一个元素，等效于removeFirst
void push(E e)	将元素推入此列表所表示的堆栈，等效于addFirst(E e)
boolean isEmpty()	判断列表是否包含元素，如果不包含元素则返回true

示例代码：

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

public class LinkedListTest {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        // 添加元素
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        // 获取元素
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("----------");
        for (String str:list) {
            System.out.println(str);
        }
        System.out.println("-----LinkedList-----");
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("1");
        linkedList.addFirst("2");
        linkedList.addFirst("3");
        for (String str:linkedList) {
            System.out.println(str);
        }
        System.out.println("----------");
        LinkedList<String> linkedList_1 = new LinkedList<>();
        linkedList_1.addLast("1");
        linkedList_1.addLast("2");
        linkedList_1.addLast("3");
        for (String str:linkedList_1) {
            System.out.println(str);
        }
        System.out.println("___________");
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        System.out.println("----------");
        linkedList.removeFirst();
        linkedList.removeLast();
        for (String str:linkedList) {
            System.out.println(str);
        }
        System.out.println("----------");
        linkedList.addFirst("4");
        linkedList.pop();
        for (String str:linkedList) {
            System.out.println(str);
        }
        System.out.println("----------");
        linkedList.push("5");
        for (String str:linkedList) {
            System.out.println(str);
        }
        System.out.println(linkedList.isEmpty());
    }
}