Question

我试图开发一种方法来检查给定数组的前4个元素（假设数组至少有4个元素）是否连续相等，我的第一个方法是创建一个布尔变量首先将其设为false，if a[i] == a[i + 1]将其设为true。但问题是，无论4个元素是否连续，它总是将其打印为真。

public static boolean isConsecutive(int[] a) {
    boolean isConsecutive = false;
    for (int i = 0; i < 4; i++) {
        if (a[i] == a[i + 1]) {
            isConsecutive = true;
        }
    }
    return isConsecutive;
}

我的错误在哪里？提前谢谢！

Answer 1

如果它不是连续的，你需要一个else分支再次将它设置为false并循环到3.或者只要某些东西不相等就更好一个return语句，例如。

if (a[i] == a[i + 1]) {
    isConsecutive = true;
} else {
    return false;
}

您也可以将变量isConsecutive视为

 public static boolean isConsecutive(int[] a) {
     for (int i = 0; i < 3; i++) {
         if (!(a[i] == a[i + 1])) {
             return false;
         }
     }
     return true;
 }

请注意，您的循环对于索引退出债券异常是不安全的，因为它的大小可能小于4.

Answer 2

使用你的方法我们的方法你可能会得到arrayOutOfBounds异常。顺便说一句，我认为这种方法更容易。

public static boolean isConsecutive(int[] a) {

    return (a[0] == a[1] && 
            a[0] == a[2] &&
            a[0] == a[3])

}

Answer 3

您的代码将isConsecutive设置为false，目的是在找到证据时将其设置为true。问题是a[i]==a[i+1]只是部分证据。因此，您在true时将其设置为a[0] == a[1]，如果（例如）a[1] != a[2]，则不要将其更改回来。

在这种情况下，如果你从isConsecutive = true开始，它会更好，并且在你的循环中，寻找确凿证据证明它是错误的：

boolean firstFourEqual(int[] a) {
    boolean isConsecutive=true;
    for(int i=0;i<3;i++) {
        if(a[i]!=a[i+1]) {
            isConsecutive=false;
        }
    }
    return isConsecutive;
}

（注意我们迭代3次，而不是4次，因为第三次测试会检查第三和第四个元素。）

一旦你将isConsecutive设置为false，就不会再回头了，所以你不妨离开循环。有两种方法可以做到这一点：

boolean firstFourEqual(int[] a) {
    boolean isConsecutive=true;
    for(int i=0;i<3;i++) {
        if(a[i]!=a[i+1]) {
            isConsecutive=false;
            break;                <-- leave the loop early
        }
    }
    return isConsecutive;
}

或者：

boolean firstFourEqual(int[] a) {
    for(int i=0;i<3;i++) {
        if(a[i]!=a[i+1]) {
            return false;
        }
    }
    return true;
}

有些人认为使用return mid-method是糟糕的风格。其他人认为拥有一个可变变量是糟糕的风格。我倾向于最后一个例子。该方法简短明了。有一个中间方法返回，但方法很短，很容易发现。

始终最好从true开始并修改为false，反之亦然。然而，在这样的情况下，假设（例如“前四项相等”）可以通过单一证据立即反驳（“因为项目3和4不相等而错误”），默认为有意义假设的结果，如果你发现其他证据则将其改为相反的结果。

最后，您可以使用stream执行此操作：

 return IntStream.range(0,3)
    .mapToObj( x -> a[x] == a[x+1])
    .noneMatch( b -> b == false);

所有这些都假设数组的大小至少为4.如果无法保证，则需要更多代码。

Answer 4

你的isConsecutive变量在for循环之外设置为false。

public static boolean isConsecutive(int[] a) {
        **boolean isConsecutive=false**;
        for(int i=0;i<4;i++) {
            if(a[i]==a[i+1]) {
                isConsecutive=true;
            }
        }


        return isConsecutive;
    }

这就是为什么变量在连续变量相等的前几次迭代期间设置为true，然后变量的值永远不会改变。

而是这样做： -

public static boolean isConsecutive(int[] a) {

        for(int i=0;i<4;i++) {
        boolean isConsecutive=false;    
        if(a[i]==a[i+1]) {
                isConsecutive=true;
            }
        }


        return isConsecutive;
    }

但这不是一件理想的事情。最好的方法是添加一个else条件，当if条件不为真时，变量的值会改变。

public static boolean isConsecutive(int[] a) {
        boolean isConsecutive=false;
        for(int i=0;i<4;i++) {

        if(a[i]==a[i+1]) {
                `isConsecutive=true;`
            }
        else {
    isConsecutive=true;
        }
        }



        return isConsecutive;
    }

通过这样做，当连续变量不相等时，再次更改变量的值。

Answer 5

问题在于你是否有条件。它没有检查4个连续的类似元素，而是检查两个连续的相似元素。

if(a[i]==a[i+1]) {
            isConsecutive=true;
        }

如果你的数组是[1,2,2,3,4,5,6]，在这个数组中你的函数检查[1] == a [2]时，它会将isConsecutive设置为true并且它对于完整的数组迭代，它将保持为真。

因此，正如您所提到的，该数组至少包含4个元素，因此您可以编写类似

的函数

 public static boolean isConsecutive(int[] a) {

         if(a[0]==a[1] && a[0]==a[2] && a[0]==a[3])
              return true;
         else
              return false;
}

如果你想在数组中的任何地方检查4个连续元素，那么编写你的函数

public static boolean isConsecutive(int[] a) {
    boolean isConsecutive=false;
    for(int i=0;i<a.length-3;i++) {
        if(a[i]==a[i+1] && a[i]==a[i+2] && a[i]==a[i+3])) {
            isConsecutive=true;
        }
    }

    return isConsecutive;
}

Answer 6

在某个1.0.0值（例如1）中将isConsecutive变量值设置为true后，该值将始终为i，甚至如果在下一次迭代中（true时），则下一个元素（i == 2）的值与当前元素（a[3]）不同。

此外，由于for循环中的限制为4，因此它也会执行第4和第5个元素的检查。当数组中只有4个元素时，它也会抛出a[2]。

您需要执行以下操作：

将ArrayIndexOutOfBoundsException值更改回isConsecutive一旦有{a} 当前元素与下一个元素之间的差异
将限制设置为3，以便最后一次迭代不会检查第5次元件
在for-loop终止条件中添加布尔标志检查为好;因此，如果第二个元素已经与第一个元素不同元素，循环将停止：
```
false
```

PS：为了更好的可读性，我将public static boolean isConsecutive(int[] a) { boolean different = false; for (int i = 0; i < 3 && !different; i++) { different = (a[i + 1] != a[i]); } return !different; }布尔值重命名为isConsecutive

Java数组 - 总是如此

6 个答案: