Question

我最近在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。请注意这里的算法：获取随机数，打印它，将其附加到数组，然后计算最后数组中每个数字的数量，并打印出该值。问题是，我不知道如何在Java语法中执行等效的someArray.count(someIndex)。所以到目前为止我的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的命令提示符控制台），哪一个会更快（换句话说，对于相同的代码，哪种语言有更好的表现？）？

Answer 1

您可以使用HashMap存储结果。

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

要显示值，您只需要迭代每个循环中的条目。

Answer 2

解决方案是将数组转换为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);

请参阅收藏集文档here

编辑：如果性能是一个问题（如评论中所示），那么您可能希望将数组的每个索引用作计数器，如下所示：

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

请注意，由于您已经获得了数组中的所有计数器并且没有计算哈希值的开销，因此您不再需要在结束时进行计数。

Answer 3

有几个库可以帮到你：

Google Guava的MultiSet
Apache Common的Bag

但是对于这么简单的事情，你可能会认为额外的库有点过分。

您也可以使用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];
}

Answer 4

集合中有一种频率方法

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

Java doc for collections

Answer 5

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

类似于：

// 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;
}

当然，如果你想在数组中找到 all 的唯一值的频率，这可能会效率极低。

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

Answer 6

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

计算元素在数组中出现的次数 - Java

6 个答案: