Code Java pour calculer l'année bissextile

Question

Je suis les "art et sciences de Java". livre 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.");
    }

}

Maintenant, voici 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 at-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.

Answer 1

Ils me ressemblent, mais notez que cette ligne de votre code présente 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.

modifier: (7 ans plus tard!)

Veuillez noter que ce qui précède suppose la présence du précédent si ((année% 4 == 0) & amp; & amp & & amp%; 100% = = 0) à partir de la question initiale!

La réponse de

cletus devrait être la réponse acceptée: https://stackoverflow.com/a/1021373/8331

(Je supprimerais ma propre réponse, mais je ne peux pas car c'est accepté le

).

Answer 2

La bonne implémentation 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;
  }
}

Answer 3

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));

Answer 4

java.time.Year :: isLeap

J'aimerais ajouter le nouveau java.time de cette manière avec le Année et isLeap méthode:

java.time.Year.of(year).isLeap()

Answer 5

new GregorianCalendar().isLeapYear(year);

Answer 6

Pseudo-code de Wikipédia traduit en Java le plus compact

(year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))

Answer 7

Test d'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 à l'adresse https://stackoverflow.com/a/11595914/733805

Answer 8

Extrait du code source de 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 non divisibles par 400.

Dans la documentation sur le calendrier grégorien . peut trouver plus d'informations à ce sujet.

Answer 9

Il est presque toujours faux d’avoir une répétition 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 voies 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 indiquant si l'année est 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 de manière à ce qu’ils ne soient pas redondants et d’effectuer les tests dans un ordre renvoyé plus tôt. L’exemple de wikipedia fait cela - 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 seul 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 en a moins à taper.

Answer 10

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);
    }

Answer 11

Vous pouvez demander au GregorianCalendar classe pour cela:

boolean isLeapyear = new GregorianCalendar().isLeapYear(year);

Answer 12

C'est ce que j'ai proposé. 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;
}
} 

Answer 13

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);    



}

Answer 14

    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!");
            }

        }
    }
}

Answer 15

Cet wikipedia doit être un algorithme pour l'année bissextile

.

(((year%4 == 0) && (year%100 !=0)) || (year%400==0))  

Voici un exemple de programme comment vérifier pour l'année bissextile .

Answer 16

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 minutieusement testé. Pour ne pas dire le vôtre n'est pas :)

Answer 17

Le moyen le plus simple de rendre l'année java java plus claire et plus facile à comprendre saisir le code ici

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");
    }
}

}

Answer 18

Avec le cours de https://tmc.mooc.fi , l'un des exercices consistait à: ce genre de problème, 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");
        }

    }
}

Answer 19

cette réponse est excellente, mais elle ne fonctionnera pas avant des années précédant 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 considérée comme une année bissextile dans l'hypothèse d'un calendrier grégorien proleptique. Idem avec l'année -1 (l'année avant 1 après JC). Le lien à répondre ne gère pas ce cas, contrairement au code adapté ci-dessus.

Answer 20

import javax.swing.*;
public class LeapYear {
    public static void main(String[] args) {
    int year;
String yearStr = JOptionPane.showInputDialog(null, "Enter radius: " );

year = Integer.parseInt( yearStr );

boolean isLeapYear;
isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);  

 if(isLeapYear){ 
JOptionPane.showMessageDialog(null, "Leap Year!"); 
 }  
 else{
JOptionPane.showMessageDialog(null, "Not a Leap Year!"); 
    }
    }
    }

Answer 21

boolean leapYear = ( ( year % 4 ) == 0 );