Java 如何基于依赖于列表的布尔值更改2d列表的特定行

如何在不检查整个arraylist>的情况下将此布尔T/F检查合并到此代码中

情况如下,

arraylist<arraylist<Integer>> bigArray....elig arraylist<Boolean>
elig.size() == bigArray.get(0).size();
bigArray is rectangular (i.e. no differing sizes of interior Lists

arraylist bigArray…elig arraylist
elig.size（）==bigArray.get（0.size（）；
bigArray是矩形的（即内部列表没有不同大小

我的代码如下：

for(int j=0; j<(bigArr.size()); j++) {  //lets assume this is ==10           
  for(int e=0; e<(ballotArr.get(0).size()); e++) {   //assume == 5
    if(elig.get(e) == false) {          
        for(int k=0; k<(ballotArr.get(0).size()); k++) {  //==5
            bigArr.get(j).set(k, big.get(j).get(k)-1);
        }
    }
  } 
}

---

for（int j=0；j使用库实现可以稍微加快速度。使用自定义集合可能会加快速度，但这超出了本文的范围。您要面对某些迭代约束，因此在任何情况下都只能做这么多

将程序分解为更小的方法将很有帮助：

public static void decrementColumns(List<List<Integer>> rows, List<Boolean> mask) {
    final List<Integer> maskIndicies = getMaskIndicies(mask);
    // We're locked into this iteration because we have to modify every row.
    for (List<Integer> row : rows) {
        apply(maskIndicies, row);
    }
}

// Your big savings will come from figuring out the indicies.
// This allows us to make the iterations-per-row smaller - 
//   assuming not every row (or even most) is set to 'true'!
public static List<Integer> getMaskIndicies(List<Boolean> mask) {
    final List<Integer> maskIndicies = new ArrayList<Integer>(mask.size());
    for (int i = 0; i < mask.size(); i++) {
        if (mask.get(i)) {
            maskIndicies.add(i);
        }
    } 
}

public static void apply(List<Integer> maskIndicies, List<Integer> row) {
    // We're locked into this iteration, needing to apply the transformation
    // to every column included.
    for (Integer index : maskIndicies) {
        final Integer modified = row.get(index) - 1;
        row.set(index, modified);
    }
}

公共静态无效递减列（列表行、列表掩码）{
最终列表maskIndicies=getMaskIndicies（mask）；
//我们被锁定在这个迭代中，因为我们必须修改每一行。
用于（列表行：行）{
申请（慈善机构，世界其他地区）；
}
}
//你的一大笔储蓄将来自于找出这些指标。
//这使我们可以使每行的迭代次数更小-
//假设不是每一行（甚至大多数）都设置为“true”！
公共静态列表getMaskIndicies（列表掩码）{
最终列表maskIndicies=newarraylist（mask.size（））；
对于（int i=0；i

请注意，这不是线程安全的，所以要小心。我也没有写任何安全检查，所以


编辑：

在重读这个问题时，我意识到我一开始误读了代码所做的事情（我踢了自己——不知怎的，我掉了一个循环）

修订本：

public static void decrementColumns(List<List<Integer>> rows, List<Boolean> mask) {
    final int count = getMaskCount(mask);
    // We're locked into this iteration because we have to modify every row.
    for (List<Integer> row : rows) {
        apply(row, count);
    }
}

public static void int getMaskCount(List<Boolean> mask) {
    int count = 0;
    for(Boolean flag : mask) {
        if (!flag) {
            count++;
        }
    }
    return count;
}

public static void apply(List<Integer> row, int count) {
    for (int index = 0; index < row.size(); index++) {
        final Integer modified = row.get(index) - count;
        row.set(index, modified);
    }
}

公共静态无效递减列（列表行、列表掩码）{
最终整数计数=getMaskCount（掩码）；
//我们被锁定在这个迭代中，因为我们必须修改每一行。
用于（列表行：行）{
应用（行、计数）；
}
}
公共静态void int getMaskCount（列表掩码）{
整数计数=0；
用于（布尔标志：掩码）{
如果（！标志）{
计数++；
}
}
返回计数；
}
公共静态无效应用（列表行，整数计数）{
对于（int index=0；index

请注意，这仍然没有完全做到您的原始代码所做的事情，只是我假设您正在尝试做的事情，考虑到您的“需求”文本。首先，您至少定义了2个附加列表，您没有给出关系-我相当确定其中一个是打字错误。如果您编辑您的问题清楚地说，我可能能够提供更好的答案；您的代码和问题文本之间存在一些模糊或矛盾的地方。请注意，虽然您的原始代码在
O（m*（n^2））
中运行，但最低版本（和我的版本）在
O（n+（m*n））
中运行，有什么建议吗（也就是说，没有稍微加快速度）？我真的很想弄清楚这方面的逻辑。