1

我最近用 Python 做了一个非常简单的练习程序，它接受用户输入并掷骰子。代码是：

import random
import sys
import math

def roll(rolls, sides, results):
    for rolls in range(1, rolls + 1):
        result = random.randrange(1, sides + 1)
        print result
        results.append(result)
def countf(rolls, sides, results):
    i = 1
    print "There were", rolls, "rolls."
    for sides in range(1, sides + 1):
        if results.count(i) != 1:
            print "There were", results.count(i), i,"s."
        else:
            print "There was", results.count(i), i
        i = i + 1
        if i == sides:
            break
    rolls = input("How many rolls? ")
        sides = input("How many sides of the die? ")
        results = []

        roll(rolls, sides, results)
        countf(rolls, sides, results)

（实际上这是一个更大程序的一部分，所以我不得不剪切'n'paste 位，我可能错过了一些东西）。

所以我决定把它翻译成Java。请注意这里的算法：获取随机数，将其打印，将其附加到数组中，然后在最后计算数组中每个数字的数量，并打印出该值。问题是，我不知道如何someArray.count(someIndex)在 Java 语法中做等效的操作。所以到目前为止，我的 Java 程序看起来像这样：

import java.util.*;

public class Dice {
    static Scanner input = new Scanner(System.in);
    public static void main(String[] args) {
        final static int TIMES_TO_ROLL = getInt("Times to roll?");
        Random flip = new Random();
        int[] results = new int[TIMES_TO_ROLL];
        for (int i = 0; i < TIMES_TO_ROLL; i++) {
            int result = flip.nextInt(6);
            System.out.println(result);
            results[i] = result;
        }
    }
    public static int getInt(String prompt) {
        System.out.print(prompt + " ");
        int integer = input.nextInt();
        input.nextLine();
        return integer;
    }
}

那么有人可以帮我处理数组计数代码吗？我知道这可能不是一个已定义的方法，因为 Python毕竟是更高级别的，所以我可以制作自己的数组计数方法，但我想知道 Java 是否像 Python 一样具有预定义的方法。

编辑：我管理这样的事情：

public static int arrayCount(int[] array, int item) {
    int amt = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == item) {
            amt++;
        }
        else {
            amt = amt;
        }
    }
    return amt;
}

编辑：只是出于兴趣，假设我使用命令提示符来运行我的 Java 程序和 Python.exe（Python 的命令提示符控制台），哪个会更快（换句话说，对于相同的代码，哪种语言的性能更好？ )?

4

6 回答 6

7

您可以使用 HashMap 来存储结果。

如果新号码不在您的地图中，则将其添加为“1”作为初始值。如果存在，则将“+1”添加到当前地图值。

要显示值，您只需在 for each 循环中迭代您的条目。

于 2012-06-15T15:28:52.657 回答
5

解决方案是将数组转换为 List，然后使用以下Collections.frequency方法：

List<Integer> resultList = Arrays.asList(results);
int freq = Collections.frequency(resultList, 4);

您也可以ArrayList从一开始就使用，为您节省转换：

List<Integer> result = new ArrayList<Integer>();
// add results
int freq = Collections.frequency(result, 4);

请参阅此处的集合文档

编辑：如果性能是一个问题（如评论中所建议的那样），那么也许您想将数组的每个索引用作计数器，如下所示：

    Random flip = new Random(SIDES);
    int[] counters = new int[SIDES];
    for (int i = 0; i < TIMES_TO_ROLL; i++) {
        int result = flip.nextInt;
        counters[result] = counters[result]+1;
    }

请注意，您不再需要在最后进行计数，因为您已经获得了数组中的所有计数器，并且没有计算散列的开销。

于 2012-06-15T15:36:42.617 回答
3

有几个库可以为您执行此操作：

  1. Google Guava 的MultiSet
  2. Apache Common 的包

但是对于如此简单的事情，您可能会认为额外的库有点过分。

您也可以自己使用int[]. 假设您的骰子使用整数，让滚动的数字引用数组中的索引，然后增加该索引处的值。当您需要检索给定数字的值时，请通过索引查找其值。

private static final int NUMBER_DICE_SIDES = 6;
public static void main(String[] args) {
    final static int TIMES_TO_ROLL = getInt("Times to roll?");
    Random flip = new Random(NUMBER_DICE_SIDES);
    int[] results = new int[NUMBER_DICE_SIDES];
    for (int i = 0; i < TIMES_TO_ROLL; i++) {
        int result = flip.nextInt;
        System.out.println(result);
        results[result]++;
    }

    for(int i = 0; i < NUMBER_DICE_SIDES; ++i) {
        System.out.println((i+1)+"'s: " + arraysCount(results, i));
    }
}

public static int arrayCount(int[] array, int item) {
    return array[item];
}
于 2012-06-15T15:36:14.537 回答
3

集合中有一种频率方法

 int occurrences = Collections.frequency(listObject, searchItem);

集合的 Java 文档

于 2012-06-15T15:38:08.763 回答
1

据我所知，没有定义方法来返回数组中特定元素的频率。如果您要编写自定义方法，只需遍历数组，检查每个值，如果该值与您所追求的元素匹配，则增加一个计数器。

所以像：

// in this example, we assume myArray is an array of ints
private int count( int[] myArray, int targetValue) {
    int counter = 0;
    for (int i = 0 ; i < myArray.length; i++ ) {
        if (myArray[i] == targetValue) {
            counter++;
        }
    }
    return counter;
}

当然，如果您想找到数组中所有唯一值的频率，这可能会非常低效。

另外，为什么要使用 7 面模具？nextInt()将Random返回一个从 0 到但不包括最大值的数字。因此，您的骰子将返回 0 到 6 的值。对于六面骰子，您需要 a new Random(6);，然后将掷骰数增加 1 以获得从 1 到 6 的值：flip.nextInt() +1;。

于 2012-06-15T15:29:12.267 回答
0 
class FindOccurrence {


  public static void main (String[]args) {

    int myArray[] = {5, 8, 5, 12, 19, 5, 6, 7, 100, 5, 45, 6, 5, 5, 5};
    int numToFind = 5;
    int numberOfOccurrence = 0;

    for (int i=0; i < myArray.length; i++) {

        if (numToFind == myArray[i]) { 
            numberOfOccurrence++;

        }

    }
    System.out.println("Our number: " + numToFind);
    System.out.println("Number of times it appears: " + numberOfOccurrence);
}
}
于 2014-07-27T07:38:23.827 回答