Question

我正在尝试编写一个可以在数组中找到重复值的代码。所以，我写下了以下代码：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        //System.out.println("Please enter the length of Array: ");
        int[] array = new int[6];
        for(int i =0; i<array.length;i++) {
            System.out.println("Enter value for index "+i+":");
            array[i] = sc.nextInt();
            }

        FindDuplicateInArray obj = new FindDuplicateInArray();

        obj.findDupicateInArray(array);
    }

    public void findDupicateInArray(int[] a) {
        //int pointer = a[0];
        int count=0;
        for(int j=0;j<a.length;j++) {
            for(int k =j+1;k<a.length;k++) {
                if(a[j]==a[k] && j!=k && j<k && count<=1) {
                    count++;
                    if(count==1)
                    System.out.println(a[j]);

                }

            }


        }

    }

但我没有得到预期的输出，例如：

如果我给出值1,2,1,4,3,1，那么它会成功找到重复值1.
但是如果我在数组中提供2组重复值，它仍然会找到第一个副本。例如1,2,1,2,1,3。它仅输出1。

我发现结果不正确的原因是计数条件，即count设置为大于1，并且如果条件不匹配，则不匹配。

所以，我试图在一次循环迭代后将计数器重置为0，现在它给出了所有重复值，但重复值打印了两次。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        //System.out.println("Please enter the length of Array: ");
        int[] array = new int[6];
        for(int i =0; i<array.length;i++) {
            System.out.println("Enter value for index "+i+":");
            array[i] = sc.nextInt();
            }

        FindDuplicateInArray obj = new FindDuplicateInArray();

        obj.findDupicateInArray(array);
    }

    public void findDupicateInArray(int[] a) {
        //int pointer = a[0];
        int count=0;
        for(int j=0;j<a.length;j++) {
            for(int k =j+1;k<a.length;k++) {
                if(a[j]==a[k] && j!=k && j<k && count<=1) {
                    count++;
                    if(count==1)
                    System.out.println(a[j]);

                }

            }
            **count = 0;**

        }

    }

e.g。输入：1,2,1,2,1,2，输出：1 2 1 2

请建议如何获得正确的结果。

Answer 1

我不喜欢使用Streams或smth hight-level来解决algorythmic问题;只有普通的java。所以这是我的解决方案：

public static Set<Integer> findDuplicateInArray(int... arr) {
    Set<Integer> unique = new HashSet<>();
    Set<Integer> duplicate = new HashSet<>();

    for (int val : arr)
        (unique.contains(val) ? duplicate : unique).add(val);

    return duplicate;
}

如果您能够修改inc arr，那么只需进行一些小修改，即可退出Set<Integer> unique。

Answer 2

你是对的，我刚刚更新了你的方法，我希望你能理解你的错误是什么：

public void findDupicateInArray(int[] a) {
        int count=0;
        for(int j=0;j<a.length;j++) {
            for(int k =j+1;k<a.length;k++) {
                if(a[j]==a[k]) {
                    count++;
                }
            }
            if(count==1)
               System.out.println(a[j]);
            count = 0;
        }
    }

尽管如此，这将使您的代码正常运行，这并不意味着您已经编写了最佳代码。

Answer 3

也许将数组转换为列表更容易，并用一句话用Java 8流api制作所有逻辑：

        Integer[] numbers = new Integer[] { 1, 2, 1, 2, 1, 3 };
    List<Integer> listInteger = Arrays.asList(numbers);         
    listInteger.stream().filter(i -> Collections.frequency(listInteger, i) >1).collect(Collectors.toSet()).forEach(System.out::println);

输出

1
2

Answer 4

请查看以下代码，它会对您有所帮助。

我们必须计算每个元素的重复次数，然后在最后查找计数，这将告诉重复的数字。

    package com.java;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

public class FindDuplicateInArray {

    public static void main(String[] args) {

        int[] intArr = new int[] { 1, 2, 1, 2, 1, 3, 4, 6, 2, 8 };

        Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();

        for (int i = 0; i < intArr.length; i++) {
            // take first element and then matched complete array
            int temp = intArr[i];
            int count = 0;

            for (int j = 0; j < intArr.length; j++) {
                if (temp == intArr[j]) {
                    // element matched -- break
                    count++;
                }
            }
            map.put(temp, count);
        }

        Set<Integer> duplicate = new LinkedHashSet<Integer>();
        Set<Integer> noDuplicate = new LinkedHashSet<Integer>();

        for (int i = 0; i < intArr.length; i++) {
            if (map.containsKey(intArr[i])) {
                System.out.println("Key :" + intArr[i] + " Value : " + map.get(intArr[i]));

                if (map.get(intArr[i]) > 1) {
                    // means repeated character
                    duplicate.add(intArr[i]);

                } else {
                    // non repeated character
                    noDuplicate.add(intArr[i]);
                }
            }
        }

        System.out.println("Duplicate Chars : " + Arrays.toString(duplicate.toArray()));
        System.out.println("No Duplicate Chars : " + Arrays.toString(noDuplicate.toArray()));

    }

}

在java中查找数组中的重复值

4 个答案: