Java 是否检查二维数组中的等效行？

假设我有一个2D数组，如下所示：

[1, 2, 3]
[1, 2, 3, 3]
[2, 3, 1]

---

在这个问题中，我的函数将返回true，因为忽略顺序和重复项。如果我改为像这样输入二维数组：

[1, 2, 3]
[2, 3, 4]
[6, 7, 1, 2]

    public static boolean checkEqual(Integer[][] array){
    //get number of rows
    int numRows = array[0].length;
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < numRows; i++){
        boolean alreadySeen = false;
        for (int j = 0; j < array[i].length; j++){
            if (map.containsKey(array[i][j])){
                //Do not add duplicates in the same row to the map
                if (!alreadySeen){
                    int count = map.get(array[i][j]);
                    count++;
                    map.put(array[i][j], count);
                    alreadySeen = true;
                }
            }
            else{
                map.put(array[i][j], 1);
            }
        }
    }
    boolean overall = false;
    for (Map.Entry<Integer, Integer> entry : map.entrySet()){
        if (entry.getValue() == numRows){
            overall = true;
        }
        else{
            return false;
        }
    }
    return overall;
}

它将返回false，因为没有一个数组具有相同的数字等

无论如何，我正试图编写一个程序来找到这些等价的数组。目前，我有这样的想法：

[1, 2, 3]
[2, 3, 4]
[6, 7, 1, 2]

    public static boolean checkEqual(Integer[][] array){
    //get number of rows
    int numRows = array[0].length;
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < numRows; i++){
        boolean alreadySeen = false;
        for (int j = 0; j < array[i].length; j++){
            if (map.containsKey(array[i][j])){
                //Do not add duplicates in the same row to the map
                if (!alreadySeen){
                    int count = map.get(array[i][j]);
                    count++;
                    map.put(array[i][j], count);
                    alreadySeen = true;
                }
            }
            else{
                map.put(array[i][j], 1);
            }
        }
    }
    boolean overall = false;
    for (Map.Entry<Integer, Integer> entry : map.entrySet()){
        if (entry.getValue() == numRows){
            overall = true;
        }
        else{
            return false;
        }
    }
    return overall;
}

public静态布尔checkEqual（整数[][]数组）{
//获取行数
int numRows=数组[0]。长度；
HashMap=newHashMap（）；
对于（int i=0；i

---

然而，这总是返回False，我感觉由于所有的循环和检查，这是一种非常低效的方法。有没有人会对我如何更有效地完成这项工作有任何提示？谢谢大家!

如果我理解正确，您可以使用以下内容：

import java.util.Set;
import java.util.HashSet;
public class Equaller
{
    public static boolean checkEqual(Integer[][] array) {
        Set<Integer> firstSet = new HashSet<Integer>();
        Set<Integer> secondSet = new HashSet<Integer>();

        if (array.length > 0) {
            // Fill first set
            final Integer[] firstArray = array[0];
            for (int i=0; i < firstArray.length; ++i) {
                firstSet.add(firstArray[i]);
            }
            // Compare 2D array with first set
            for (int i=1; i < array.length; ++i) {
                final Integer[] intArray = array[i];
                for (int j=0; j < intArray.length; ++j) {
                    if (!firstSet.contains(intArray[j])) {
                        return false;
                    }
                }
            }
            //  Create second set
            if (array.length > 1) {
                final Integer[] secondArray = array[1];
                for (int i=0; i < secondArray.length; ++i) {
                    secondSet.add(secondArray[i]);
                }

            // Compare first array
            if (firstSet.size() != secondSet.size()) {
                return false;
            }
            }
            return true;
        }
        return false;
    }

    public static void main(String[] argv) {
        Integer[][] aa = new Integer[][] {
            {1,2,3},
            {1,2,3,3},
            {2,3,1}};
        System.out.println(checkEqual(aa));
        Integer[][] ab = new Integer[][] {
            {1,2,3},
            {2,3,4},
            {6,7,1,2}};
        System.out.println(checkEqual(ab));
    }
}

---

已清理xio4的解决方案：

import java.util.Set;
import java.util.HashSet;

public class Equaller {

    public static boolean checkEqual(Integer[][] array) {
        if (array.length > 0) {
            Set<Integer> firstSet = new HashSet<Integer>(array[0].length);
            // fill first set
            for (Integer i : array[0]) {
                firstSet.add(i);
            }
            // compare 2D array with first set
            for (Integer[] intArray : array) {
                Set<Integer> secondSet = new HashSet<Integer>(firstSet.size());
                for (Integer i : intArray) {
                    if (!firstSet.contains(i)) {
                        return false;
                    }
                    secondSet.add(i);
                }
                if (firstSet.size() != secondSet.size()) {
                    return false;
                }
            }
        }
        return true;
    }
}

import java.util.Set；
导入java.util.HashSet；
公共类均衡器{
公共静态布尔checkEqual（整数[][]数组）{
如果（array.length>0）{
Set firstSet=newhashset（数组[0]。长度）；
//填第一套
对于（整数i:数组[0]）{
第一组。添加（i）；
}
//将2D数组与第一组数组进行比较
对于（整数[]数组：数组）{
Set secondSet=newhashset（firstSet.size（））；
for（整数i:intArray）{
如果（！firstSet.contains（i））{
返回false；
}
第二组。添加（i）；
}
if（firstSet.size（）！=secondSet.size（））{
返回false；
}
}
}
返回true；
}
}

“顺序和重复项被忽略”——听起来您想要的是

java.util.Set

，而不是数组。如果出于某种原因必须在其他地方使用数组，请通过构建内部数组的集合来实现此功能，并使用这些集合的集合来检查重复项。