Java 检查数组中的每个元素是否具有相同的值

基本上，我想做的是检查int数组中的每个元素，如果所有元素都具有相同的值

我创建int数组，如下所示，以传递给比较每个数组元素的方法，它返回布尔值true，即使元素的值不完全相同

Int[] denominator = {3,3,4,3};

boolean compare;

compare = bruteforce(denominator);

public static boolean bruteforce(int[] input) {

int compare =0;
int count =0;

    for (int i = 0; i < input.length; i++) {

        compare = input[i];

        while(count<input.length){

            if(input[i+1]==compare){
            return true;

            }
            i++;
            count++;

        }//end while

    }//end for
    return false;
}//end method

Int[]分母={3,3,4,3}；
布尔比较；
比较=强力（分母）；
公共静态布尔暴力（int[]输入）{
int比较=0；
整数计数=0；
for（int i=0；i而（count如果所有元素都是相同的值，为什么不只使用一个for循环来测试数组中的下一个值？如果不是，则返回false。
现在，您没有检查“所有元素都是相同的值”。每当（第一次）两个元素相等时，您就结束函数并返回true。
当两个元素彼此不相等时，为什么不将布尔值设置为true并返回false？这样就可以保留大部分已存在的元素

if（输入[i+1]！=compare）返回false；
公共类答案{
public class Answer {

    public static void main(String[] args)
    {
        boolean compare = false;
        int count = 0;
        int[] denominator = { 3, 3, 4, 3 };


        for (int i = 0; i < denominator.length; i++)
        {
            if(denominator[0] != denominator[i]) 
            {
                count++;
            }
        }
        if(count > 0)
        {
            compare = false;
        } else
        {
            compare = true;
        }
        System.out.println(compare);

    }
}

公共静态void main（字符串[]args）
{
布尔比较=假；
整数计数=0；
int[]分母={3,3,4,3}；
for（int i=0；i<分母长度；i++）
{
if（分母[0]！=分母[i]）
{
计数++；
}
}
如果（计数>0）
{
比较=假；
}否则
{
比较=正确；
}
System.out.println（比较）；
}
}

我在bat右边注意到的一个错误是，您将数组声明为Int[]，这不是java关键字，实际上是Int[]。此代码检查数组，如果数组中的值彼此不相等，则返回false。如果数组中的值彼此相等，则程序返回true。
如果数组元素相等，则只需将第一个元素与其余元素进行比较，因此问题的更好解决方案如下：
>
public static boolean bruteforce(int[] input) {
     for(int i = 1; i < input.length; i++) {
         if(input[0] != input[i]) return false;
     }

     return true;
}

公共静态布尔暴力（int[]输入）{
for（int i=1；i

对于这个简单的算法，您不需要多个循环。希望这能有所帮助。
如果您想检查所有元素是否都具有相同的值，那么您可以用一种更简单的方法

int arr = {3,4,5,6};

int value = arr[0];


flag notEqual = false;

for(int i=1;i < arr.length; i++){

     if(!arr[i] == value){
           notEqual = true;
           break;
     }

}

if(notEqual){
     System.out.println("All values not same");
}else{
     System.out.println("All values same);
}

intarr={3,4,5,6}；
int值=arr[0]；
标志notEqual=false；
对于（int i=1；i
您只需要一个循环，并应在适用的情况下尽快返回
false
（即遇到与第一个循环不匹配的元素时）

您还需要考虑输入数组为
null
或只有一个元素的边缘情况

尝试类似的东西，我根据您提供的代码对其进行了最低限度的修改

public class BruteForceTest {

    public static boolean bruteforce(int[] input) {

        // NOTE: Cover the edge cases that the input array is null or has one element.
        if (input == null || input.length == 1)
            return true; // NOTE: Returning true for null is debatable, but I leave that to you.

        int compare = input[0]; // NOTE: Compare to the first element of the input array.

        // NOTE: Check from the second element through the end of the input array.
        for (int i = 1; i < input.length; i++) {
            if (input[i] != compare)
                return false;
        }

        return true;

    }

    public static void main(String[] args) {

        int[] denominator = {3,3,4,3};
        boolean compare = bruteforce(denominator);

        // FORNOW: console output to see where the first check landed
        System.out.print("{3,3,4,3}:\t");
        if (compare)
            System.out.println("Yup!");
        else
            System.out.println("Nope!");

        // NOTE: a second array to check - that we expect to return true
        int[] denominator2 = {2,2};
        boolean compare2 = bruteforce(denominator2);

        System.out.print("{2,2}:\t\t");
        if (compare2)
            System.out.println("Yup!");
        else
            System.out.println("Nope!");

        /*
         *  NOTE: edge cases to account for as noted below
         */

        // array with one element
        int[] denominator3 = {2};
        System.out.print("{2}:\t\t");
        if (bruteforce(denominator3))
            System.out.println("Yup!");
        else
            System.out.println("Nope!");

        // null array
        System.out.print("null:\t\t");
        if (bruteforce(null))
            System.out.println("Yup!");
        else
            System.out.println("Nope!");

    }

}

如果您对测试数组相等感兴趣（而不是自己编写此测试），那么您可以使用
Arrays.equals（theArray，theOtherArray）
试试

Integer[]    array = {12,12,12,12};
Set<Integer> set   = new HashSet<Integer>(Arrays.asList(array));
System.out.println(set.size()==1?"Contents of Array are Same":"Contents of Array are NOT same");

Integer[]数组={12,12,12,12}；
Set=newhashset（Arrays.asList（array））；
System.out.println（set.size（）=1？“数组内容相同”：“数组内容不相同”）；

说明：

将数组添加到集合中并检查大小os集合，如果它是1，则内容相同，否则不相同。
这是因为如果第一个元素等于第二个元素，则立即返回true。需要检查它们是否不相等，如果不相等，则返回false。如果它们从不相等，则在结尾返回true。此外，还可以从b中获取索引ounds异常。@Carlos Bobbiescas谢谢，最后我得到的结果是上面数组的return false。但是，是的，如果所有元素都是相同的值，它会给出超出范围的索引。我如何解决这个问题？
if（输入[I+1]==compare）{
当
i==input.length-1
是AFA的罪魁祸首时，
IndexOutOfBoundsException
。这很简洁，但不能解释
input
可能是
null
。该方法应该考虑到这种边缘情况。谢谢，@Oussama Bouguerne，但数组元素不是静态的。我的意思是，它会根据对用户输入。是的@J0e3gan我知道这一点，但忘了包括在内，谢谢提醒。@user3790782我上面写的方法适用于任何输入大小，尽管如果你给它较大的输入大小，它会很慢。这是关于测试给定数组中所有元素的相等性，而不是测试两个数组的相等性。@J0e3gan，与之不同
a.equals（b）
，当且仅当两个数组以相同的顺序包含相同的元素时才会返回true。对
Int[]
与
Int[]
的调用很好。我忘了在使用OP的代码时我立即更正了这一点。：}这个实现看起来是可行的，但它也会不必要地迭代数组中的每个元素——当元素的不平等性已经确定时；在大的输入上，这会造成伤害：你需要一个有条件的
break
或
return
来避免这种情况。是的，这似乎是正确的，谢谢你的纠正。非常感谢我想你是指
newhashset（Arrays.asList（array））
，而不是
newhashset（Arrays.asList（array1））
。此外，采用这种方法的
bruteforce
的实现还应考虑到输入数组为
null
@J0e3gan感谢您的编辑，这是一个键入错误：）
Integer[]    array = {12,12,12,12};
Set<Integer> set   = new HashSet<Integer>(Arrays.asList(array));
System.out.println(set.size()==1?"Contents of Array are Same":"Contents of Array are NOT same");