Java 什么'；我的方法有什么问题？

我对Java完全陌生，所以请原谅我在某些方面是个白痴。我应该编写一个静态方法

isStrictlyIncreasing（double[]in）

，如果给定数组中的每个值都大于前面的值，则返回true，否则返回false。另外，我不能使用

java.util.ArrayList

这是我的密码：

public static void main(String[] args) {

    double in[] = new double[]{45, 15, 25, 79, 89, 45, 66, 33, 56, 105};
    Sort(in);
    System.out.println("Answer: " + Sort(in));
}

private static boolean Sort(double[] in) {
    int n = in.length;
    int temp = 0;    
    for(int i = 0; i < n; i++){
        for(int j = 1; j < (n-i); j++){
            if(in[j - 1] < in[j]){
                return true;
            }
            return false;
        }
    }

publicstaticvoidmain（字符串[]args）{
双入[]=新双入[]{45,15,25,79,89,45,66,33,56,105}；
排序（in）；
System.out.println（“回答：“+Sort（in））；
}
专用静态布尔排序（双[]英寸）{
int n=英寸长度；
内部温度=0；
对于（int i=0；i

不幸的是，我一直得到一张“真的，真的，真的……回答：错”

---

我知道我的方法有问题，可能是在if语句中，我想知道是否有人可以帮助我。

您不需要在之前只检查值吗？一旦您的条件不满足，您将返回false。否则它将返回true

   public static void main(String[] args) {

        double in[] = new double[]{45, 15, 25, 79, 89, 45, 66, 33, 56, 105};
        Sort(in);
        System.out.println("Answer: " + Sort(in));
    }

    private static boolean Sort(double[] in) {
        int n = in.length;
        int temp = 0;    
        for(int i = 1; i < n; i++){
           if(in[i - 1] < in[i])
              return false;
        }
        return true;
  }

publicstaticvoidmain（字符串[]args）{
双入[]=新双入[]{45,15,25,79,89,45,66,33,56,105}；
排序（in）；
System.out.println（“回答：“+Sort（in））；
}
专用静态布尔排序（双[]英寸）{
int n=英寸长度；
内部温度=0；
对于（int i=1；i

您不需要只检查之前的值吗？一旦您的条件不满足，您将返回false。否则它将返回true

   public static void main(String[] args) {

        double in[] = new double[]{45, 15, 25, 79, 89, 45, 66, 33, 56, 105};
        Sort(in);
        System.out.println("Answer: " + Sort(in));
    }

    private static boolean Sort(double[] in) {
        int n = in.length;
        int temp = 0;    
        for(int i = 1; i < n; i++){
           if(in[i - 1] < in[i])
              return false;
        }
        return true;
  }

publicstaticvoidmain（字符串[]args）{
双入[]=新双入[]{45,15,25,79,89,45,66,33,56,105}；
排序（in）；
System.out.println（“回答：“+Sort（in））；
}
专用静态布尔排序（双[]英寸）{
int n=英寸长度；
内部温度=0；
对于（int i=1；i

首先，在Java中，通常使用camelCase方法名。也就是说

private static boolean Sort(double[] in) {

应该成为

private static boolean sort(double[] in) {

其次，return语句用于从方法返回，因此您可能不希望在每次检查后返回。相反，您希望这样做

private static boolean Sort(double[] in) {
    int n = in.length;
    int temp = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 1; j < (n - i); j++) {
            if (in[j - 1] > in[j]) {
                return false;
            }
        }
    }
    return true;
}

私有静态布尔排序（双[]英寸）{
int n=英寸长度；
内部温度=0；
对于（int i=0；iin[j]）{
返回false；
}
}
}
返回true；
}

---

如果序列中的下一个数字不大于它前面的值，那么它将返回false。然后如果它通过for循环而未被触发，那么我们知道它们必须按升序排列，因此返回true。首先，在Java中，通常使用camelCase方法名。也就是说

private static boolean Sort(double[] in) {

应该成为

private static boolean sort(double[] in) {

其次，return语句用于从方法返回，因此您可能不希望在每次检查后返回。相反，您希望这样做

private static boolean Sort(double[] in) {
    int n = in.length;
    int temp = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 1; j < (n - i); j++) {
            if (in[j - 1] > in[j]) {
                return false;
            }
        }
    }
    return true;
}

私有静态布尔排序（双[]英寸）{
int n=英寸长度；
内部温度=0；
对于（int i=0；iin[j]）{
返回false；
}
}
}
返回true；
}

---

如果序列中的下一个数字不大于它前面的值，则返回false。如果它通过for循环而未被触发，则我们知道它们必须按升序排列，因此返回true。您不需要双循环，因为您只检查连续值

private static boolean Sort(double[] in) {
        int n = in.length;

        for(int i = 1; i < n-1; i++){
                if(in[i - 1] < in[i]){
                    return true;
                }

            }
        return false;
        }

私有静态布尔排序（双[]英寸）{
int n=英寸长度；
对于（int i=1；i

您不需要双循环，因为您只检查连续值

private static boolean Sort(double[] in) {
        int n = in.length;

        for(int i = 1; i < n-1; i++){
                if(in[i - 1] < in[i]){
                    return true;
                }

            }
        return false;
        }

私有静态布尔排序（双[]英寸）{
int n=英寸长度；
对于（int i=1；i

您的内部for循环将始终只迭代一次。

返回false

将始终在

返回true

未执行时执行，因此将结束循环。您想做什么？“不幸的是，我一直得到一个“真、真、真……回答：假”的列表”对于您发布的代码，这是不可能的，因为它甚至无法编译，因此无法运行并生成任何结果。请使用最小但完整的示例更新您的问题，这将让我们重现您的问题。您的内部for循环将始终只迭代一次。如果

返回true

，则

返回false

将始终执行所以没有结束循环。你想做什么？“不幸的是，我一直得到一个“真的，真的，真的…回答：假”的列表”对于你发布的代码来说，这是不可能的，因为它甚至不会编译，因此无法运行并生成任何结果。请使用最小但完整的示例更新你的问题，让我们重现你的问题。