Valid Parentheses (LeetCode #20)

Input: s = "()"
Output: true

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

Input: s = "(]"
Output: false

class Solution {
    public boolean isValid(String s) {
        
        if(s.length() == 0) return true;
        // if empty string return true

        Stack<Character> LIFOStack = new Stack<>();
        // Last In First Out
        
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == '(' || s.charAt(i) == '{'|| s.charAt(i) == '['){
                LIFOStack.push(s.charAt(i));
                // if open bracket, push to stack
            }
            else if(!LIFOStack.empty() && s.charAt(i) == ')' && LIFOStack.peek() == '('){
                // if close bracket and top of stack is open bracket (and check if empty always)
                LIFOStack.pop();
                // remove respective open bracket from stack
            }
            else if(!LIFOStack.empty() && s.charAt(i) == '}' && LIFOStack.peek() == '{'){
                LIFOStack.pop();
                // repeat for other types of brackets
            }
            else if(!LIFOStack.empty() && s.charAt(i) == ']' && LIFOStack.peek() == '['){
                LIFOStack.pop();
            }
            else{
                return false;
            }
        }
        
        return LIFOStack.empty();
        // if stack is empty, input string is valid
    }
}

class Solution {
    public boolean isValid(String s) {
        char[] stack = new char[s.length()];
        // create char array with s.length() as size
        // s.length() as if String is valid, the program will iterate throughout
		int head = 0;
        // set head index to 0
		for(char c : s.toCharArray()) {
            // iterate through characters in String
			switch(c) {
				case '{':
				case '[':
				case '(':
					stack[head++] = c;
                    // if open bracket, set head index to char then postfix
                    // increment for next iteration
					break;
				case '}':
					if(head == 0 || stack[--head] != '{') return false;
                    // if head is zero, means that no open brackets have been placed in stack
                    // check precending character (prefix decrement), 
                    // if not valid (not { in this case) return false
					break;
				case ')':
					if(head == 0 || stack[--head] != '(') return false;
                    // same logic applies but with other bracket types
					break;
				case ']':
					if(head == 0 || stack[--head] != '[') return false;
					break;
			}
		}
		return head == 0;
    }
}