【问题标题】:Measuring overlap between arrays测量阵列之间的重叠
【发布时间】:2015-09-30 06:31:46
【问题描述】:

鉴于 Java 中的几个数组(我将遍历当前存储在 HashMap 中的键),我希望能够识别(基于当前存储的 boolean[] 键)哪些索引是 true它们,它们是false

例子:

{true, true,false}
{true,false,false}
{true,false, false}

将产生索引 0 具有所有真值,而索引 2 具有所有假值。

我的一个想法是将布尔数组转换为整数数组,对这些值求和,如果求和的数组索引 = numArrays,那么它们都是 True。类似地,如果求和的数组索引为 0,则它们全部为假。

我不确定如何以有效的方式(在 java 中)执行此操作,更不用说这是实现我想要的结果的好方法了。

有没有办法将布尔数组转换为整数?如果不是,最简单的方法是实例化一个新的整数数组,然后遍历布尔数组以填充新数组?

【问题讨论】:

  • 您基本上有一个矩阵或表格(假设它们具有相同的列数)。您应该能够简单地遍历每个数组的每一列并检查它的结果......
  • 0b110 & 0b100 & 0b100 == 0xb100 - 按位与。

标签: java arrays


【解决方案1】:

它们是布尔值,所以我真的不知道您为什么要考虑将它们转换为整数并将它们相加:这确实很容易但绝对没用。

所以。我假设您没有将它们放在矩阵中(我实际上假设您不知道矩阵是什么,但请不要被此冒犯),您将它们放在单独的数组中,并且您确切知道您有多少个数组有(比方说3)。我还假设它们都具有相同的长度。

这个想法是:对于每个可用位置,我们检查三个数组中占据该位置的三个元素,看看它们是否都为真。我们可以用这个比较的结果做什么?我们可以把它打印到屏幕上,把它放在另一个数组中,或者做任何我们想做的事情。

让我们从三个数组开始:

boolean[] foo = {true, true, false};
boolean[] bar = {true, false, false};
boolean[] baz = {true, false, false};

好的。我们现在可以创建第四个数组来存储我们的结果。

boolean[] qux = new boolean[3];

或者,甚至更好:

boolean[] qux = new boolean[foo.length];

让我们开始构建我们的 C 风格循环:

for (i = 0; i < foo.length; i++) {
    ...
}

如果您使用数组,您可能已经知道 for 循环的工作原理:第一条语句将被执行,就好像它是在整个代码块之前编写的一样在大括号内;每次执行块时,第二条语句都会被检查为 first 指令,如果它失败,则循环停止;每次执行块时,第三条语句将作为 last 指令执行。
您可能已经知道,如果数组的长度为n,则其元素的索引将为
0, [...], n-1
如果你不知道这两件事......好吧,不客气。

那么,我说过我们想对每个可用职位做什么?我们想比较那个位置的三个元素。于是for循环就变成了:

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

    if (foo[i] && bar[i] && baz[i]) {
        ...
    }

}

我们刚刚添加的是这个检查:如果数组 foo 中位置 i 的元素是 trueAND ALSO 数组 bar 中位置 i 的元素是 trueAND ALSO 数组中位置 i 的元素 baz 是true...我们做点什么。

例如,我们可以将结果放入 qux

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

    if (foo[i] && bar[i] && baz[i]) {

        qux[i] = true;

    } else {

        qux[i] = false;

    }

}

请注意,比较本身的计算结果是一个布尔值,当它的值为true时,我们存储一个true;当false 我们存储false。所以我们也可以这样写:

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

    qux[i] = (foo[i] && bar[i] && baz[i]);

}

Grrrrreat,我们实现了我们想要实现的目标!你也想显示这样的结果吗?让我给你介绍一下增强的for循环:

for (boolean val : qux) {
    ...
}

基本上,作为 qux 一个布尔数组,它是一个布尔值的“容器”。这个 for 声明说:对于组成 qux 的每个元素......做一些事情。

所以,让我们用它来打印这些元素:

for (boolean val : qux) {

    System.out.println(val);

}

方法println(),对象out,类System的静态成员(如果你不理解所有这些术语,请不要担心,如果你继续学习Java,你会知道它们的含义)显示在屏幕上某物。从技术上讲,这个“东西”应该是一个字符串,但是由于 Java 知道如何用布尔值生成字符串,所以我们在传递 val 给它时不必太担心。

想要在第一个 for 中完成所有操作并以漂亮的方式打印?简单易懂:

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

    qux[i] = (foo[i] && bar[i] && baz[i]);

    System.out.println("At position " + i + " we have " + qux[i]);

}

那么,我们现在如何检查全假位置?我们可以使用 bang(!),其含义是:取这个布尔值并考虑它的否定(true,如果它是falsefalse,如果它是true)。
使用它,我们可以表达这种检查:如果数组 foo 中位置 i 的元素是 falseAND ALSO数组 bar 中位置 i 的元素是 falseAND ALSO 数组 中位置 i 的元素bazfalse...我们做点什么。

所以我们需要第五个数组:

boolean[] norf = new boolean[foo.length];

我们会将循环更改为

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

    qux[i] = (foo[i] && bar[i] && baz[i]);

    if (qux[i]) {

            System.out.println("At position " + i + " they are all true.");

    }

    norf[i] = (!foo[i] && !bar[i] && !baz[i]);

    if (norf[i]) {

            System.out.println("At position " + i + " they are all false.");

    }

}

希望这是有用的。

【讨论】:

    【解决方案2】:

    假设所有数组都有相同数量的元素,你可以试试这个:

    public static void main(String[] args) {
        boolean[] array1 = new boolean[] {true,true,false};
        boolean[] array2 = new boolean[] {true,false,false};
        boolean[] array3 = new boolean[] {true,false,false};
        boolean[] array4 = new boolean[] {true,false,false};
    
        compareAndPrintCommonIndicesForArrays(array1, array2, array3);
    }
    
    public static boolean compareAndPrintCommonIndicesForArrays(boolean[] ...arrays) {
        boolean result =true;
        boolean itemToCompare;
        int elementsToCompare = arrays[0].length;
    
        for(int itemIndex=0; itemIndex<elementsToCompare; itemIndex++) {
            result = true;
            itemToCompare = arrays[0][itemIndex];
            for(int arrayIndex = 0; arrayIndex<arrays.length;arrayIndex++) {
                if(itemToCompare != arrays[arrayIndex][itemIndex]) {
                    result = false;
                }
            }
            if(result) System.out.println(itemIndex);
        }
        return result;
    }
    

    打印出来:

    0 2

    代码将遍历所有索引,并且对于每个索引,它将比较该索引处所有数组的元素。如果它们都相同,则打印索引。

    【讨论】:

    • 虽然技术上是正确的,但它不会很好地扩展:p
    【解决方案3】:

    基本上,您希望将数组包装在另一个数组中,例如创建一个二维矩阵...

    boolean matrix[][] = {
        {true, true, false},
        {true, false, false},
        {true, false, false}
    };
    

    然后对于每一列,每一行,你要检查值是否匹配

    boolean results[] = new boolean[3];
    for (int col = 0; col < 3; col++) {
        Boolean value = null;
        boolean matches = true;
        for (int row = 0; row < matrix.length; row++) {
            if (value == null) {
                value = matrix[row][col];
            } else if (matrix[row][col] != value) {
                matches = false;
                break;
            }
        }
        results[col] = matches;
    }
    System.out.println(Arrays.toString(results));
    for (int col = 0; col < results.length; col++) {
        if (results[col]) {
            System.out.println(col);
        }
    }
    

    哪些打印...

    [true, false, true]
    0
    2
    

    boolean results[] 数组的原因是因为每一列要么匹配 (true) 要么不匹配 (false),只需检查每个元素以确定哪些索引导致 @ 987654327@结果

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 2017-01-29
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2014-12-03
      • 2018-11-16
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多