Je travaille sur un projet. Là, je devrais trouver le total des semaines d'une année. J'ai essayé avec le code suivant, mais je reçois la mauvaise réponse: 2020 a 53 semaines, mais ce code donne 52 semaines.

Où me suis-je trompé dans ce code?

package com.hib.mapping;

import java.time.LocalDate;
import java.time.temporal.WeekFields;
import java.util.Calendar;
import java.util.GregorianCalendar;

import org.joda.time.DateTime;

public class TestWeek {

    public static void main(String args[]) {
        System.out.println(getWeeks());
    }

    public static int getWeeks() {

        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        cal.set(Calendar.MONTH, Calendar.JANUARY);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        GregorianCalendar gregorianCalendar = new GregorianCalendar();

        int weekDay = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (gregorianCalendar.isLeapYear(2020)) {
            if (weekDay == Calendar.THURSDAY || weekDay == Calendar.WEDNESDAY)
                return 53;
            else
                return 52;
        } else {
            if (weekDay == Calendar.THURSDAY)
                return 53;
            else
                return 52;
        }

    }

}

Production:

52

Utilisation de la définition Wikipedia ici . Une année compte 53 semaines si le 1er janvier est un jeudi ou le 31 décembre est un jeudi, sinon elle compte 52 semaines. Cette définition est équivalente à celle que vous avez utilisée. Je pense que c'est une condition beaucoup plus facile à vérifier, car vous n'avez pas besoin de vérifier les années bissextiles.

Utilisation des java.timeAPI Java 8 :

int year = 2020;
boolean is53weekYear = LocalDate.of(year, 1, 1).getDayOfWeek() == DayOfWeek.THURSDAY ||
        LocalDate.of(year, 12, 31).getDayOfWeek() == DayOfWeek.THURSDAY;
int weekCount = is53weekYear ? 53 : 52;

tl; dr

Pour une semaine ISO 8601 standard, utilisez la YearWeekclasse de la bibliothèque ThreeTen-Extra avec une déclaration ternaire.

YearWeek          // Represents an entire week of a week-based-year.
.of( 2020 , 1 )   // Pass the number of the week-based-year (*not* calendar year), and a week number ranging from 1 to 52 or 1 to 53.
.is53WeekYear()   // Every standard week-based-year has either 52 or 52 complete weeks.
? 53              // Ternary statement returns 53 if the predicate returns True, …
: 52              // … otherwise returns 52. 

C'est, YearWeek.of( 2020 , 1 ).is53WeekYear() ? 53 : 52

Définir la «semaine»

Vous devez définir une semaine. Dans votre exemple de code, la définition de week varie selon la valeur par défaut actuelle de la JVM Locale. Vos résultats peuvent donc varier lors de l'exécution.

Votre code utilise également de terribles classes de date-heure qui ont été remplacées il y a des années par les classes modernes de java.time . Arrêtez d'utiliser GregorianCalendar& Calendar; ils ont été remplacés pour de bonnes raisons.

ISO 8601 semaine

L' ISO 8601 norme définit une semaine comme:

• Les semaines commencent le lundi et se terminent le dimanche.
• La semaine # 1 a le premier jeudi de l'année civile.

Cette définition signifie:

• Les premiers et derniers jours d'une année hebdomadaire peuvent être les jours de fin / début de l'année civile précédente / suivante.
• L'année hebdomadaire comprend 52 ou 53 semaines complètes.

Si votre définition diffère, consultez la réponse d'Ole VV .

YearWeek:is53WeekYear

Si cela correspond à votre définition, ajoutez la bibliothèque ThreeTen-Extra à votre projet pour étendre la fonctionnalité java.time intégrée à Java 8 et versions ultérieures. Vous avez alors accès à la YearWeekclasse.

ZoneId z = ZoneId.of( "America/Montreal" ) ;
YearWeek yearWeekNow = YearWeek.now( z ) ;
boolean is53WeekYear = yearWeekNow.is53WeekYear() ;

int weeksLong = yearWeekNow.is53WeekYear() ? 53 : 52 ;

Pour vous renseigner sur une année en particulier, choisissez simplement n'importe quelle semaine de l'année. Par exemple, pour l'année 2020 basée sur la semaine, nous demandons la semaine # 1.

int weeksLong = YearWeek.of( 2020 , 1 ).is53WeekYear() ? 53 : 52 ;
LocalDate weekStart = YearWeek.of( 2020 , 1 ).atDay( DayOfWeek.MONDAY ) ;

semaines Long = 53

weekStart = 2019-12-30

Remarquez comment le premier jour de l'année hebdomadaire 2020 est à partir de l'année civile 2019.

La solution flexible

Cela devrait fonctionner pour tout schéma de numérotation de semaine qui peut être représenté dans un WeekFieldsobjet.

public static int noOfWeeks(WeekFields wf, int year) {
    LocalDate lastDayOfYear = YearMonth.of(year, Month.DECEMBER).atEndOfMonth();
    if (lastDayOfYear.get(wf.weekBasedYear()) > year) { // belongs to following week year
        return lastDayOfYear.minusWeeks(1).get(wf.weekOfWeekBasedYear());
    }
    else {
        return lastDayOfYear.get(wf.weekOfWeekBasedYear());
    }
}

L'idée est de trouver le numéro de semaine de la dernière semaine de l'année basée sur la semaine. J'essaie d'abord avec le 31 décembre, mais cela peut être dans la première semaine de l'année suivante. Si c'est le cas, je retourne une semaine en arrière.

J'ai testé assez soigneusement avec WeekFields.ISO, pas tellement avec d'autres WeekFieldsobjets, mais comme je l'ai dit, je crois que cela fonctionne.

Si vous savez pertinemment que vous aurez toujours besoin d' ISO 8601 semaines, je pense que vous devriez choisir l'une des bonnes réponses de Sweeper et de Basil Bourque . J'ai posté cela au cas où vous auriez besoin d'une solution plus flexible qui fonctionnerait également avec d'autres schémas de numérotation des semaines.

Utilisez java.time

Le code dans votre question est drôle en ce qu'il importe des classes à la fois de Joda-Time et de java.time, tout en utilisant l'ancien Calendar et GregorianCalendarde Java 1.1. Ces classes étaient mal conçues et sont maintenant dépassées depuis longtemps, vous ne devriez pas les utiliser. Joda-Time est en mode maintenance, java.time a pris le relais. C'est ce que j'utilise et vous recommande d'utiliser.

Je pense que cela devrait aussi bien fonctionner:

int year = 2020;
long numOfWeeks = LocalDate.of(year, 1, 1).datesUntil(LocalDate.of(year, 12, 31), Period.ofDays(7)).count();
System.out.println("Weeks: " + numOfWeeks);

Après avoir essayé beaucoup en java 8. Je n'ai pas pu trouver de solution. puis j'ai préparé la dépendance de date et d'heure de Joda. Cela m'a donné une bonne réponse comme je m'y attendais

code:

for (int i = 2020; i < 2100; i++) {
  int weeks = new DateTime().withYear(i).weekOfWeekyear().getMaximumValue();
  System.out.println(i + " years : " + weeks); 
}

Dépendance Maven:

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.10.5</version>
</dependency>