Sto lavorando a un progetto. Lì dovrei trovare le settimane totali di un anno. Ho provato con il seguente codice, ma ho la risposta sbagliata: 2020 ha 53 settimane, ma questo codice dà 52 settimane.

Dove ho sbagliato in questo codice?

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

    }

}

Produzione:

52

Usando la definizione di Wikipedia qui . Un anno ha 53 settimane se il 1 ° gennaio è un giovedì o il 31 dicembre è un giovedì, altrimenti ha 52 settimane. Questa definizione è equivalente a quella che hai usato. Penso che questa sia una condizione molto più facile da verificare, in quanto non è necessario controllare per gli anni bisestili.

Utilizzo delle 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

Per una settimana ISO 8601 standard, utilizzare la YearWeekclasse dalla libreria ThreeTen-Extra con un'istruzione ternaria.

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. 

Questo è, YearWeek.of( 2020 , 1 ).is53WeekYear() ? 53 : 52

Definisci "settimana"

Devi definire una settimana. Nell'esempio di codice, la definizione di settimana varia in base all'impostazione predefinita corrente della JVM Locale. Quindi i risultati possono variare in fase di esecuzione.

Il tuo codice utilizza anche terribili classi data-ora che sono state soppiantate anni fa dalle moderne classi java.time . Smetti di usare GregorianCalendar& Calendar; sono stati sostituiti per buoni motivi.

Settimana ISO 8601

L'ISO 8601 norma definisce una settimana come:

• Le settimane iniziano lunedì , finiscono domenica.
• La settimana n. 1 ha il primo giovedì dell'anno civile.

Tale definizione significa:

• Il primo e l'ultimo giorno di un anno di riferimento settimanale possono essere i giorni finali / iniziali dell'anno civile precedente / successivo.
• L'anno su base settimanale ha 52 o 53 settimane complete.

Se la tua definizione differisce, vedi la risposta di Ole VV .

YearWeek:is53WeekYear

Se questo corrisponde alla tua definizione, aggiungi la libreria ThreeTen-Extra al tuo progetto per estendere la funzionalità java.time integrata in Java 8 e versioni successive. Quindi hai accesso alla YearWeekclasse.

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

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

Per chiedere informazioni su un determinato anno settimanale, scegli arbitrariamente qualsiasi settimana dell'anno. Ad esempio, per l'anno 2020 a settimana chiediamo la settimana n. 1.

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

settimaneLungo = 53

weekStart = 30-12-2019

Si noti come il primo giorno dell'anno della settimana del 2020 è dell'anno civile 2019.

La soluzione flessibile

Questo dovrebbe funzionare per qualsiasi schema di numerazione settimanale che può essere rappresentato in un WeekFieldsoggetto.

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'idea è quella di trovare il numero della settimana dell'ultima settimana dell'anno in base alla settimana. Provo prima con il 31 dicembre, ma potrebbe essere la prima settimana dell'anno successivo. Se è così, ci torno una settimana fa.

Ho provato abbastanza accuratamente WeekFields.ISO, non tanto con altri WeekFieldsoggetti, ma come ho detto, credo che funzioni.

Se sai per certo che avrai sempre bisogno di ISO 8601 settimane, penso che dovresti andare con una delle buone risposte di Sweeper e Basil Bourque . L'ho pubblicato nel caso in cui fosse necessaria una soluzione più flessibile che funzionasse anche con altri schemi di numerazione settimanali.

Usa java.time

Il codice nella tua domanda è divertente in quanto importa classi sia da Joda-Time che da java.time, eppure utilizza il vecchio Calendare GregorianCalendarda Java 1.1. Queste classi sono state progettate male e sono ormai obsolete, non dovresti usarle. Joda-Time è in modalità manutenzione, java.time è subentrato dopo di esso. Che è quello che uso e raccomando di usare.

Penso che dovrebbe funzionare anche bene:

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

Dopo aver provato molto in Java 8. Non sono riuscito a trovare una soluzione. poi ho preparato la dipendenza da data e ora di Joda. Mi ha dato una buona risposta come mi aspettavo

codice:

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

Dipendenza di Maven:

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