在java数组中查找重复项_Java_Loops_For Loop

在java数组中查找重复项

java loops for-loop

在java数组中查找重复项,java,loops,for-loop,Java,Loops,For Loop,无论如何，我有一个非常简单的java程序来确定数组中的两个对象是否相同。然而，当我在一组唯一的对象上运行它时，它总是返回1个错误，如果我添加更多相同的对象，它将被视为正常这就是代码 int[] array= new int[] {1,245,324,523}; int size = array.length; int error=0; System.out.println(error); int i = 0; for(i=0; i<size;

无论如何，我有一个非常简单的java程序来确定数组中的两个对象是否相同。然而，当我在一组唯一的对象上运行它时，它总是返回1个错误，如果我添加更多相同的对象，它将被视为正常

这就是代码

int[] array= new int[] {1,245,324,523};

    int size = array.length;
    int error=0;
    System.out.println(error);

    int i = 0;
    for(i=0; i<size; i++){

        if(array[0] == array[i]){
            error= error +1;
        }
        System.out.println(error);
    }

1错误是因为您将数组[0]与数组[0]进行比较，后者当然等于自身

如果要查找所有成对重复项，则需要执行双循环：

for(int i=0;i<size;i++){
    for(int j=i+1;j<size;j++){
        if(array[i] == array[j]){
            if(i!=j){
                error = error + 1;
            }
        }
    }
}

您将从这段代码中注意到以下几点：

j从i+1开始，而不是从0开始。错误只会在输入时增加=J 第一个原因是，您轮流处理数组中的每个元素，以便与其他每个元素进行比较。当它在外循环中出现时，它已经与之前的元素进行了比较，不应该再与它们进行比较

第二个原因是，对于每个外部循环，您最终会将一个元素与自身进行比较。您不想将其算作错误。

1错误是因为您将数组[0]与数组[0]进行比较，这当然等于数组本身

如果要查找所有成对重复项，则需要执行双循环：

for(int i=0;i<size;i++){
    for(int j=i+1;j<size;j++){
        if(array[i] == array[j]){
            if(i!=j){
                error = error + 1;
            }
        }
    }
}

您将从这段代码中注意到以下几点：

第二个原因是，对于每个外部循环，您最终会将一个元素与自身进行比较。你不想把它算作一个错误。

你从0开始。因此，第一个测试是ifarray[0]==数组[0]

您总是会得到至少一个错误，因为当i=0时，数组[0]==数组[i]在第一次迭代时为真。

尝试双重嵌套for循环。像这样的

for (int i=0;i<size-1;i++){
  for (int j=i+1; j<size; j++) {
    error += (array[i] == array[j]) ? 1 : 0;
  }
}

尝试双嵌套for循环。像这样的

for (int i=0;i<size-1;i++){
  for (int j=i+1; j<size; j++) {
    error += (array[i] == array[j]) ? 1 : 0;
  }
}

在您的代码中

int i=0;
for(i=0;i<size;i++){
    if(array[0]==array[i]){    //this condition runs true only for the first time. as i=0 here
        error=error+1;
    }
    System.out.println(error); //now here you had put the println(error) outside the if()-condition therefore it will be printed repeatedly value of error which is 1
}

在您的代码中

int i=0;
for(i=0;i<size;i++){
    if(array[0]==array[i]){    //this condition runs true only for the first time. as i=0 here
        error=error+1;
    }
    System.out.println(error); //now here you had put the println(error) outside the if()-condition therefore it will be printed repeatedly value of error which is 1
}

您还需要考虑Java。使用Array.equals进行比较。参见文档和一些示例

您还需要考虑Java。使用Array.equals进行比较。请参阅文档和一些示例

如果要使用任何集合，您可以轻松找到阵列中的重复项

例如：

 public static void main(String[] args) {
    boolean containsDuplicate =false;
    int[] intArray = new int[] {1,245,324,1,523};
    List<Integer> myObj = new ArrayList<Integer>();
    for(int id : intArray){
        if(myObj.contains(id)){
            containsDuplicate = true;
            System.out.println("Duplicate");
        }else{
            myObj.add(id);
        }
    }

}

如果要使用任何集合，可以在数组中轻松找到重复项

例如：

 public static void main(String[] args) {
    boolean containsDuplicate =false;
    int[] intArray = new int[] {1,245,324,1,523};
    List<Integer> myObj = new ArrayList<Integer>();
    for(int id : intArray){
        if(myObj.contains(id)){
            containsDuplicate = true;
            System.out.println("Duplicate");
        }else{
            myObj.add(id);
        }
    }

}

下面的代码很好，但返回11。不确定这是否是预期的结果

public static void main(String[] args){
    int[] array = {23, 23, 0, 43, 545, 12, -55, 43, 12, 12, -999, -87, 12, 0, 0};
    int error = 0;
    for(int i=0;i<array.length;i++){
        for(int j=i+1;j<array.length;j++){
            if(array[i] == array[j]){
                if(i!=j){
                    error = error + 1;
                }
            }
        }
    }
    System.out.println(error);
}

我提出了一个有点复杂但希望更高级的解决方案

package myjavaprogram;
import java.util.Arrays;

public class TestClass1 {
    public static void main(String[] args){
        int[] array = {23, 23, 0, 43, 545, 12, -55, 43, 12, 12, -999, -87, 12, 0, 0};
        //int[] array = {23, -22, 0, 43, 545, 12, -55, 43, 12, 0, -999, -87, 12};
        //int[] array = {23, -22, 0, 23};
        //int[] array = {23, -22, 23};
        calculate_duplicates(array);        
    }

    private static void calculate_duplicates(int[] array) {
        calculateUniqueNumbers(array);
    }

    private static void calculateUniqueNumbers(int[] array) {
        Pair[] pairs = new Pair[array.length];
        initializePairsAtrray(pairs, array);
        printPairsAtrray(pairs);

        System.out.println("array.length="+array.length);
        System.out.println("--------------------");

        // update pairs array taking in account duplicates duplicates
        for(int i = 0; i < array.length; i++) {
            System.out.println("array[i]="+array[i] + " i="+i);
            for(int j = i+1; j < array.length; j++) {
                System.out.println("array[j]="+array[j]+" j="+j);

                if(array[i] == array[j] && pairs[j].useDuringCount == true) {
                    pairs[i].occurance_num++;

                    pairs[j].occurance_num = 0;
                    pairs[j].useDuringCount = false;
                }

                if(array[i] == 0) {
                    pairs[i].occurance_num = 0;                    
                }
                if(array[j] == 0) {
                    pairs[j].occurance_num = 0;
                    pairs[j].useDuringCount = false;
                }                
            }
            pairs[i].useDuringCount = false;
            System.out.println("--------------------");
        }                
        printPairsAtrray(pairs);

        // calculate general number of duplicates (numbers whick are repeated 
        // in initial array)
        System.out.println("Duplicates in array:"+
                calculateDuplicatesNumber(pairs));        
    }

    private static void initializePairsAtrray(Pair[] pairs, int[] array) {
        for(int i=0;i<pairs.length;i++) {
            Pair p = new Pair();            
            p.occurance_num = 1;
            p.value = array[i];
            p.useDuringCount = true;
            pairs[i] = p;
        }
    }

    private static void printPairsAtrray(Pair[] pairs) {
        System.out.println("--------------------");
        for(int i=0;i<pairs.length;i++) {
            System.out.println("pairs["+i+"].occurance_num="+pairs[i].occurance_num);
            System.out.println("pairs["+i+"].value="+pairs[i].value);
            System.out.println("pairs["+i+"].useDuringCount="+pairs[i].useDuringCount);
            System.out.println("--------------------");
        }
    }

    private static int calculateDuplicatesNumber(Pair[] pairs) {
        System.out.println("-------------------- Duplicates:");
        int duplicates_num = 0;
        for(int i=0;i<pairs.length;i++) {
            if(pairs[i].occurance_num > 1) {
                duplicates_num++;
                System.out.println("number: "+pairs[i].value+" occurance_num " + pairs[i].occurance_num);
            }
        }
        return duplicates_num;
    }        
}    

class Pair {
    int value;
    int occurance_num;
    boolean useDuringCount;
}

Mykola

下面的代码很好，但返回11。不确定这是否是预期的结果

public static void main(String[] args){
    int[] array = {23, 23, 0, 43, 545, 12, -55, 43, 12, 12, -999, -87, 12, 0, 0};
    int error = 0;
    for(int i=0;i<array.length;i++){
        for(int j=i+1;j<array.length;j++){
            if(array[i] == array[j]){
                if(i!=j){
                    error = error + 1;
                }
            }
        }
    }
    System.out.println(error);
}

我提出了一个有点复杂但希望更高级的解决方案

package myjavaprogram;
import java.util.Arrays;

public class TestClass1 {
    public static void main(String[] args){
        int[] array = {23, 23, 0, 43, 545, 12, -55, 43, 12, 12, -999, -87, 12, 0, 0};
        //int[] array = {23, -22, 0, 43, 545, 12, -55, 43, 12, 0, -999, -87, 12};
        //int[] array = {23, -22, 0, 23};
        //int[] array = {23, -22, 23};
        calculate_duplicates(array);        
    }

    private static void calculate_duplicates(int[] array) {
        calculateUniqueNumbers(array);
    }

    private static void calculateUniqueNumbers(int[] array) {
        Pair[] pairs = new Pair[array.length];
        initializePairsAtrray(pairs, array);
        printPairsAtrray(pairs);

        System.out.println("array.length="+array.length);
        System.out.println("--------------------");

        // update pairs array taking in account duplicates duplicates
        for(int i = 0; i < array.length; i++) {
            System.out.println("array[i]="+array[i] + " i="+i);
            for(int j = i+1; j < array.length; j++) {
                System.out.println("array[j]="+array[j]+" j="+j);

                if(array[i] == array[j] && pairs[j].useDuringCount == true) {
                    pairs[i].occurance_num++;

                    pairs[j].occurance_num = 0;
                    pairs[j].useDuringCount = false;
                }

                if(array[i] == 0) {
                    pairs[i].occurance_num = 0;                    
                }
                if(array[j] == 0) {
                    pairs[j].occurance_num = 0;
                    pairs[j].useDuringCount = false;
                }                
            }
            pairs[i].useDuringCount = false;
            System.out.println("--------------------");
        }                
        printPairsAtrray(pairs);

        // calculate general number of duplicates (numbers whick are repeated 
        // in initial array)
        System.out.println("Duplicates in array:"+
                calculateDuplicatesNumber(pairs));        
    }

    private static void initializePairsAtrray(Pair[] pairs, int[] array) {
        for(int i=0;i<pairs.length;i++) {
            Pair p = new Pair();            
            p.occurance_num = 1;
            p.value = array[i];
            p.useDuringCount = true;
            pairs[i] = p;
        }
    }

    private static void printPairsAtrray(Pair[] pairs) {
        System.out.println("--------------------");
        for(int i=0;i<pairs.length;i++) {
            System.out.println("pairs["+i+"].occurance_num="+pairs[i].occurance_num);
            System.out.println("pairs["+i+"].value="+pairs[i].value);
            System.out.println("pairs["+i+"].useDuringCount="+pairs[i].useDuringCount);
            System.out.println("--------------------");
        }
    }

    private static int calculateDuplicatesNumber(Pair[] pairs) {
        System.out.println("-------------------- Duplicates:");
        int duplicates_num = 0;
        for(int i=0;i<pairs.length;i++) {
            if(pairs[i].occurance_num > 1) {
                duplicates_num++;
                System.out.println("number: "+pairs[i].value+" occurance_num " + pairs[i].occurance_num);
            }
        }
        return duplicates_num;
    }        
}    

class Pair {
    int value;
    int occurance_num;
    boolean useDuringCount;
}

Mykola

由于数组[0]==array[0]，因此始终至少打印1。这里有问题吗？@user972183:您对iArray[0]==array[i]的看法是什么？因为array[0]==array[0]，所以它总是至少打印1。这里有问题吗？@user972183:您对iArray[0]==array[i]的想法是什么？我认为在您的双循环中，j应该始终从i+1开始。如果我=j是不必要的是的，呃。有一个小问题，因为索引将在最后一次外部迭代中以大小开始。当然，我们的用户可以知道该怎么做。我的目标是找出所有元素是否都是distint，我认为它仍然可以在没有外部循环的情况下工作，不管计数器有多少错误。但是如果它们不是错误，那么错误就不可能高于1？我认为在你的双循环中，j应该总是从I+1开始。如果我是，那就是第二秒=j是不必要的是的，呃。有一个小问题，因为索引将在最后一次外部迭代中以大小开始。当然，我们的用户可以知道该怎么做。我的目标是找出所有元素是否都是distint，我认为它仍然可以在没有外部循环的情况下工作，不管计数器有多少错误。但是，如果它们不是错误，那么错误就不可能超过一个？国际海事组织（IMO）公认的答案似乎能更有效地完成这项简单的任务。没有理由为使用更简单、可行的解决方案解决的问题增加复杂性添加额外的阵列。下一个循环遍历原始数组的每个元素。对于当前元素，迭代当前元素右侧数组的所有元素。如果发现相等，则将此元素放入一个附加数组中。您可以制作第二个数组以进行其他计算，或者只使用二维数组。接受的答案IMO似乎就是这样做的

这项工作效率更高。没有理由为使用更简单、可行的解决方案解决的问题增加复杂性添加额外的阵列。下一个循环遍历原始数组的每个元素。对于当前元素，迭代当前元素右侧数组的所有元素。如果发现相等，则将此元素放入一个附加数组中。您可以创建第二个数组以进行其他计算，或者只使用二维数组。