Question

我正在处理一个程序的问题，我需要能够在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并且很欣赏这可能是一个非常简单的问题，但是非常感谢任何帮助，谢谢。

Answer 1

没有编写整个内容（或者使用第三方库 - 我注意到你是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的单词，则不会有条目）。根据您的使用情况，这可能/可能不是问题。

Answer 2

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

arr[length]++;

Answer 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));
        }
    }
}

Answer 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

Answer 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界面中的map.entrySet()方法。使用此方法比使用map.keySet()更好的编码实践，然后查找关联的值。这为您节省了大量的查找时间。（特别是用户输入量大!!!）

Answer 6

我有上述问题的2个解决方案

使用额外空间，即Map来存储唯一值。复杂度O（n）+空间（N）[N = #unique value]
没有多余的空间。对输入和计数值进行排序。复杂性nLog（n）+ n

第一个解决方案

创建一个地图，将每个唯一值存储为键，将其计数值作为值
迭代输入数组
如果值以密钥形式存在，则增加计数器

ELSE如果map中存在值，则将值和设置计数器设置为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++;
            }

        }

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

6 个答案: