Java 我需要单循环还是嵌套循环？

假设我有一个数组和一个布尔方法。如果所有正数出现在所有非正数之前（包括0），则此布尔方法将返回true。否则，它将返回一个假值。 第一个数组newArrayTrue将返回一个真值，因为所有正数都出现在所有非正数和0之前。而在newArrayFalse中，它将返回一个假值，因为0出现在5之前，而5是一个正数

int[] newArrayTrue = {3,1,-4,0,-5};
int[] newArrayFalse = {3,1,-4,0,5};

public static boolean isPositiveFirst(int[] numbers) {

for (int i=0; i<numbers.length; i++) {
  for (int j=i+1; i<numbers.length; i++) {
    if (numbers[i] > 0  && (numbers[i+1] < 0 || numbers[i+1] == 0)) {
      return true;
    }
  }
}
return false;
}
}

int[]newArrayTrue={3,1，-4,0，-5}；
int[]newArrayFalse={3,1，-4,0,5}；
公共静态布尔值isPositiveFirst（int[]数字）{
对于（int i=0；i，如果遇到0或负数，您可以使用一个布尔变量EnometedNegative并将其设置为true。然后继续迭代，如果找到正数，则该方法应返回false。如果循环结束，该方法返回true

大概是这样的：

public static boolean isPositiveFirst(int[] numbers) {

    boolean encounteredNegative = false;
    for (int i = 0; i < numbers.length; i++) {
        if (numbers[i] <= 0) {
            encounteredNegative = true;
        } else {
            if (encounteredNegative) {
                return false;
            }
        }
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
布尔值遇到负值=false；
for（int i=0；iif（numbers[i]如果遇到0或负数，您可以只使用遇到负数的布尔变量，并将其设置为true。然后继续迭代，如果找到正数，则该方法应返回false。如果循环结束，则该方法返回true

大概是这样的：

public static boolean isPositiveFirst(int[] numbers) {

    boolean encounteredNegative = false;
    for (int i = 0; i < numbers.length; i++) {
        if (numbers[i] <= 0) {
            encounteredNegative = true;
        } else {
            if (encounteredNegative) {
                return false;
            }
        }
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
布尔值遇到负值=false；
for（int i=0；i
public static boolean isPositiveFirst(int[] numbers) {
    for(int i = 1; i < numbers.length; i++) {
       if(numbers[i] > 0 && numbers[i-1] <= 0) {
           return false;
       }
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
对于（int i=1；i0&&numbers[i-1]这就足够了：

public static boolean isPositiveFirst(int[] numbers) {
    for(int i = 1; i < numbers.length; i++) {
       if(numbers[i] > 0 && numbers[i-1] <= 0) {
           return false;
       }
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
对于（int i=1；i0&&numbers[i-1]

    private static boolean areAllPositiveFirst(int[] a)
    {
        boolean f=false,ans=true;
        for (int i = 0; i < a.length; i++)
        {
            if(f && a[i]>0)
            {
                ans=false;
                break;
            }
            if(a[i]<=0)
                f=true;
        }
        return ans;
    }

private静态布尔值areAllPositiveFirst（int[]a）
{
布尔值f=false，ans=true；
for（int i=0；i0）
{
ans=假；
打破
}
如果（a[i]这个怎么样

    private static boolean areAllPositiveFirst(int[] a)
    {
        boolean f=false,ans=true;
        for (int i = 0; i < a.length; i++)
        {
            if(f && a[i]>0)
            {
                ans=false;
                break;
            }
            if(a[i]<=0)
                f=true;
        }
        return ans;
    }

private静态布尔值areAllPositiveFirst（int[]a）
{
布尔值f=false，ans=true；
for（int i=0；i0）
{
ans=假；
打破
}
如果（a[i]作为给定答案的替代方案，使用IntStream可以执行以下操作：

public static boolean isPositiveFirst(int[] numbers) {
    int k = IntStream.range(0, numbers.length).filter(i -> numbers[i]<1).findFirst().orElse(-1);
    if(k < 0) 
        return true;        
    else 
        return IntStream.of(Arrays.copyOfRange(numbers, k, numbers.length)).filter(i-> i>0).count() <1;
}

public静态布尔值isPositiveFirst（int[]数字）{
int k=IntStream.range（0，numbers.length）.filter（i->numbers[i]i>0）.count（）作为给定答案的替代方法，使用IntStream可以执行以下操作：

public static boolean isPositiveFirst(int[] numbers) {
    int k = IntStream.range(0, numbers.length).filter(i -> numbers[i]<1).findFirst().orElse(-1);
    if(k < 0) 
        return true;        
    else 
        return IntStream.of(Arrays.copyOfRange(numbers, k, numbers.length)).filter(i-> i>0).count() <1;
}

public静态布尔值isPositiveFirst（int[]数字）{
int k=IntStream.range（0，numbers.length）.filter（i->numbers[i]i>0）.count（）我看到柳波米尔·帕帕佐夫已经提出了这个算法。我的实现更简洁一些：

public static boolean isPositiveFirst(int[] numbers) {
    boolean seenNonPositive = false;
    for(int i : numbers) {
        if(i < 1) seenNonPositive = true;
        else if(seenNonPositive) return false;
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
布尔值seenNonPositive=false；
用于（int i：数字）{
如果（i<1）seenNonPositive=true；
否则，如果（见否）返回false；
}
返回true；
}
我看到柳波米尔·帕帕佐夫已经提出了这个算法。我的实现更简洁一些：

public static boolean isPositiveFirst(int[] numbers) {
    boolean seenNonPositive = false;
    for(int i : numbers) {
        if(i < 1) seenNonPositive = true;
        else if(seenNonPositive) return false;
    }
    return true;
}

public静态布尔值isPositiveFirst（int[]数字）{
布尔值seenNonPositive=false；
用于（int i：数字）{
如果（i<1）seenNonPositive=true；
否则，如果（见否）返回false；
}
返回true；
}
假设我只能使用一个布尔方法，而不能创建新方法。在当前布尔方法中我必须做什么@宿命的な孤独 EncountedNegative不是一个方法，它是一个变量。我看了两遍后才知道。我很抱歉。比方说，我只能使用一个布尔方法，而不能创建新方法。在当前布尔方法中我必须做什么@宿命的な孤独 EncountedNegative不是一个方法，它是一个变量。我看了两遍后才知道。我很抱歉。实际上，您不需要检查数组是否短于或等于1。在这种情况下，它将不会进入循环并返回true…实际上，您不需要检查数组是否短于或等于1。在这种情况下，它不会t无论如何都不要进入循环并返回true。。。