Code Java pour calculer l'année bissextile
Je suis le livre "L’art et la science de Java" et il montre comment calculer une année bissextile . Le livre utilise la bibliothèque de ACM Java Task Force.
Voici le code utilisé par les livres:
import acm.program.*;
public class LeapYear extends ConsoleProgram {
public void run()
{
println("This program calculates leap year.");
int year = readInt("Enter the year: ");
boolean isLeapYear = ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0));
if (isLeapYear)
{
println(year + " is a leap year.");
} else
println(year + " is not a leap year.");
}
}
Voilà comment j'ai calculé l'année bissextile.
import acm.program.*;
public class LeapYear extends ConsoleProgram {
public void run()
{
println("This program calculates leap year.");
int year = readInt("Enter the year: ");
if ((year % 4 == 0) && year % 100 != 0)
{
println(year + " is a leap year.");
}
else if ((year % 4 == 0) && (year % 100 == 0) && (year % 400 == 0))
{
println(year + " is a leap year.");
}
else
{
println(year + " is not a leap year.");
}
}
}
Y a-t-il un problème avec mon code ou dois-je utiliser celui fourni par le livre?
EDIT :: Les deux codes ci-dessus fonctionnent bien. Ce que je veux demander, c'est quel code est le meilleur moyen de calculer l'année bissextile.
Ils me ressemblent, mais notez que cette ligne dans votre code a une certaine redondance:
else if ((year % 4 == 0) && (year % 100 == 0) && (year % 400 == 0))
pourrait être remplacé par:
else if (year % 400 == 0)
Si un nombre est un multiple de 400, il est automatiquement un multiple de 100 et 4.
edit: (7 ans plus tard!)
Notez que ce qui précède suppose la présence de la if ((year % 4 == 0) && year % 100 != 0) précédente de la question initiale! </ Strike>
la réponse de cletus devrait être celle acceptée: https://stackoverflow.com/a/1021373/8331
(Je supprimerais ma propre réponse, mais je ne peux pas car c'est accepté le)
La mise en œuvre correcte est:
public static boolean isLeapYear(int year) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365;
}
Mais si vous réinventez cette roue, alors:
public static boolean isLeapYear(int year) {
if (year % 4 != 0) {
return false;
} else if (year % 400 == 0) {
return true;
} else if (year % 100 == 0) {
return false;
} else {
return true;
}
}
Je vous suggère de mettre ce code dans une méthode et de créer un test unitaire.
public static boolean isLeapYear(int year) {
assert year >= 1583; // not valid before this date.
return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
Dans le test unitaire
assertTrue(isLeapYear(2000));
assertTrue(isLeapYear(1904));
assertFalse(isLeapYear(1900));
assertFalse(isLeapYear(1901));
Pseudo-code de Wikipedia traduit en Java le plus compact
(year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))
new GregorianCalendar().isLeapYear(year);
Test de l'année bissextile le plus efficace:
if ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0))
{
/* leap year */
}
Ceci est un extrait de ma réponse détaillée sur https://stackoverflow.com/a/11595914/733805
À partir du code source du calendrier GregorianCalendar de Java:
/**
* Returns true if {@code year} is a leap year.
*/
public boolean isLeapYear(int year) {
if (year > changeYear) {
return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}
return year % 4 == 0;
}
Où changeYear est l'année où le calendrier julien devient le calendrier grégorien (1582).
Le calendrier julien spécifie les années bissextiles tous les quatre ans, alors que le Le calendrier grégorien omet les années-siècles non divisibles par 400.
Dans la documentation du calendrier Gregorian , vous trouverez plus d'informations à ce sujet.
Si vous utilisez Java8:
Java.time.Year.of(year).isLeap()
Implémentation Java de la méthode ci-dessus:
public static boolean isLeap(long year) {
return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
}
Il est presque toujours faux de se répéter dans un logiciel. Dans toute discipline d'ingénierie, la forme doit suivre la fonction, et vous avez trois branches pour quelque chose qui a deux chemins possibles - c'est une année bissextile ou non.
Le mécanisme qui a le test sur une ligne n'a pas ce problème, mais généralement, il serait préférable de séparer le test en une fonction qui prend un int représentant une année et renvoie un booléen représentant le fait que l'année soit ou non une année bissextile . De cette façon, vous pouvez utiliser quelque chose d'autre que l'impression sur une sortie standard de la console et le tester plus facilement.
Dans le code dont on sait qu'il dépasse son budget de performances, il est habituel d'organiser les tests pour qu'ils ne soient pas redondants et d'effectuer les tests dans un ordre qui leur soit renvoyé rapidement. L’exemple de wikipedia répond à cet objectif - la plupart des années, vous devez calculer les modulo 400,100 et 4, mais pour quelques-uns, vous n’avez besoin que de modulo 400 ou 400 et 100. C’est une petite optimisation en termes de performances (au mieux, un sur cent). les entrées sont effectuées), mais cela signifie également que le code a moins de répétition et que le programmeur a moins à taper.
Vous pouvez demander à la classe GregorianCalendar :
boolean isLeapyear = new GregorianCalendar().isLeapYear(year);
Comme wikipedia États algorithme pour l'année bissextile devrait être
(((year%4 == 0) && (year%100 !=0)) || (year%400==0))
Voici un exemple de programme comment vérifier l'année bissextile .
import Java.util.Scanner;
public class LeapYear {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
System.out.print("Enter the year then press Enter : ");
int year = input.nextInt();
if ((year < 1580) && (year % 4 == 0)) {
System.out.println("Leap year: " + year);
} else {
if ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) {
System.out.println("Leap year: " + year);
} else {
System.out.println(year + " not a leap year!");
}
}
}
}
Au cours de: https://tmc.mooc.fi , que l'un des exercices était de ce type, j'ai écrit cette réponse:
import Java.util.Scanner;
public class LeapYear {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.println("Type a year: ");
int year = Integer.parseInt(reader.nextLine());
if (year % 400 == 0 && year % 100 == 0 && year % 4 == 0) {
System.out.println("The year is a leap year");
} else
if (year % 4 == 0 && year%100!=0 ) {
System.out.println("The year is a leap year");
} else
{
System.out.println("The year is not a leap year");
}
}
}
Votre code, tel qu'il est, sans classe supplémentaire, ne semble pas fonctionner pour Java universel ..__ Voici une version simplifiée qui fonctionne n'importe où, se penchant davantage vers votre code.
import Java.util.*;
public class LeapYear {
public static void main(String[] args) {
int year;
{
Scanner scan = new Scanner(System.in);
System.out.println("Enter year: ");
year = scan.nextInt();
if ((year % 4 == 0) && year % 100 != 0) {
System.out.println(year + " is a leap year.");
} else if ((year % 4 == 0) && (year % 100 == 0)
&& (year % 400 == 0)) {
System.out.println(year + " is a leap year.");
} else {
System.out.println(year + " is not a leap year.");
}
}
}
}
Votre code, dans son contexte, fonctionne tout aussi bien, mais notez que le code de livre fonctionne toujours , et est testé de manière approfondie. Pour ne pas dire le vôtre n'est pas. :)
meilleure façon de rendre l'année bissextile Java plus claire à comprendreenter code here
import Java.util.Scanner;
classe que19 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
double a;
System.out.println("enter the year here ");
a=input.nextDouble();
if ((a % 4 ==0 ) && (a%100!=0) || (a%400==0)) {
System.out.println("leep year");
}
else {
System.out.println("not a leap year");
}
}
}
cette réponse est géniale, mais cela ne fonctionnera pas avant des années avant Jésus-Christ (avec un calendrier proleptique grégorien). Si vous voulez que cela fonctionne pour la Colombie-Britannique années, utilisez ensuite l'adaptation suivante:
public static boolean isLeapYear(final int year) {
final Calendar cal = Calendar.getInstance();
if (year<0) {
cal.set(Calendar.ERA, GregorianCalendar.BC);
cal.set(Calendar.YEAR, -year);
} else
cal.set(Calendar.YEAR, year);
return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365;
}
Vous pouvez le vérifier vous-même en considérant que l'année -5 (c'est-à-dire 4 av. J.-C.) devrait être prononcée comme une année bissextile dans l'hypothèse d'un calendrier grégorien proleptique. Même avec l'année -1 (l'année avant 1 AD). Le lien de réponse ne gère pas ce cas, contrairement au code adapté ci-dessus.
C'est ce que je suis venu avec. Il existe une fonction supplémentaire permettant de vérifier si l'int est passé de la date à laquelle les exceptions ont été imposées (année $ 100, année% 400). Avant 1582, ces exceptions n'existaient pas.
import Java.util.Scanner;
public class lecture{
public static void main(String[] args) {
boolean loop=true;
Scanner console = new Scanner( System.in );
while (loop){
System.out.print( "Enter the year: " );
int year= console.nextInt();
System.out.println( "The year is a leap year: "+ leapYear(year) );
System.out.print( "again?: " );
int again = console.nextInt();
if (again == 1){
loop=false;
}//if
}
}
public static boolean leapYear ( int year){
boolean leaped = false;
if (year%4==0){
leaped = true;
if(year>1582){
if (year%100==0&&year%400!=0){
leaped=false;
}
}
}//1st if
return leaped;
}
}
public static void main(String[] args)
{
String strDate="Feb 2013";
String[] strArray=strDate.split("\\s+");
Calendar cal = Calendar.getInstance();
cal.setTime(new SimpleDateFormat("MMM").parse(strArray[0].toString()));
int monthInt = cal.get(Calendar.MONTH);
monthInt++;
cal.set(Calendar.YEAR, Integer.parseInt(strArray[1]));
strDate=strArray[1].toString()+"-"+monthInt+"-"+cal.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(strDate);
}