Java 使用堆栈检查密码中字母和数字的相等数量

我必须写一个程序来检查密码，这样密码就应该

• 长度应至少为8个字符
• 仅包含字母和数字（特殊字符）
• 包含相同数量的字母和数字

程序应检查其是否有效，并显示适当的消息。 此外，仅应将stack类用作数据结构

以下是我到目前为止的想法：

public class dsa_1c {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc= new Scanner(System.in);

        String pass;

        System.out.println("Enter a password");
        pass= sc.nextLine();

        if(checkPass(pass)){
            System.out.println("Valid Password");
        }
        else{
            System.out.println("Invalid Password");
        }
    }


        public static boolean checkPass(String password){

            Stack<Character> stack= new Stack<Character>();


            int count1=0, count2=0;

            if(password.length()<8){
                return false;
            }
            else{
             for(int i=0; i<password.length();i++){
                 char c= password.charAt(i);

                  if (!Character.isLetterOrDigit(c)){
                    return false;}

                  if(Character.isLetterOrDigit(c)){

                    stack.push(c);

                  }

                    char top= stack.peek();

                  if(Character.isLetter(top)){
                      count1++;
                      stack.pop();                    

                  }

                  else if(Character.isDigit(top)){                  
                      count2++;
                      stack.pop();                    

                  }

                  if(count1==count2){
                 return true;
                  }

                  if(!stack.isEmpty()){
                 return false;
                  }

             }

            }
                return true;

            }

    }

因为当我改变它的时候

if(count1!=count2)
    return false; }

---

对于任何有效的密码，它都会返回无效的密码。

对我来说，使用堆栈似乎有点过火了-对字符进行迭代，计算数字和字母，并确保它们具有相同的数字就足够了：

private static boolean isValidPassword(String password) {
    int letterCount = 0;
    int digitCount = ;
    for (int i = 0; i < password.length(); ++i) {
        char c = password.charAt(i);
        if (Character.isLetter(c)) {
            ++letterCount;
        } else if (Character.isDigit(c)) {
            ++digitCount;
        } else {
            return false;
        }
    }
    return (letterCount + digitCount) >= 8 &&
           letterCount == digitCount;
}

私有静态布尔值isValidPassword（字符串密码）{
int-letterCount=0；
int-digitCount=；
对于（int i=0；i=8&&
letterCount==数字计数；
}

最终导致问题的是

返回true

。您可以使用

returncount1==count2。以下是一个例子：

public static boolean checkPass(String password) {

    Stack<Character> stack = new Stack<Character>();
    int count1 = 0, count2 = 0;
    if (password.length() < 8) {
        return false;
    } else {
        for (int i = 0; i < password.length(); i++) {
            char c = password.charAt(i);

            if (!Character.isLetterOrDigit(c)) {
                return false;
            } else {
                stack.push(c);
            }
        }
        while(!stack.isEmpty()){
            char c = stack.pop();
            if(Character.isLetter(c)){
                count1++;
            }else{
                count2++;
            }
        }
        return count1 == count2;
    }
}

公共静态布尔校验传递（字符串密码）{
堆栈=新堆栈（）；
int count1=0，count2=0；
if（password.length（）<8）{
返回false；
}否则{
对于（int i=0；i
假设这只是一个操作堆栈的练习，下面是我的2美分：

public class dsa_1c {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter a password");
    String pass = sc.nextLine();

    if (checkPass(pass)) {
        System.out.println("Valid Password");
    } else {
        System.out.println("Invalid Password");
    }
}

private static boolean checkPass(String pass) {
    boolean result = false;
    if (pass.length() == 8) {
        Stack stack = new Stack();
        for (char current : pass.toCharArray()) {
            if (stack.isEmpty()) {
                stack.push(current);
                continue;
            }
            char previousChar = stack.pop();
            if (sameType(current, previousChar)) {
                stack.push(previousChar);
                stack.push(current);
            }
        }
        if (stack.isEmpty()) {
            result = true;
        }
    }
    return result;
}

public static boolean sameType(char current, char previousChar) {
    boolean result = false;
    if (Character.isAlphabetic(current) && Character.isAlphabetic(previousChar)) {
        result = true;
    }
    else if (Character.isDigit(current) && Character.isDigit(previousChar)) {
        result = true;
    }
    return result;
}

static class Stack extends ArrayList {

    public static final char NULL_CHARACTER = 0x0;

    public void push(Character letter) {
        add(letter);
    }
    public Character pop() {
        Character result = NULL_CHARACTER;
        if (!isEmpty()) {
            result = (Character)remove(size()-1);
        }
        return result;
    }
}

}
感谢您完善代码。你能解释一下如何返回count1==count2布尔值检查了吗？没有完全理解。
count1==count2
返回一个布尔值，它类似于
if（count1==count2）{return true；}else{return false；}
public class dsa_1c {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter a password");
    String pass = sc.nextLine();

    if (checkPass(pass)) {
        System.out.println("Valid Password");
    } else {
        System.out.println("Invalid Password");
    }
}

private static boolean checkPass(String pass) {
    boolean result = false;
    if (pass.length() == 8) {
        Stack stack = new Stack();
        for (char current : pass.toCharArray()) {
            if (stack.isEmpty()) {
                stack.push(current);
                continue;
            }
            char previousChar = stack.pop();
            if (sameType(current, previousChar)) {
                stack.push(previousChar);
                stack.push(current);
            }
        }
        if (stack.isEmpty()) {
            result = true;
        }
    }
    return result;
}

public static boolean sameType(char current, char previousChar) {
    boolean result = false;
    if (Character.isAlphabetic(current) && Character.isAlphabetic(previousChar)) {
        result = true;
    }
    else if (Character.isDigit(current) && Character.isDigit(previousChar)) {
        result = true;
    }
    return result;
}

static class Stack extends ArrayList {

    public static final char NULL_CHARACTER = 0x0;

    public void push(Character letter) {
        add(letter);
    }
    public Character pop() {
        Character result = NULL_CHARACTER;
        if (!isEmpty()) {
            result = (Character)remove(size()-1);
        }
        return result;
    }
}