Question

得到编译错误并且无法让我的代码以我需要的方式工作，它开始让我发疯！基本上我试图在我的方法中获取我的布尔数组来迭代数组，找出是否连续更多地列出了False，或者如果是，则返回true或false。在我的程序中，我列出的数组应该返回false。有任何想法吗？提前致谢。

public class trueOrfalse
{
   public static void main(String [] args)
   {
      boolean[] guess = {false,true,false,false,false,true,true};
      boolean result = longerTF(guess);
   }


   public static boolean longerTF(boolean[] guess)
   {
   int variable = 0;
   for(int x = 0; x < guess.length; x++)
   {
       if(guess[x] > true)
       {
          return true;
       }
       else 
       {
           return false;
       }
   }
}

Answer 1

以下是“更正”版本：

public class trueOrfalse {
    public static void main(String[] args) {
        boolean[] guess = { false, true, false, false, false, true, true };

        boolean result = longerTF(guess);

    }

    public static boolean longerTF(boolean[] guess) {

        int variable = 0;

        for (int x = 0; x < guess.length; x++) {
            if (guess[x]) {
                variable++;
            }
        }
        return (variable > (guess.length-variable));
    }
}

您忘记了一个结束语}，返回语句和布尔比较不能与<或>一起使用。

Answer 2

比较运算符>等对于boolean操作数既不合法也不有意义。您打算guess[x] > true完成什么？

由于guess是boolean[]，您可以进行测试

if (guess[x])

或

if (! guess[x])

和

return guess[x];

EDIT 您希望循环计算连续值。这个循环没有，但它显示了这样的结构如何适用于更简单的问题。

public boolean dominant(boolean[] guess) {
  int tCount = 0;
  for (int ix = 0; ix < guess.length; ++ix) {
    if (guess[ix]) {
      ++tCount;
    }
  }
  return tCount >= guess.length / 2;
}

Answer 3

我不知道从哪里开始

首先这是错误的

if(guess[x] > true)

应该是

if(guess[x]==true)

因为if语句需要一个布尔结果，并且你的数组中有布尔值，这将产生相同的效果

if(guess[x])

你也错过了一个案子。当数组为空时，你永远不会遇到for循环，但你的方法仍然需要返回一个布尔值。您可以在方法结束时抛出运行时异常或默认值return false;

你的for循环没有意义，因为你的方法将在第一次迭代中返回一个结果（如果数组不为空）。你的longTF方法也可能看起来像这样

public static boolean longerTF(boolean[] guess) {
    if(guess.length>0)
        return guess[0];
    throw new IllegalArgumentException("The array must not be empty");
}

我建议像“编程：学习计算机编程语言的基础知识”这样的通用书。在尝试实现任何内容之前，您需要先了解编程的基础知识。

Answer 4

如上所述。您无法使用>来比较两个布尔值。

为了计算连续的真/假数，你需要两个不同的计数器。您可以运行循环并在遇到重复的真/假项时继续递增计数器，如果不是，您可以将计数器重置为1.我在下面提出了一个仓促的解决方案给你一个想法。我还没有对它进行过良好的测试，似乎有效。希望这会有所帮助。

public class trueOrfalse {
    public static void main(String[] args) {
        boolean[] guess = { false,true,false,false,false,true,true };
        boolean result = longerTF(guess);
        System.out.println("result: " +result);
    }

    public static boolean longerTF(boolean[] guess) {

        int consecutiveFalseCount = 1;
        int consecutiveTrueCount = 1;

        for (int x = 0; x < guess.length; x++) {
            if (guess[x] == true) {
                if(x!=0 && x<guess.length){
                   if(guess[x-1] == true){
                       consecutiveTrueCount = consecutiveTrueCount + 1;
                   } else {
                       consecutiveTrueCount = 1;
                   }
                }
            } else {
                if(x!=0 && x<guess.length-1){
                       if(guess[x-1] == false){
                           consecutiveFalseCount = consecutiveFalseCount + 1;
                       } else {
                           consecutiveFalseCount = 1;

                       }
                    }
                } 
        }

        System.out.println("Consecutive True count: " +consecutiveTrueCount);
        System.out.println("Consecutive False count: " +consecutiveFalseCount);

        if(consecutiveTrueCount>consecutiveFalseCount){
            return true;
        } else {
            return false;
        }
    }

}

编译错误Java：布尔数组方法

4 个答案: