如何使用Java查找数组中不同重复值的数量答案

【问题标题】：How to find the number of different duplicate values in an array with Java如何使用Java查找数组中不同重复值的数量
【发布时间】：2014-02-10 17:18:29
【问题描述】：

我正在处理的程序有一个小问题，我需要能够查看 Java 中的数组并找到该数组中不同重复项的数量，例如，如果数组的值是 4、6， 4 我需要能够显示：

有： 2 个长度为 1 的单词（4 个字符） 1 个长度为 2 的单词（6 个字符）

我目前得到的是-

public class wordLength {

public static void main(String[] args) {

    String userInput1 = "Owen Bishop Java ";
    String [] inputArray = userInput1.split(" ");


    for (int i = 0; i < inputArray.length; i++) {
        int length = inputArray[i].length(); 
        int inputArray2 = length;
        System.out.println(inputArray2);        
    }
}

}

目前这会在有空格时将字符串拆分为一个数组，然后查找并打印数组中每个单词的长度，我需要显示相同长度的单词数量。
我真的是 Java 新手，很欣赏这可能是一个非常简单的问题，但任何帮助将不胜感激，谢谢。

【问题讨论】：

您可以对数组进行排序，然后计算次数inputArray[i].length() == inputArray[i+1].length()。

标签： java arrays duplicates words

【解决方案1】：

如果不编写整个内容（或使用 3rd 方库 - 我注意到您是 Java 新手，所以我们不要让事情复杂化），我会考虑以下内容。

使用Map<Integer,Integer> 来存储特定长度的单词数。例如填充：

Map<Integer, Integer> counts = new HashMap<Integer, Integer>();    
for (String word : words) {
    Integer current = counts.get(word.length());
    if (current == null) {
       current = 0;
    }
    current++;
    counts.put(word.length(), current);   
}

然后遍历它以输出每个字数的字数。请注意，上面使用了boxing。

使用Map 的优点是（与您的数组不同）您无需担心空计数（例如，如果您没有长度为 5 的单词，您将没有条目）。根据您的用例，这可能/可能不是问题。

【讨论】：

我喜欢这个，因为它包括解释，以及对所用技术的引用。

【解决方案2】：

您可以创建一个长度为 20（或英文的最大字长）的 int 数组，并在打印该值之前增加索引值。

arr[length]++;

【讨论】：

您假设语言始终为英语，并且所处理的文本仅由合法单词组成。 OP 的声明都不支持这些假设。

【解决方案3】：

public class wordLength {

    public static void main(String[] args) {

        String userInput1 = "Owen Bishop Java ";
        String [] inputArray = userInput1.split(" ");

        Map<Integer,Integer> wordLengths = new HashMap<Integer,Integer>();

        for (int i = 0; i < inputArray.length; i++) {
            int length = inputArray[i].length(); 
            if (wordLengths.containsKey(length))
                wordLengths.put(length, wordLengths.get(length) + 1);
            else
                wordLengths.put(length, 1);                               
        }

        for (Integer length : new TreeSet<Integer>(wordLengths.keySet()))
            System.out.println("Length: " + length + " Count: " + wordLengths.get(length));
        }
    }
}

【讨论】：

【解决方案4】：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;


public class wordLength {

public static void main(String[] args) {

String userInput1 = "Owen Bishop Java ";
String [] inputArray = userInput1.split(" ");
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();

for (int i = 0; i < inputArray.length; i++) {
    int length = inputArray[i].length(); 
    if(map.get(length)==null){
        map.put(length, 1);
    }
    else map.put(length, map.get(length)+1);
}

Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry pairs = (Map.Entry)it.next();
    System.out.println("words of length " +pairs.getKey() + " are " + pairs.getValue());
}

}
}

输出将是：

words of length 4 are 2
words of length 6 are 1

【讨论】：

【解决方案5】：

代码的开头看起来不错。您基本上想要跟踪（在我的理解中）是从字符串长度到发生这种情况的次数的映射。

public class wordLength {

    public static void main(String[] args) {

        String userInput1 = "Owen Bishop Java ";
        String [] inputArray = userInput1.split(" ");
        Map<Integer, Integer> counter = new HashMap<>();   //please note that I use the 'diamond' notation here, this is for Java 1.7 and higher.

        for (int i = 0; i < inputArray.length; i++) {
            int length = inputArray[i].length(); 
            Integer num = counter.get(length);
            if (num == null) {
                num = 1;
            }
            else {
                num++;
            }
            counter.put(length, num);
            //or counter.put(length, num == null ? 1 : num++); instead of the if-else
        }

        //print the results
        for (Entry<Integer, Integer> entry : map.entrySet()) {
            System.out.println("There are " + entry.getValue() + " words with length " + entry.getKey() + ".");
        }
    }  
}

arr[length]++; 之前提交的方法确实有效，但是使用了很多空间的方法。假设你只有长度为 20 及以上的单词，那么这个 arr 的前 20 个元素是无用的......

还请注意，您可以使用地图界面中的map.entrySet() 方法。使用此方法比使用 map.keySet() 并在此之后查找关联值更好。这为您节省了很多查找时间。（尤其是大量用户输入！！！）

【讨论】：

【解决方案6】：

上述问题我有两个解决方案

使用额外空间（即映射）来存储唯一值。复杂度 O(n) + Space(N) [N= #unique value]
没有多余的空间。对输入进行排序并计算值。复杂度 nLog(n) + n

第一个解决方案

创建一个映射以将每个唯一值存储为键并将其计数存储为值
遍历输入数组
如果值作为键存在，则递增计数器

如果map中确实存在值，则ELSE，然后输入值并将计数器设置为1

    private static void UniqueValueUsingMap(int[] a){
        //Map with 
        // key: unique values 
        // Value: count as each value (key)
        Map<Integer, Integer> store = new HashMap<Integer, Integer>(); 
        for (int i : a) {
            Integer key = Integer.valueOf(i);
            Integer count = null;
            if(store.containsKey(key)){
                count = store.get(key);
            }else{
                count = 0;
            }
            count++;
            store.put(key, count);
        }       
    }

第二种解决方案

对给定的数组 nlog(n) 进行排序。排序后所有相同的值将放在一起。
遍历排序数组
维护 2 个变量，即以前的值和当前值的计数器
值更改时，打印值/计数并重置计数器

注意：：int 默认为 0 初始值。需要为它添加额外的检查。

        private static void CountValueUsingSort(int[] a){
            //Sort the input array
            Arrays.sort(a);

            int currentValue = 0;
            int counter =0;

            for (int curr : a) {
                if(curr != currentValue){               
                    System.out.println("Value: " + currentValue + " Count:" + counter);
                    //Reset counter
                    counter = 0;
                }
                currentValue = curr;

                //increment Count
                counter++;
            }

        }

【讨论】：