Java 如何创建一个方法接收一个数组并查找一个数字的所有发生项，然后返回一个包含它发生的所有索引的新数组

我一直在为我的java课程做一些家庭作业，最后一部分我有点不知所措。基本上，家庭作业是教如何传递数组，最后一部分是有一个传递数组和要搜索的数字的方法

这就是我需要做的事情的确切措辞：

编写并测试一个方法findAll（），该方法创建并返回一个包含 目标值每次出现的索引。返回长度为0的空数组 如果目标值未出现，则不包含任何内容

到目前为止，我掌握的代码是：

public int[] findAll(int arr[], int num)
{
    int indexNum = 0;
    int arrSize = 1;
    int newArr[] = new int[arrSize];

    while (indexNum < arr.length)
    {
        if (arr[indexNum] == num)
        {
            indexNum += indexNum;


            for (int i = 0; i < arrSize; ++i)
                newArr[i] = indexNum;

            arrSize++;
        }

    } 
    return newArr;

}

public void printArray(int arr[])
{
    //use for each loop here to use each array element
    for (int e : arr)
        System.out.print(e + " ");
    System.out.println();
}

public int[]findAll（int arr[]，int num）
{
int indexNum=0；
int arrSize=1；
int newArr[]=新int[arrSize]；
while（indexNum

这编译得很好，但由于某种原因，我得到了一个越界异常

---

谢谢你的帮助

您将获得越界异常，因为

newArr

最多可以容纳一个值。您需要创建一个足够大的数组，以包含需要返回的最大索引数。保留一个单独的int变量来表示实际找到的整数。循环完成后，创建一个大小完全正确的新结果数组，并使用System.arraycopy将找到的索引复制到结果数组中，然后返回该结果数组。

请尝试使用此选项以确定大小。运行这个类，它会告诉您其中的

findAll（）

方法有什么问题

public class ArrayFinderHomework {
    private static ArrayFinderHomework finder = new ArrayFinderHomework();

    public int[] findAll(int arr[], int num) {
        return new int[]{99999};
    }

    public static void main(String args[]) {
        boolean success = true;
        success &= withEmptyArray_returnsEmptyArray();
        success &= withNoMatches_returnsEmptyArray();
        success &= withOneMatch_returnsMatchingIndex();
        success &= withTwoMatches_returnsMatchingIndices();
        success &= withFiveMatches_returnsMatchingIndices();
        success &= withConsecutiveMatches_findsAllMatches();
        success &= withOneMatchAtStart_findsTheMatch();
        success &= withOneMatchAtEnd_findsTheMatch();
        if (success) {
            System.out.println("It works!");
        } else {
            System.out.println("Sorry, fix the problems and try again.");
        }
    }

    private static boolean withEmptyArray_returnsEmptyArray() {
        int[] empty = {};
        int[] matches = finder.findAll(empty, 99);
        if (matches.length == 0) {
            return true;
        }
        System.out.println("It should return an empty array if passed an empty array");
        return false;
    }

    private static boolean withNoMatches_returnsEmptyArray() {
        int[] noMatchingElements = {1, 2, 3, 4, 5};
        int[] matches = finder.findAll(noMatchingElements, 99);
        if (matches.length != 0) {
            System.out.println("It should return an empty array if no matches are found");
            return false;
        }
        return true;
    }

    private static boolean withOneMatch_returnsMatchingIndex() {
        int[] input = {1, 2, 3, 4, 5};
        int[] matches = finder.findAll(input, 3);
        if (matches.length == 1 && matches[0] == 2) {
            return true;
        }
        System.out.println("It should find '3' at index 2 in " + stringFor(input));
        return false;
    }

    private static boolean withTwoMatches_returnsMatchingIndices() {
        int[] input = {1, 2, 3, 2, 1};
        int[] matches = finder.findAll(input, 2);
        if (matches.length == 2 && matches[0] == 1 && matches[1] == 3) {
            return true;
        }
        System.out.println("It should find '2' at indices 1 and 3 in " + stringFor(input));
        return false;
    }

    private static boolean withFiveMatches_returnsMatchingIndices() {
        int[] input = {1, 2, 1, 2, 1, 2, 1, 2, 1, 2};
        int[] matches = finder.findAll(input, 2);
        if (matches.length == 5 && matches[0] == 1 && matches[1] == 3
                && matches[2] == 5 && matches[3] == 7 && matches[4] == 9) {
            return true;
        }
        System.out.println("It should find '2' at indices 1, 3, 5, 7, and 9 in " + stringFor(input));
        return false;
    }

    private static boolean withConsecutiveMatches_findsAllMatches() {
        int[] input = {1, 2, 2, 2, 1};
        int[] matches = finder.findAll(input, 2);
        if (matches.length == 3 && matches[0] == 1 && matches[1] == 2 && matches[2] == 3) {
            return true;
        }
        System.out.println("It should find '2' at indices 1, 2, and 3 in " + stringFor(input));
        return false;
    }

    private static boolean withOneMatchAtStart_findsTheMatch() {
        int[] input = {1, 2, 3, 4, 5};
        int[] matches = finder.findAll(input, 1);
        if (matches.length == 1 && matches[0] == 0) {
            return true;
        }
        System.out.println("It should find '1' index 0 in " + stringFor(input));
        return false;
    }

    private static boolean withOneMatchAtEnd_findsTheMatch() {
        int[] input = {1, 2, 3, 4, 5};
        int[] matches = finder.findAll(input, 5);
        if (matches.length == 1 && matches[0] == 4) {
            return true;
        }
        System.out.println("It should find '5' index 4 in " + stringFor(input));
        return false;
    }

    private static String stringFor(int[] array) {
        StringBuilder result = new StringBuilder();
        result.append("[");
        for (int i : array) {
            if (result.length() > 1) {
                result.append(",");
            }
            result.append(i);
        }
        return result.append("]").toString();
    }
}

你只能在纸上做这么多。有时，你不得不戳代码看看会发生什么

---

p.S.顺便说一句，不要试图一次完成所有工作。只需一次专注于解决其中一个场景。事实上，我建议大家抛开手头的东西，从零开始，以此作为指导。

好吧，所以我修正了代码，使其正常工作。出于某种原因，我认为可以少编写一点代码。你怎么认为？它确实有效，并以讲师想要的格式输出正确的信息，但他总是提出让代码干净、清晰和正确是件好事

public int[] findAll(int arr[], int num)
{
    int indexNum = 0;
    int arrSize = 0;

    // find all accutences of the target
    for(int x = 0; x < arr.length; x++)
    {
        if(arr[x] == num)
        {
            arrSize++;
        }
    }
    //create new array with the right occurence size
    int newArr[] = new int[arrSize];
    for(int x = 0; x < arr.length; x++)
    {
        if(arr[x] == num)
        {
            newArr[indexNum] = x;
            indexNum++;
        }
    }
    return newArr;
}

public void print(int arr[])
{
    System.out.print("{");
    int i;
    // print elements before the last, separated by commas
    for (i = 0; i < arr.length - 1; ++i)
        System.out.print(arr[i] + ", ");
    // print last element.  Careful here to handle length 0
    if (arr.length > 0)
        System.out.print(arr[i]);
    System.out.print("}\n");
}

public int[]findAll（int arr[]，int num）
{
int indexNum=0；
int arrSize=0；
//找到目标的所有能力
对于（int x=0；x0）
系统输出打印（arr[i]）；
System.out.print（“}\n”）；
}

很抱歉，您的逻辑完全不正确，您可能希望废弃此代码并在纸上重新思考，但在尝试编写代码之前，请先确定正确的逻辑。尽管我同意您的意见，因为代码不起作用，我一直在纸上写这将如何解决。你的评论没有提供多少帮助。如果您可以详细说明，这将非常有帮助。例如，即使您重新调整了数组的大小，此代码将做什么？：

For（int i=0；i

我想我理解您所说的，尽管我认为这就是arrSize所做的？每次它向newArr添加一个数字时，它都会递增，这样它就可以按需要变大。当程序执行以下语句时：

intnewarr[]=newint[arrSize]

，此时使用

arrSize

的值。当您稍后更改

arrSize

时，它不会更改分配的数组的大小。这完全有道理！谢谢。我将再次尝试并修改我的代码来解决这个问题。再次感谢您的帮助。我想我都明白了！如果返回的数组未排序，则此操作失败。假设家庭作业问题的最有可能的解决方案将返回一个排序数组，它不是规范的一部分。在测试解决方案的正确性时，您需要考虑到这一点。不幸的是，这也无助于OP追踪越界异常。@TedHopp：是的，我确实对解决方案施加了一个额外的、未指定的约束，但1）我认为这是一个合理的折衷，因为OP以这种方式理解代码会更简单，2）我认为这是解决问题的自然方向，3）根据原始要求，解决方案仍然是正确的。至于存在的问题，我只是回来建议从零开始，因为他自己挖了一个大洞。每次使用一项功能总是效果更好。教授可能不喜欢在数组中迭代两次。然而，这可能是内存效率最高的方法。以牺牲更多内存为代价，只需遍历一次数组：首先分配一个长度为

arr.length

的临时数组。当你计算你得到的点击数时，也要将每个点击数存储在临时arr中