Leetcode bracket validity problem

Title Description ：

Given one only includes '(',')','{','}','[',']' String s , Determines whether the string is valid .

Valid string needs to meet ：

Opening parentheses must be closed with closing parentheses of the same type .
The left parenthesis must be closed in the correct order .

 Input ：s = "()"
 Output ：true

 Input ：s = "()[]{}"
 Output ：true

 Input ：s = "(]"
 Output ：false

 Input ：s = "([)]"
 Output ：false

 Input ：s = "{[]}"
 Output ：true

Description of ideas

There is a closing bracket of the same type to close it . Because the left bracket encountered after must be closed first , So we can put this 【 Put the left bracket at the top of the stack 】.
When we encounter a closing bracket , We need to close an open parenthesis of the same type . here , We can take out the left parentheses at the top of the stack and judge whether they are the same type of parentheses .
If not of the same type , Or there is no left parenthesis in stack , So the string ss Invalid  

Be careful ：(( and )) In special circumstances .

Code

package com.pshdhx.Algorithm.easy;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @author pshdhx
 * @date 2022-01-12 15:26
 * @Des  Valid parenthesis 
 */

/**
 *  Description of ideas ： There is a closing bracket of the same type to close it . Because the left bracket encountered after must be closed first , So we can put this 【 Put the left bracket at the top of the stack 】.
 *  When we encounter a closing bracket , We need to close an open parenthesis of the same type . here , We can take out the left parentheses at the top of the stack and judge whether they are the same type of parentheses .
 *  If not of the same type , Or there is no left parenthesis in stack , So the string  ss Invalid 
 *  Be careful ：((  and  ))  In special circumstances .
 */
public class Brackets {
    Boolean isValid(String s) {
        // The odd number returns directly to 
        if(s.length() % 2 == 1){
            return false;
        }
        // Left bracket in stack 
        // Bracketed queue  "{[]}"
        Stack<Character> stack = new Stack<>();
        if(s.charAt(0) == ')' || s.charAt(0) == ']' ||s.charAt(0) == '}'){
            return false;
        }
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='('
            ||s.charAt(i)=='['
            ||s.charAt(i)=='{'){
                stack.push(s.charAt(i));
            }else if(stack.size()==0){      // solve  ()))
                return false;
            }else if(s.charAt(i)==')' && stack.size()>0){
                Character left = stack.pop();
                if(left != '('){
                    return false;
                }
            }else if(s.charAt(i)== ']' && stack.size()>0){
                Character left = stack.pop();
                if(left != '['){
                    return false;
                }
            }else if(s.charAt(i)== '}' && stack.size()>0){
                Character left = stack.pop();
                if(left != '{'){
                    return false;
                }
            }
        }
        // solve  (( such 
        if(stack.size()>0){
            return  false;
        }
        return true;
    }

    public static void main(String[] args) {
        Brackets b = new Brackets();
        Boolean valid = b.isValid("()))");
        System.out.println(valid);
    }
}