Java 寻找下一个闰年_Java_Date_For Loop_While Loop_Leap Year

Java 寻找下一个闰年

java date for-loop

Java 寻找下一个闰年,java,date,for-loop,while-loop,leap-year,Java,Date,For Loop,While Loop,Leap Year,代码在第一年是闰年时有效，因此如果我说2004年是2008年，那么它将返回2008年，但当起始年不是闰年时，它将不返回任何结果。如果给定的年份是2001年、2002年或2003年，下一个闰年是2004年，我将如何输出。我知道while循环是有意义的，但我不知道在它里面放什么。此外，我只能使用基本的java格式，因此没有像java.time.Year这样的输入类 public static boolean leapYear(int year) { boolean isLeap = true;

代码在第一年是闰年时有效，因此如果我说2004年是2008年，那么它将返回2008年，但当起始年不是闰年时，它将不返回任何结果。如果给定的年份是2001年、2002年或2003年，下一个闰年是2004年，我将如何输出。我知道while循环是有意义的，但我不知道在它里面放什么。此外，我只能使用基本的java格式，因此没有像java.time.Year这样的输入类

public static boolean leapYear(int year) {
  boolean isLeap = true;
  if (year % 4 == 0) {
    if (year % 100 == 0) {
      if (year % 400 == 0)
        isLeap = true;
      else
        isLeap = false;
    } else
      isLeap = true;
  } else {
    isLeap = false;
  }
  return isLeap;
}

public static int nextLeapYear(int year) {
  int nextLeap = 0;

  if (leapYear(year)) {
    nextLeap = nextLeap + 4;
  } else {
    while (!leapYear(year)) {
      nextLeap++;
    }
    nextLeap += 1;
  }
  year += nextLeap;
  return year;
}

您的代码以多种方式被破坏：

你说：如果给定的年份是闰年，那么下一个闰年将是4年后这是错误的。如果你在1896年通过，你的算法返回1900，但这是错误的；虽然1896年是闰年，但1900年不是

如果您提前退出，您的isLeapYear代码将更容易阅读。该方法应该有大量的返回语句，并且减少缩进

你的while循环会不断地问同一个问题，如果你向一个稳定的方法问同一个问题（你的isLeapYear方法是稳定的），你会得到相同的答案，从而产生一个无限循环。大概，您不希望

while（！leapYear（year））

，您希望

while（！leapYear（year+nextLeap））

，并且不希望在while循环之后再次增加nextLeap

事实上，你的优势案例是：如果所述年份已经是一年，那么添加4-根本没有必要。想想看：你可以去掉if/else部分。您的代码将只是

nextLeap

、while循环和一个return语句。如果你做得对的话，一个三行

您的代码以多种方式被破坏：

如果您提前退出，您的isLeapYear代码将更容易阅读。该方法应该有大量的返回语句，并且减少缩进

while（！leapYear（year））

，您希望

while（！leapYear（year+nextLeap））

，并且不希望在while循环之后再次增加nextLeap

事实上，你的优势案例是：如果所述年份已经是一年，那么添加4-根本没有必要。想想看：你可以去掉if/else部分。您的代码将只是

nextLeap

、while循环和一个return语句。如果你做得对的话，一个三行

编辑：我想出来了耶

对于任何与此抗争的人来说，这是对我有用的：）

编辑：我想出来了耶

对于任何与此抗争的人来说，这是对我有用的：）

当然这不需要太多的处理。但是如果你想提高程序的效率，你可以考虑以下内容：

所有闰年必须能被4整除。但并非所有能被4整除的年份都是闰年。首先，检查不可被4整除。这将是75%的案例。在这种情况下，返回
```
false
```

继续时，

年必须可以被4整除，因此只需确定它是而不是世纪年。这将在25%的时间内进行评估，并在24%的时间内返回true



最后，唯一未检查的类别是年份除以400。如果我们按照逻辑来到这里，那一定是一个世纪。因此，请相应地返回。这将评估为真。25%的时间

当然这不需要太多的处理。但是如果你想提高程序的效率，你可以考虑以下内容：

所有闰年必须能被4整除。但并非所有能被4整除的年份都是闰年。首先，检查不可被4整除。这将是75%的案例。在这种情况下，返回false


继续时，年必须可以被4整除，因此只需确定它是而不是世纪年。这将在25%的时间内进行评估，并在24%的时间内返回true



最后，唯一未检查的类别是年份除以400。如果我们按照逻辑来到这里，那一定是一个世纪。因此，请相应地返回。这将评估为真。25%的时间

每年被四整除就是闰年，除了
这些年可以被100整除，但是这些百年
如果它们可以被400整除，那么它们就是闰年。例如
1700年、1800年和1900年不是闰年，而是1600年和1900年
2000人。

您可以大大简化函数，leapYear
，如下所示：
public static boolean leapYear(int year) {
  return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(nextLeapYear(1999));
        System.out.println(nextLeapYear(2000));
        System.out.println(nextLeapYear(2001));
    }

    public static int nextLeapYear(int year) {
        // If year is already a leap year, return year + 4
        if (leapYear(year)) {
            return year + 4;
        }

        // Otherwise, keep incrementing year by one until you find a leap year
        while (!leapYear(year)) {
            year++;
        }

        return year;
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

演示：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

输出：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

然后，您可以在函数中使用它，nextLeapYear
，如下所示：
public static boolean leapYear(int year) {
  return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(nextLeapYear(1999));
        System.out.println(nextLeapYear(2000));
        System.out.println(nextLeapYear(2001));
    }

    public static int nextLeapYear(int year) {
        // If year is already a leap year, return year + 4
        if (leapYear(year)) {
            return year + 4;
        }

        // Otherwise, keep incrementing year by one until you find a leap year
        while (!leapYear(year)) {
            year++;
        }

        return year;
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

输出：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

在生产代码中，您应该使用OOTB（开箱即用）类来处理一年
import java.time.Year;

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(nextLeapYear(1999));
        System.out.println(nextLeapYear(2000));
        System.out.println(nextLeapYear(2001));
    }

    public static int nextLeapYear(int year) {
        Year yr = Year.of(year);
        // If year is already a leap year, return year + 4
        if (yr.isLeap()) {
            return yr.plusYears(4).getValue();
        }

        // Otherwise, keep incrementing year by one until you find a leap year
        while (!yr.isLeap()) {
            yr = yr.plusYears(1);
        }

        return yr.getValue();
    }
}

输出：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

有关现代日期时间API的更多信息，请访问
每年被四整除就是闰年，除了
这些年可以被100整除，但是这些百年
如果它们可以被400整除，那么它们就是闰年。例如
1700年、1800年和1900年不是闰年，而是1600年和1900年
2000人。

您可以大大简化函数，leapYear
，如下所示：
public static boolean leapYear(int year) {
  return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(nextLeapYear(1999));
        System.out.println(nextLeapYear(2000));
        System.out.println(nextLeapYear(2001));
    }

    public static int nextLeapYear(int year) {
        // If year is already a leap year, return year + 4
        if (leapYear(year)) {
            return year + 4;
        }

        // Otherwise, keep incrementing year by one until you find a leap year
        while (!leapYear(year)) {
            year++;
        }

        return year;
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

演示：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

输出：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

然后，您可以在函数中使用它，nextLeapYear
，如下所示：
public static boolean leapYear(int year) {
  return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(nextLeapYear(1999));
        System.out.println(nextLeapYear(2000));
        System.out.println(nextLeapYear(2001));
    }

    public static int nextLeapYear(int year) {
        // If year is already a leap year, return year + 4
        if (leapYear(year)) {
            return year + 4;
        }

        // Otherwise, keep incrementing year by one until you find a leap year
        while (!leapYear(year)) {
            year++;
        }

        return year;
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

输出：
public class Main {
    public static void main(String[] args) {
        // Test
        System.out.println(leapYear(1999));
        System.out.println(leapYear(2000));
        System.out.println(leapYear(1900));
        System.out.println(leapYear(1904));
    }

    public static boolean leapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

false
true
false
true

2000
2004
2004

2000
2004
2004

在生产代码中，您应该使用我们