代码

class Solution {
    public boolean isValid(String s) {
               //初始化变量
        //map
        Map<Character,Character> map=new HashMap<>();
        map.put('}','{');
        map.put(')','(');
        map.put(']','[');
        //栈
        Stack<Character> stack=new Stack();

        //遍历
        for (int i = 0; i <s.length() ; i++) {
            Character curC=s.charAt(i);
            //1.如果是右括号
            //判断栈顶是否为 对应的左
            //是 弹栈
            //不是 结束，返回false
            if (map.containsKey(curC)) {
                //栈判空，如果空，false
                if (stack.isEmpty()) {
                    return false;
                }
                if (stack.peek().equals(map.get(curC))){
                    stack.pop();
                }
                else {
                    return false;
                }
                
            }
            else{//因为要么是 左括号 要么是 右括号，所以这else就完全针对左括号
                //2.如果是左括号，入栈
                stack.push(curC);
            }
        }

        //遍历结束,栈不为空，返回false
        if (stack.isEmpty()){
            return true;
        }
        else {
            return false;
        }

    }
}

记录

总结

1. 栈的常用方法

new 对象：Stack<Character> stack=new Stack();

push(E item) - 将元素压入栈顶

pop() - 移除并返回栈顶元素

peek() - 查看栈顶元素但不移除--如果 栈为空会报错，所以要主要判空

empty() - 检查栈是否为空

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // 创建栈
        Stack<String> stack = new Stack<>();
        
        // 入栈(push)
        stack.push("A");
        stack.push("B");
        stack.push("C");
        
        // 获取栈顶元素但不移除(peek)
        String topElement = stack.peek(); // 返回"C"
        
        // 出栈(pop)
        String popped = stack.pop(); // 移除并返回"C"
        
        // 检查栈是否为空
        boolean isEmpty = stack.empty(); // false
    }
}

记忆：

push(E item)====push 推，推入栈

pop()====pop:突然弹出

pop 整体有种 很突然的感觉

例如kpop,炸裂的 突然的

peek()偷看

其他

注意：Stack是线程安全的，但性能不如Deque接口的实现类(如ArrayDeque)。Java官方推荐使用Deque代替Stack来实现栈功能。

Deque<Character> stack = new LinkedList<Character>();

其他一样

2. 队列的常用方法

在 Java 中，队列（Queue） 和 栈（Stack） 是两种不同的数据结构，它们的操作方式不同。

1. 队列（Queue）的基本操作

Queue 接口，常用实现类有 LinkedList 和 ArrayDeque。

方法	作用	队列为空时
add(e) / offer(e)	入队（添加元素到队尾）	add() 满时抛异常，offer() 返回 false
remove() / poll()	出队（移除并返回队头元素）	remove() 抛异常，poll() 返回 null
element() / peek()	查看队头元素（不移除）	element() 抛异常，peek() 返回 null

示例代码：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // 入队
        queue.offer("A");  // 或 queue.add("A")
        queue.offer("B");

        // 查看队头（不移除）
        String head = queue.peek();  // "A"（队列空时返回 null）
        // 或者 queue.element()（队列空时抛异常）

        // 出队
        String first = queue.poll();  // "A"（队列空时返回 null）
        // 或者 queue.remove()（队列空时抛异常）

        System.out.println(queue);  // 输出 [B]
    }
}

3. Character 新对象

1-new

2-直接单引号

举例1

        Character c1='{';
        Character c2=new Character('c');

举例2

        Map<Character,Character> map=new HashMap<>();
        map.put('}','{');
        map.put(')','(');
        map.put(']','[');

4.map初始化元素

方法1

 Map<Character,Character> map=new HashMap<>();
        map.put('}','{');
        map.put(')','(');
        map.put(']','[');

方法2；括号后 双花括号

 Map<Character,Character> map2=new HashMap<>()
{{
            put('}','{');
            put(')','(');
            put(']','[');
        }};