Java 检查布尔值数组是否包含true的最快方法

我有一个

数组

的

布尔值

项：

boolean[] myBooleanArray = new boolean[24];

目前我检查它是否包含true，如下所示：

Arrays.asList(myBooleanArray).contains(true);

这是检查布尔值数组的最快方法吗？如果不是，执行此检查的最快方法是什么

编辑：

通过在Android 4.03三星S2设备上运行应用程序，我对您答案中的方法进行了如下计时：

boolean[] myBooleanArray = new boolean[24];

long startTime = System.nanoTime();
suggestedMethod(myBooleanArray);
long endTime = System.nanoTime();

long duration = endTime - startTime;
Log.i("timetest", Long.toString(duration));

时间排名超过五分的是，最快的第一名：

在5334和11584纳秒之间：

for (boolean value : myBooleanArray) {
    if (value) {
        return true;
    }
}
return false;

在160542和171417纳秒之间：

Arrays.asList(myBooleanArray).contains(true);

在191833和205750纳秒之间：

Booleans.contains(myBooleanArray, true);

---

只需遍历数组

for(boolean value: myBooleanArray){
  if(value){ return true;}
}
return false;

据介绍，使用增强for或普通for对数组进行迭代基本相同，因为两者都使用数组访问。因此，只需在数组上迭代：

public boolean containsTrue(boolean[] array){

    for(boolean val : array){
        if(val)
            return true;
    }

    return false;
}

如果您正在使用库（库中有很多有用的东西）：

（）

---

该方法的文档还描述了另一种方法。您可以用

位集替换
布尔[]
（应该更节省内存）并调用
！bitSet.isEmpty（）
检查是否至少有一个位为真。
一般来说，如果你有一个数组（或
列表）
，在其中查找项目的最快/唯一的方法是在数组上迭代，直到找到你要查找的内容。这是数组/
List
s的限制之一

对于一个包含24个元素的数组，我无论如何都不会担心这个问题。如果您有数百万项，并且期望的
true
s很少（或者可能没有），那么将数据封装在类中是有意义的：

public class BooleanArray
{
    boolean[] arr = new boolean[SIZE]; // or get size from a constructor
    boolean anyTrue = false;

    boolean get(int index) {
        return arr[index];
    }

    boolean set(int index, boolean value) {
        arr[index] = value;
        anyTrue |= value;
    }

    boolean containsAnyTrues() {
        return anyTrue;
    }
}

重申一下，我不建议对包含24个元素的数组执行此操作。我的意思是，这更像是一个示例，您的数据结构应该支持预期的用例。如果预期的用例是“大量元素，非常稀疏的
true
s，需要找出是否存在任何
true
s”，那么您对最快方式的关注就更为相关，像上面这样的数据结构将非常有用。
如果您有一个0和1的数组，您可以简单地或每个元素。如果得到1，则至少有一个TRUE。
如果未绑定到布尔数组，则应查看该类。尽管名称不同，但它更像数组而不是集合

如果“数组”中存在任何
true
，则该方法将回答您的问题，并实现为：

public boolean isEmpty()
{
    return wordsInUse == 0;
}

我怀疑你能得到更快的支票

但代价必须在别处付出：如果您知道数组的大小，并且数组很大，那么设置/取消设置值可能比单纯的
布尔[]
更昂贵。24相当小，所以很难改进。Arrays.mismatch似乎要快一点

import java.util.Arrays;
import java.util.Random;

public class BenchMark{
    final static int N = Short.MAX_VALUE;
    static boolean[] base = new boolean[N];
    static boolean any1(boolean[] test){
        return Arrays.mismatch(base, test)==-1;
    }
    static boolean any2(boolean[] test){
        for(boolean b: test)
            if(b) return true;
        return false;
    }
    public static void main(String[] args){
        boolean[] test = new boolean[N];
        Random r = new Random(1);
        int last = 0;
        long start = System.nanoTime();
        int p = 0;
        for(int i = 0; i<100000; i++){
            test[last] = false;
            int s = r.nextInt(2);
            if(s == 0){
                last = r.nextInt(test.length);
                test[last] = true;
            } 
            if(any2(test)){
                p++;
            }
        }
        System.out.println( ( p + " in " + (System.nanoTime() - start ) / 1e9 ) + " seconds");
    }
}

导入java.util.array；
导入java.util.Random；
公共课基准{
最终静态int N=Short.MAX_值；
静态布尔值[]基=新布尔值[N]；
静态布尔any1（布尔[]测试）{
返回数组。不匹配（基，测试）=-1；
}
静态布尔any2（布尔[]测试）{
for（布尔b：测试）
如果（b）返回true；
返回false；
}
公共静态void main（字符串[]args）{
布尔[]测试=新布尔[N]；
随机r=新随机（1）；
int last=0；
长启动=System.nanoTime（）；
int p=0；
对于（int i=0；i
Arrays.asList（myBooleanArray）
为您提供的数组列表不是
布尔值
s。该方法不应用于原语数组。为什么您不对您的各种选项进行基准测试，看看而不是相信其他选项？@Rohit Jain.公平点，但我没有足够的经验知道所有选项是什么。有了这些答案，我可以做基准测试。@pierrymiortz..Hmm、 是的，对。谢谢大家的建议。请参阅编辑后的答案，了解方法的基准测试。OP只想检查
true
的存在性，这并不是所有的
true
，这是最快的方法吗？因为它也通过使用contains方法来做同样的事情，因为它也是有问题的。我想不出任何更快的方法用于boolean数组（但位集实际上可能更快）。
import java.util.Arrays;
import java.util.Random;

public class BenchMark{
    final static int N = Short.MAX_VALUE;
    static boolean[] base = new boolean[N];
    static boolean any1(boolean[] test){
        return Arrays.mismatch(base, test)==-1;
    }
    static boolean any2(boolean[] test){
        for(boolean b: test)
            if(b) return true;
        return false;
    }
    public static void main(String[] args){
        boolean[] test = new boolean[N];
        Random r = new Random(1);
        int last = 0;
        long start = System.nanoTime();
        int p = 0;
        for(int i = 0; i<100000; i++){
            test[last] = false;
            int s = r.nextInt(2);
            if(s == 0){
                last = r.nextInt(test.length);
                test[last] = true;
            } 
            if(any2(test)){
                p++;
            }
        }
        System.out.println( ( p + " in " + (System.nanoTime() - start ) / 1e9 ) + " seconds");
    }
}