从Java堆栈返回数据

我试图平衡括号。当我尝试执行stack.peek（）之类的操作时，出现了一个错误“无法将对象与基本体进行比较”{'我将其转换为字符。编译器接受了它，但警告不安全操作。有人知道更好的方法吗？为什么我可以将字符作为基本体从堆栈中推送和弹出，但当我偷看时它不是基本体

import java.util.*;

class Solution {
    public int solution(String S) {
        // write your code in Java SE 8

    char[] C = S.toCharArray();
    LinkedList stack = new LinkedList();

    for(int i = 0; i< C.length; i++){
        if(C[i] == '(' || C[i] == '[' || C[i] == '{'){
            stack.push(C[i]);   
        }

        if(C[i] == ')' && (char)stack.peek() == '('){
            stack.pop();   
        }
        else if (C[i] == ']' && (char)stack.peek() == '['){
            stack.pop();   
        }
        else if (C[i] == '}' && (char)stack.peek() == '{'){
            stack.pop();   
        }
    }

    if(stack.size() == 0){
        return 1;   
    }
    else{
        return 0;   
    }
}
}

import java.util.*；
类解决方案{
公共整数解决方案（字符串S）{
//用JavaSE8编写代码
char[]C=S.toCharArray（）；
LinkedList堆栈=新建LinkedList（）；
for（int i=0；i

您使用的是原始形式的

链接列表

，它将存储

对象

s。您不能将

对象

强制转换为

字符

使用一个通用的

LinkedList

。然后

peek（）

将返回

Character

s，当与

=

进行比较时，Java将把它们取消装箱到

char

s

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

LinkedList堆栈=新建LinkedList（）；

---

然后您会发现，您甚至不需要将

peek（）

的返回转换为

char

您使用的是

LinkedList

的原始形式，它将存储

对象

s。您不能将

对象

转换为

char

使用一个通用的

LinkedList

。然后

peek（）

将返回

Character

s，当与

=

进行比较时，Java将把它们取消装箱到

char

s

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

LinkedList堆栈=新建LinkedList（）；

---

然后您会发现，您甚至不需要强制执行

peek（）的返回

到

char

如果正确使用

LinkedList

原始类型，就不会出现此问题。将列表声明为

LinkedList

，它应该可以工作。

如果正确使用

LinkedList

原始类型，就不会出现此问题。将列表声明为

LinkedList

它应该会起作用。

这是一篇很好的文章-- 例如，它谈到了允许和不允许的类型转换

在任何情况下都不能做的一件事是从一个对象强制转换为一个基本数据类型，反之亦然。基本类型和对象在Java中是非常不同的东西，您不能在两者之间自动强制转换。”

仅供将来参考，以防链表无法设置为特定类型（因为它可能发生在某些情况下），代码只需执行.equals操作，除了==for stack。peek（）是一个对象，对象需要.equals进行比较。此外，刚刚取消了强制转换

    public static void main(String[] args) 
{

    System.out.println(solution("{"));



}

public static int solution(String s) {
  char[] C = s.toCharArray();
LinkedList stack = new LinkedList();
System.out.println("Length:" + C.length);
for(int i = 0; i< C.length; i++){
    if(C[i] == '(' || C[i] == '[' || C[i] == '{'){

        stack.push(C[i]);   
    }
    System.out.println("Peek" + (C[i] == '}'));
    if(C[i] == ')' && stack.peek().equals('(')){
        stack.pop();   
    }
    else if (C[i] == ']' && stack.peek().equals('[')){
        stack.pop();   
    }
    else if (C[i] =='}' && stack.peek().equals('{')){
        System.out.println("POPPED");
        stack.pop();   
    }
}

if(stack.size() == 0){
    return 1;   
}
else{
    return 0;   
}
}

publicstaticvoidmain（字符串[]args）
{
System.out.println（解决方案（“{”）；
}
公共静态int解决方案（字符串s）{
char[]C=s.toCharArray（）；
LinkedList堆栈=新建LinkedList（）；
System.out.println（“长度：“+C.Length”）；
for（int i=0；i

但更好的方法是使用字符类型的LinkedList

这两种解决方案都不需要强制转换

这是一篇很好的文章-- 例如，它谈到了允许和不允许的类型转换

在任何情况下都不能做的一件事是从一个对象强制转换为一个基本数据类型，反之亦然。基本类型和对象在Java中是非常不同的东西，您不能在两者之间自动强制转换。”

仅供将来参考，以防链表无法设置为特定类型（因为它可能发生在某些情况下），代码只需执行.equals操作，除了==for stack。peek（）是一个对象，对象需要.equals进行比较。此外，刚刚取消了强制转换

    public static void main(String[] args) 
{

    System.out.println(solution("{"));



}

public static int solution(String s) {
  char[] C = s.toCharArray();
LinkedList stack = new LinkedList();
System.out.println("Length:" + C.length);
for(int i = 0; i< C.length; i++){
    if(C[i] == '(' || C[i] == '[' || C[i] == '{'){

        stack.push(C[i]);   
    }
    System.out.println("Peek" + (C[i] == '}'));
    if(C[i] == ')' && stack.peek().equals('(')){
        stack.pop();   
    }
    else if (C[i] == ']' && stack.peek().equals('[')){
        stack.pop();   
    }
    else if (C[i] =='}' && stack.peek().equals('{')){
        System.out.println("POPPED");
        stack.pop();   
    }
}

if(stack.size() == 0){
    return 1;   
}
else{
    return 0;   
}
}

publicstaticvoidmain（字符串[]args）
{
System.out.println（解决方案（“{”）；
}
公共静态int解决方案（字符串s）{
char[]C=s.toCharArray（）；
LinkedList堆栈=新建LinkedList（）；
System.out.println（“长度：“+C.Length”）；
for（int i=0；i

但更好的方法是使用字符类型的LinkedList

---

这两种解决方案都不需要强制转换

您看到的是自动装箱。您应该使用泛型集合。您看到的是自动装箱。您应该使用泛型集合。只是好奇，如果我使用原始链表并使用.equals（'}'）将对象与角色进行比较，它会起作用吗？或者使用.equals（）只在两个对象之间工作？我仍然没有真正理解参数化类型的意义