Java 当只有一个条件为真时，如何使条件语句返回真？

我需要做一个if语句，其中它的值取决于N个其他条件。特别是，仅当N个条件中的一个为真时，它才需要返回真（如果多个条件为真，则必须返回假）。更正式地说，

if（1，2，3…N）

应在且仅当只有一条语句的值为true时计算true，否则计算false

我实施了这个方法,

boolean trueOnce(boolean[] conditions) {

    boolean trueOnce = false;

    for (boolean condition : conditions) {
        if (condition) {
            if (!trueOnce) {
                trueOnce = true;
            } else {
                trueOnce = false;
                break;
            }
        }
    }

    return trueOnce;
}

但我要求的是更实际的东西。我正在使用Java，但我认为这个问题对于每种语言都是普遍存在的。谢谢

---

编辑：这种方法做得很好，但我的问题是，Java（或任何其他语言）是否有更实用的方法来实现这一点（即，甚至不实现整个方法）？

带有条件计数的简单循环

true

存在是一种简单的方法返回语句是一种比较，返回一个

布尔值，无论
true
计数是否精确等于1：

long count = 0;
for (boolean condition: conditions) {
    if (condition) {
        count++;
    }
}
return count == 1;

这总是迭代所有数组，这并不总是必需的。当找到两个
true
值时，可以优化迭代以停止，因此继续迭代没有意义

long count = 0;
for (boolean condition: conditions) {
    if (condition && ++count > 1) {
        break;
    }
}
return count == 1;

使用流API，您可以将其重写为（尽管它看起来不像普通循环那么“实用”）：

import java.util.stream.*；
静态布尔值trueOnce（布尔值…条件）{
//查找第一个true的索引，如果不可用，则获取-1
int firstTrue=IntStream.range（0，conditions.length）
.filter（i->条件[i]）
.findFirst（）.orElse（-1）；
//如果找到第一个true，请检查数组其余部分中是否没有true
返回firstTrue>-1&&IntStream.range（firstTrue+1，conditions.length）
.noneMatch（i->条件[i]）；
}


使用@VLAZ建议的更改恢复初始版本：

import java.util.stream.*；
布尔trueOnce（布尔[]条件）{
return IntStream.range（0，conditions.length）
.filter（i->条件[i]）
.限制（2）/！
.count（）==1；
}
您可以使用此解决方案

public boolean trueOnce(boolean[] conditions) {
         boolean m = false;
         for(boolean condition : conditions) {
             if(m && condition)
                 return false;
             m |= condition;
         }
         return m;
     }

这是一个非常小的解决方案，只需很少的几行即可完成您想要的功能。
可以使用while操作符执行迭代。一个变量用于控制正值的增量，另一个变量用于计算数组的每个元素。这两个变量将是我们的停止条件，该方法将返回解决方案，当存在单个正值时为true，在所有其他情况下为false

boolean trueOnce(boolean[] conditions) 
    {
        int i = 0, count = 0;
        
        while(count <= 1 && i < conditions.length){
            if(conditions[i++]){
                count++;
            }
        }
        
        return count == 1;
    }

boolean trueOnce（boolean[]条件）
{
int i=0，count=0；
使用Java流API时（计数）

boolean trueOnce（boolean[]条件）{
return IntStream.range（0，conditions.length）
.filter（x->conditions[x]）//只保留'true'值
.limit（2）//不需要获取两个以上
.count（）==1；//检查是否只有一个'true'值
}
（布尔条件：条件）如果（条件）返回trueReReRy，我没有读清楚你的问题。你可以只计算真条件的数目，然后返回nbtrue= 1？@ kajjajys，你的代码看起来是什么样的解决方案，你会考虑更多的“实用”？“它需要遍历所有数组”。–仅在最坏情况下为真（即最后一个元素是第一个或第二个真值）。根据要求，算法可以在遇到第二个真值后立即短路。@斯拉夫算法如何在遇到第二个真值后立即短路
？@RIVERMAN2010要求是，如果真值的数量是
0
或
>1
，那么最终结果是
false
。没有理由检查超过2个真值，因为那时你知道最终结果是
false
。@Slaw：是的，你是对的。我已经纠正了我的错误，并添加了一个优化n、 顺便说一句，为什么要使用
long
进行计数？不是100%确定，但我认为三元可以简化为
m |=条件
@Slaw是的，你是对的，它可以简化，我将使用
编辑我的答案，而
循环使用
I
在这种情况下有点冗长：）这是一种非常迂回的检查方法。执行
Arrays.stream（conditionals）.filter（x->x）.limit（2）.count（）
仍将使用流API，并且它正确、简短、可读。是的，limit（2）！：\n在很多层面上都是错误的！如果根本不复制，这怎么会有这么高的投票率。1）
conditions
vs
conditionals
.2）
数组。stream（boolean[]）
根本不存在。@Nikolasharalalambidis感谢您的反馈。第一点是类型，第二点是我没有意识到
Arrays.asStream（boolean[]）
丢失。看起来很奇怪，但我想它就是这样。将其更改为带有数组索引的
IntStream
。虽然不太好，但这是最便宜的选择。
private static boolean trueOnce(boolean[] conditions) 
{
    int count = 0;
    
    for(int i = 0; i < conditions.length && count <= 1; i++){
        if(conditions[i]){
            count++;
        }
    }
    
    return count == 1;
}