Question

我编写了一个静态方法，它使用了4个内部循环设置，如下所示。我在运行时使用的堆上做了很多很多测试。它似乎生成成千上万的“int []”对象，我认为这些来自我已经实施的循环。

我似乎找不到解决这个内存问题的方法，我需要循环，但是我不需要为每个循环创建大量的int []对象，这只是浪费！这些循环本身是否会导致这些错误？我有什么办法可以减少内存使用量，我正在考虑增强循环，但这可能是同样的问题......

谢谢！

    public static double[] calculateHand(final int card1, final int card2, final int card3,
        final int card4, final int card5)
{
    int ahead = 0, tied = 1, behind = 2;
    int[][] HP = new int[3][3];
    int[] HPTotal = new int[3];

    int ourrank = HandEval.hand5Eval(HandEval.encode(card1, card2, card3, card4, card5));

    int[] remainingCards = filterCardsFromDeck(card1, card2, card3, card4, card5);

    int kM = 1

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

        for (int k = kM; k < remainingCards.length; k++)
        {
            int index = -1;
            int oCard1 = remainingCards[i];
            int oCard2 = remainingCards[k];

            int opprank = HandEval.hand5Eval(HandEval
                    .encode(oCard1, oCard2, card3, card4, card5));

            if (ourrank > opprank)
            {
                index = ahead;
            }
            else if (ourrank == opprank)
            {
                index = tied;
            }

            else
            {
                index = behind;
            }

            HPTotal[index]++;
            int[] newArray = filter2Cards(remainingCards, oCard1, oCard2);

            int riverMinimumIndex = 1;
            for (int turnIndex = 0; turnIndex < newArray.length; turnIndex++)
            {

                for (int riverIndex = riverMinimumIndex; riverIndex < newArray.length; riverIndex++)
                {

                    int turnCard = newArray[turnIndex];
                    int riverCard = newArray[riverIndex];
                    int ourbest = HandEval.hand7Eval(HandEval.encode7(card1, card2, card3, card4,
                            card5, turnCard, riverCard));

                    int oppbest = HandEval.hand7Eval(HandEval.encode7(oCard1, oCard2, card3, card4,
                            card5, turnCard, riverCard));

                    if (ourbest > oppbest)
                    {
                        HP[index][ahead]++;
                    }

                    else if (ourbest == oppbest)
                    {
                        HP[index][tied]++;
                    }

                    else
                    {
                        HP[index][behind]++;
                    }
                }
                riverMinimumIndex++;
            }
        }
        kM++;
    }

    .....

    return result;
}

Answer 1

在该方法中有四个位置可以创建（或可能创建）数组：

int[][] HP = new int[3][3];
int[] HPTotal = new int[3];
...
int[] remainingCards = filterCardsFromDeck(card1, card2, card3, card4, card5);
...
int[] newArray = filter2Cards(remainingCards, oCard1, oCard2);

（你可能会调用其他一些方法创建...并丢弃......临时数组。应该很容易发现它们。）

前三次在您的方法每次调用时发生一次，可能不是一个重大问题。最后一个发生在第二级循环中，并且（如果我的阅读正确）将执行O(N**2)次N是卡的数量。

该怎么办？（显而易见的答案就是不管它，除非你有明确的证据表明它会影响应用程序性能。但我认为你已经过去了。）

我能想到的最好的方法是重构代码，以便filter2Cards将现有数组作为参数，并用过滤后的卡填充它。它需要返回一个int，给出添加到数组中的值的数量，以下代码需要使用此值而不是数组的长度。然后将数组的创建移到最外层循环之前。

显然，这会使您的代码更加复杂。这是你支付的罚款......

Answer 2

我的猜测就是像你所说的那样的堆通胀会被作为虚拟机开发的一部分被捕获。它不是不可能你看到了VM的问题，但是如果你没有发布其余的代码，我的猜测是问题不仅仅是循环而且更可能是你引入的东西你的其他代码。如果您发布，也许我们可以提供更多帮助。

大量内存被用在几个内部循环中

2 个答案: