Question

我尝试遍历数组数组，并按顺序比较元素以查找公共元素。所以，如果我们有inventoryTable = new JTable(); String showquery="select * from sample.inventory where parts='BSP'"; PreparedStatement showPst; DefaultTableModel showTable=new DefaultTableModel(); inventoryTable.setModel(showTable); try{ showPst=connect.prepareStatement(showquery); //showPst.setString(2, "BSP"); ResultSet showrs=showPst.executeQuery(); ResultSetMetaData meta=(ResultSetMetaData) showrs.getMetaData(); String[] rowdata=new String[2]; while(showrs.next()){ rowdata[0]=showrs.getObject(2)+" "+showrs.getObject(3)+" "+showrs.getObject(5)+" "+showrs.getObject(8)+" "+showrs.getObject(7); rowdata[1]=(String) showrs.getObject(15); showTable.addRow(rowdata); } }catch(Exception e){ e.printStackTrace(); } inventoryTable.setModel(showTable); showTable.fireTableDataChanged(); inventoryTable.setBounds(62, 0, 489, 306); panel.add(inventoryTable); }，我想首先比较[i] [i]和[i + 1] [i]，[i] [i + 1]和[i + 1] [i + 1] ]和[i] [i + 2]和[i + 1] [i + 2]等。这是我的代码：

var arr = [[1,2,3],[4,2,5]];

问题：当我运行代码而不是包含匹配元素的数组时，我得到一个空数组

Answer 1

首先必须迭代一个数组，看看另一个数组是否包含您指定的值。

我的答案类似于嵌套的for循环，因为includes方法就是这样做的。它将一个元素作为参数，并检查调用它的数组是否包含所述元素。为了做到这一点，它必须在最坏的情况下遍历数组中的所有元素。

我的回答还假设你只想重复一次匹配。

＆＃13;

function sym(args) {
  var fullArr = [];
  var finalArr = [];
  // store the arguments inside a single array
  for (var count = 0; count < arguments.length; count ++) {
    fullArr[count] = arguments[count];
  }
  // loop through finalArr[];
  
  //since you are comparing only two arrays in this 
 //example you just have to iterate over each element in the first array aka fullArr[0] and
 //check if each element "e" is also in the second array aka fullArr[1] 
 //AND that your final output array does not already contain it.
 //If both of these are true then we push the element to the output array.
  fullArr[0].forEach(function(e){
       if(fullArr[1].includes(e) && !finalArr.includes(e)) finalArr.push(e);
    
    });
  return finalArr;
}

sym([1, 2, 3], [5, 2, 1, 4]);

＆＃13;

但是，如果你想检查一个n长度数组的所有集合中是否存在特定元素，那么我会建议这样的事情：

＆＃13;

function sym(args) {
  var fullArr = [];
  var finalArr = [];
  // store the arguments inside a single array
  for (var count = 0; count < arguments.length; count ++) {
    fullArr[count] = arguments[count];
  }
      
      var newArr = fullArr[0].reduce( function(prev, e1) {
         if(prev.indexOf(e1) < 0 && fullArr.every( function(arr){
                   return arr.indexOf(e1) > -1;
             })){
             return [...prev, e1];    
           }else{
                   return prev;
           };
       },[]);
       alert(newArr);        
       return newArr;
}

sym([1,1, 2, 3,4], [5, 2, 1, 4], [4,1,2, 5]);

＆＃13;

Answer 2

您可以遍历第一个数组并检查其中的任何值是否在所有其他数组中都是通用的。

function sym() {
    var common = [];
    for (var i=0; i<arguments[0].length; i++) {
        var isCommon = common.indexOf(arguments[0][i]) === -1; // first check if its not already exists in the common array
        for (var j=1; j<arguments.length && isCommon; j++) {
            isCommon = arguments[j].indexOf(arguments[0][i]) > -1
        }
        if (isCommon) common.push(arguments[0][i])
    }
    return common;
}

当然，您可以通过迭代最小的数组来改进它。

Answer 3

在您的代码中，当执行以下行时，您还会增加作为控制变量的i的值：

if (fullArr[i][i] == fullArr[i++][i++])

因此，这就是你的i变量在每次迭代中递增的方式：

迭代＃1： i = 0

迭代次数＃2： i = 3 - 你从我上面提到的那一行得到i + 2，你在for循环的最终条件中指定的增量再增加+1

因此，即使在第一次迭代之后，您的函数将在您的特定场景中返回一个空数组，因为您传递的是长度为3的数组，并且for循环在第一次迭代后i = 0之后结束。 / p>

即使循环继续，它也会返回索引超出范围的异常，因为长度为3的数组不会有array[3]元素。

例如，如果您只想比较两个数组（如在场景中），则需要遍历每个数组并比较它们的元素：

function sym(array1, array2) {
  var results = [];


  for (var i = 0; i < array1.length; i++) {
      for (var j = 0; j < array2.length; j++) {
          if(array1[i] === array2[j]) {
              if(results.indexOf(array1[i]) === -1) {
                  results.push(array1[i]);
              }
          }
      }
  }

  return results;
}

sym([1, 2, 3], [5, 2, 1, 4]);

我还构建了一个解决方案，它返回您提供的数组的交集作为函数的参数，无论有多少数组：

function sym(args) {
    var paramSet = Array.prototype.slice.call(arguments);
    var counterObject = {};
    var results = [];

    paramSet.forEach(function (array) {
        // Filter the arrays in order to remove duplicate values
        var uniqueArray = array.filter(function (elem, index, arr) {
            return index == arr.indexOf(elem);
        });


        uniqueArray.forEach(function (element) {
            if (Object.prototype.hasOwnProperty.call(counterObject, element)) {
                counterObject[element]++;
            } else {
                counterObject[element] = 1;
            }
        });
    });


    for (var key in counterObject) {
        if (counterObject[key] === paramSet.length) {
            results.push(parseInt(key));
        }
    }

    return results;

}

sym([1, 2, 3, 3, 3], [5, 2, 1, 4], [1, 7, 9, 10]);

对于我提供的示例，上面的代码将返回[1]，因为这是所有3个数组的交集。

比较许多数组的数组元素

3 个答案: