Java 能否将转换后的阵列与另一个转换后的阵列进行比较？

好的，我试着把问题说对，这样我就能得到我需要的帮助。我得到的是一个简单的钱包/硬币程序，它将字符串数组与另一个字符串数组进行比较。请原谅冗长的循环/嵌套循环/逻辑，因为在这个赋值中，我不能使用java数组和集合类中的方法。 这是一个课堂作业，所以请解释过程，而不仅仅是回答

（理论）：我认为我对两个已转换数组的比较是问题的原因，但我无法找出一种方法来比较数组列表中的每个元素与另一个数组列表中的每个元素

钱包类别：

import java.util.ArrayList;

/**
 * A purse holds a collection of coins.
 */
public class Purse
{
    private ArrayList<String> coins;

    /**
     * Constructs an empty purse.
     */
    public Purse()
    {
        coins = new ArrayList<String>();
    }

    /**
     * Add a coin to the purse.
     * 
     * @param coinName
     *            the coin to add
     */
    public void addCoin(String coinName)
    {
        coins.add(coinName);
    }

    /**
     * Returns a string describing the object.
     * 
     * @return a string in the format "Purse[coinName1,coinName2,...]"
     */
    public String toString()
    {
        String coinName1 = "Quarter";
        String coinName2 = "Dime";
        String coinName3 = "Nickel";
        String coinName4 = "Penny";

        String str = "Actual:"
                + "Purse["
                + (coinName1 + "," + coinName2 + "," + coinName3 + "," + coinName2)
                + "]";

        return str;
    }

    /**
     * Determines if a purse has the same coins in the same or different order
     * as another purse.
     * 
     * @param other
     *            the other purse
     * @return true if the two purses have the same coins in the same or
     *         different order, false otherwise
     */
    public boolean sameCoins(Purse other)
    {
        if (this.coins.size() != other.coins.size())
        {
            System.out.println("1");
            return false;
        }


        int matched = 0;
        for (int i = 0; i < this.coins.size(); i++)
        {
            for (int j = 0; j < other.coins.size(); j++)
            {
                if (this.coins.toArray() == other.coins.toArray())
                {
                    matched++;
                    System.out.println("2");
                    System.out.println(this.coins.toArray());
                    System.out.println(other.coins.toArray());
                    break;
                }
            }
        }
        return matched == this.coins.size();

    }

} 

输出为：

Actual:Purse[Quarter,Dime,Nickel,Dime]
Expected: Purse[Quarter,Dime,Nickel,Dime]
false
Expected: true
false
Expected: false

预期产出：

Actual:Purse[Quarter,Dime,Nickel,Dime]
Expected: Purse[Quarter,Dime,Nickel,Dime]
true
Expected: true
false
Expected: false

---

您的循环从不在

列表中查看，您只需在两个数组上重复检查
=
。您需要比较这些元素，如：

    for (int i = 0; i < this.coins.size(); i++)
    {
        if (!this.coins.get(i).equals(other.coins.get(i)))
        {
           return false;
        }
    }

如果您先对
列表进行排序，然后使用第一种最佳方法，则此方法显然效率极低。但是由于不能使用
Array
方法，我假设不能使用
TreeSet
或
Collections.sort（）

此代码始终返回
false
，因为它不比较两个数组的内容，它测试两个表达式是否引用同一个数组（即修改一个将修改另一个）

基本上，您需要计算每个列表中每种硬币的数量，然后比较结果。如果预先知道可能的硬币种类，这很容易：每种硬币都有两个变量（一个用于这个钱包，另一个用于另一个钱包）。如果不知道硬币的可能扭结，则必须使用
地图
“是相同的”有点不清楚，“参考/指向完全相同的对象（主要通过使用
=
-运算符在某个点实际将它们设置为相等来实现）”那就更好了。所以基本上你要说的是，我必须把字符串值设置为一个数值。然后将每个数组的总数与另一个数组的总数进行比较？一点也不。我的意思是看一个数组，计算它包含的四分之一的数量，然后看另一个数组，计算它包含的四分之一的数量，然后比较两个结果。如果它们不相同，则返回
false
，如果它们相同，则继续下一种硬币。哦，这是另一种思考方式。没有
remove
的迭代器方法基本上与OP尝试使用双for循环所做的（我相信）相同。值得注意的是，当第1个数组中有2个相同的项，而第2个数组中只有1个相同的项时，这（没有
删除
）可能会将2个数组划分为相等的数组，因为这两个数组都将与一个项匹配。是的，这是有效的。我只是想指出，我认为OP可能一直在尝试做的事情不会起作用，这与之类似，并且由于
remove
，所以这没有问题。也许有人会觉得这很有用。
    for (int i = 0; i < this.coins.size(); i++)
    {
        if (!this.coins.get(i).equals(other.coins.get(i)))
        {
           return false;
        }
    }

    final List<String> copy = new ArrayList<String>(other.coins);
    outerLoop:
    for (final String mine : coins)
    {
        final Iterator<String> otherIter = copy.iterator();
        while (otherIter.hasNext())
        {
            if (mine.equals(otherIter.next()))
            {
                otherIter.remove();
                continue outerLoop;
            }
        }
        return false;
    }

this.coins.toArray() == other.coins.toArray()