查找数组中出现的重复数-Java

我不能对这件事耿耿于怀。需要找到重复的，我找到了。现在剩下的就是打印一个副本在数组中出现的次数。我刚开始学习Java，所以需要硬编码才能理解。花上最后两天的时间想办法解决，但运气不好。。任何帮助都会很好！谈话很便宜，下面是代码

import java.util.Arrays;
public class LoopTest {

    public static void main(String[] args) {

        int[] array = {12,23,-22,0,43,545,-4,-55,43,12,0,-999,-87};
        int positive_counter = 0;
        int negative_counter = 0;


        for (int i = 0; i < array.length; i++) {
            if(array[i] > 0) {
                positive_counter++;
            } else if(array[i] < 0) {
                negative_counter++;
            }
        }

        int[] positive_array = new int[positive_counter];
        int[] negative_array = new int[negative_counter];

        positive_counter = 0;
        negative_counter = 0;

        for (int i = 0; i < array.length; i++) {
            if(array[i] > 0) {
                positive_array[positive_counter++] = array[i];
            } else if(array[i] < 0) {
                negative_array[negative_counter++] = array[i];
            }
        }

        System.out.println("Positive array: " + (Arrays.toString(positive_array)));
        System.out.println("Negative array: " + (Arrays.toString(negative_array)));

        Arrays.sort(array);
        System.out.println("Array duplicates: ");
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if(array[i] == array[j]) {                    
                    System.out.println(array[j]);
                }

            }
        }
    }
}

导入java.util.array；
公共类循环测试{
公共静态void main（字符串[]args）{
int[]数组={12,23，-22,0,43545，-4，-55,43,12,0，-999，-87}；
int正计数器=0；
int负_计数器=0；
for（int i=0；i0）{
正_计数器++；
}else if（数组[i]<0）{
负_计数器++；
}
}
int[]正数数组=新的int[正数计数器]；
int[]负数组=新int[负计数器]；
正计数器=0；
负计数器=0；
for（int i=0；i0）{
正数组[正计数器++]=数组[i]；
}else if（数组[i]<0）{
负数组[负计数器++]=数组[i]；
}
}
System.out.println（“正数组：”+（Arrays.toString（正数组））；
System.out.println（“负数组：”+（Arrays.toString（负数组））；
数组。排序（数组）；
System.out.println（“数组副本：”）；
for（int i=0；i

由于您已经在对阵列进行排序，因此只需一个循环即可找到重复的阵列（它们将彼此相邻，对吗？）。因此，您可以执行以下操作：

            Arrays.sort(array);
            System.out.println("Array duplicates: ");
            int lastValueCount=1; //How many times we met the current value (at least 1 - this time)
            for (int i = 1; i < array.length; i++){        
                    if(array[i] == array[i-1])                     
                        lastValueCount++;   //If it is the same as the previous increase the count  
                    else {
                       if(lastValueCount>1) //If it is duplicate print it
                           System.out.println(array[i-1]+" was found "+lastValueCount+" times");
                       lastValueCount=1; //reset the counter
                    }
            }

---

你也可以使用一些Java的铃铛和口哨，比如把值插入地图或者类似的东西，但我想你是从算法的角度来看的，所以上面是一个简单的答案，只有一个循环，那么你永远不会使用它们，那么这种分离的目的是什么？ 我只是给你一个与你的问题相关的想法，最好是自己解决它，这样你就可以接触到Java

解决方案：可以使用字典键值对。遍历数组，将元素作为键放在字典中，将值作为零，在每次迭代中检查该键是否已经存在于字典中，只需增加其值。最后，所有值都是数组中出现的重复值

---

希望对你有帮助

一个简单的方法是使用地图。在不过度更改代码的情况下：

 for (int i = 0; i < array.length; i++) {
        int count = 0;
        for (int j = i + 1; j < array.length; j++) {
            if(array[i] == array[j]) {                    
                System.out.println(array[j]);
                count++;
            }
        }
        map.put(array[i], count);
  }

for（int i=0；i

文件：

编辑：作为一项建议，在您完成示例之后，您应该分析您的代码，找出哪些不必要，哪些可以做得更好，等等

---

是否需要所有的辅助阵列？所有的循环都是必要的吗？

从算法的角度来看，Veselin Davidov的答案是好的（效率最高）

在生产代码中，您更愿意这样编写：

Map<Integer, Long> result = 
    Arrays.stream(array)
          .boxed() //converts IntStream to Stream<Int>
          .collect(Collectors.groupingBy(i -> i, Collectors.counting()));

{0=2545=1，-4=1，-22=1，-87=1，-999=1，-55=1，23=1，43=2，12=2}

---

您可以通过为重复值创建数组列表来执行此操作：-

Arrays.sort(array);
System.out.println("Array duplicates: ");

ArrayList<Integer> duplicates = new ArrayList<Integer>(); 

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if(j != i && array[i] == array[j] && !duplicates.contains(array[i])){
            duplicates.add(array[i]);
            System.Out.println(duplicates[duplicates.size()-1]);
        }
    }
}

array.sort（数组）；
System.out.println（“数组副本：”）；
ArrayList duplicates=新的ArrayList（）；
for（int i=0；i

公共静态无效查找副本（字符串s）{

char[]charArray=s.toCharArray（）；
ArrayList duplicateList=新的ArrayList（）；
System.out.println（Arrays.toString（charArray））；
对于（int i=0；i）创建一个映射，其中key是一个数字，value是出现的次数。您不在任何地方定义map变量(（：如果数组没有排序的话就不会那么容易了。但是+1是的！这非常好，事情看起来更清楚了。谢谢！回答得好，但是流可能是一个过火的想法，因为OP只是刚刚开始学习java。@TA我同意。这个答案更适合未来的谷歌用户，因为计算一些发生的事件ces是一个常见的需求。这是我的教授给我的许多测试之一，我想练习和理解数组和循环。我想自己完成它，但没有运气。谢谢你的输入！欢迎使用SO！当你用代码回答问题时，请解释一下你的问题。在这种情况下，有更多的答案，因此可以展示你的优点s
System.out.println(result);

Arrays.sort(array);
System.out.println("Array duplicates: ");

ArrayList<Integer> duplicates = new ArrayList<Integer>(); 

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if(j != i && array[i] == array[j] && !duplicates.contains(array[i])){
            duplicates.add(array[i]);
            System.Out.println(duplicates[duplicates.size()-1]);
        }
    }
}

char[] charArray=s.toCharArray();
ArrayList<Character> duplicateList = new ArrayList<>();
System.out.println(Arrays.toString(charArray));

for(int i=0 ; i<=charArray.length-1; i++){
    if(duplicateList.contains(charArray[i]))
        continue;
    for(int j=0 ; j<=charArray.length-1; j++){
        if(i==j)
            continue;

        if(charArray[i] == charArray[j]){
            duplicateList.add(charArray[j]);
            System.out.println("Dupliate at "+i+" and "+j);
        }
    }
}