L'implémentation 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 allez réinventer 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;
  }
}

java.time.Year::isLeap

Je voudrais ajouter la nouvelle java.time façon de le faire avec le Year classe et isLeap méthode:

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

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

new GregorianCalendar().isLeapYear(year);

Pseudo code de Wikipédia traduit dans le Java le plus compact

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

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 à https://stackoverflow.com/a/11595914/733805

Il est possible de créer un code source de type 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 calendrier grégorien omet les années du siècle qui ne sont pas divisibles par 400.

Dans la documentation du calendrier grégorien vous pouvez trouver 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 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 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 si l'année est ou non une année bissextile. Que façon dont vous pouvez faire quelque chose avec elle autre que l'impression à la sortie standard sur la console, et peut plus facilement le tester.

Dans le code qui est connu pour dépasser son budget de performance, il est habituel d'organiser les tests de sorte qu'ils ne soient pas redondants et d'effectuer les tests dans un ordre qui revient tôt. L'exemple de Wikipedia fait cela-pour la plupart des années, vous devez calculer 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 performance (au mieux, seulement une entrée sur cent est effectuée), mais cela signifie également que le code a moins de répétition, et il y a moins pour le programmeur à taper.

Vous pouvez demander à la classe GregorianCalendar pour cela:

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

Avec le cours de: TestMyCode Programming assignment evaluator , que l'un des exercices était 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");
        }

    }
}

C'est Ce que je suis venu avec. Il y a une fonction ajoutée pour vérifier si l'int est passé 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);    



}

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

        }
    }
}

Comme wikipedia membres de l'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 pour l'année bissextile.

Votre code, tel qu'il est, sans une classe supplémentaire, ne semble pas fonctionner pour universal java. 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, en contexte, fonctionne tout aussi bien, mais notez que le code du livre fonctionne toujours et est testé à fond. Pour ne pas dire que le vôtre ne l'est pas.:)

Meilleure façon ta faire java année bissextile et plus clair à comprendre enter 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 excellente mais elle ne fonctionnera pas pendant des années avant Christ (en utilisant un calendrier grégorien proleptique). Si vous voulez que cela fonctionne pendant des années en Colombie-Britannique, utilisez 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 vérifier cela par vous-même en considérant que l'année -5 (c'est-à-dire 4 avant JC) devrait être prononcée comme une année bissextile en supposant un calendrier grégorien proleptique. Même avec l'année -1 (l'année avant 1 ANNONCE). La réponse liée à ne gère pas ce cas alors que le code adapté ci-dessus le fait.

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

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