calculer le nombre de semaines dans une année donnée

Je voudrais obtenir le nombre de semaines dans une année donnée. Même si 52 est acceptée comme une généralisé dans le monde de réponse, les calendriers pour 2015, 2020 et 2026 fait avoir 53 semaines.

Est-il possible que je peux la calculer, ou toutes les fonctions qui vont m'aider?

Commentaire général, pour tout ce qui n'est pas exactement la réponse à la question ci-dessus, mais est utile de connaître: comprendre pourquoi le Calendrier de la classe renvoie 53 "nombre de semaines dans une année", vous devez comprendre comment la getFirstDayOfWeek() et getMinimalDaysInFirstWeek() méthodes sont utilisées dans le calcul. Si le "premier jour de la semaine" est spécifié que le lundi par exemple, et le "minimal jours dans la première semaine est de 4 et le premier lundi de l'année est le 5 janvier, puis la semaine précédant le 5 janvier, est considérée comme faisant partie de cette même année.

OriginalL'auteur AndroidGuy | 2012-01-04

11

Selon l'article de wikipedia sur Semaine ISO format de la date, Vous pouvez la calculer à l'aide de code suivant.
```
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, 2015);
    cal.set(Calendar.MONTH, Calendar.DECEMBER);
    cal.set(Calendar.DAY_OF_MONTH, 31);

    int ordinalDay = cal.get(Calendar.DAY_OF_YEAR);
    int weekDay = cal.get(Calendar.DAY_OF_WEEK) - 1; //Sunday = 0
    int numberOfWeeks = (ordinalDay - weekDay + 10) / 7;
    System.out.println(numberOfWeeks);
```
merci Manjula. D'une certaine manière mon problème a été résolu automatiquement. Je pense que le Calendrier de la classe de ne pas considérer la semaine 53. (aucune idée, le format de Date, il suit...). Mais le calendrier.set(Calendrier.WEEK_OF_YEAR, 52); calendrier.set(Calendrier.ANNÉE, 2015); SimpleDateFormat formatter = new SimpleDateFormat("ddMMM aaaa"); Date startDate = calendrier.getTime(); calendrier.add(Calendar.DATE, 6); Date endDate = calendrier.getTime(); donne-moi de commencer & date de fin de la semaine 27 Dec2015 & 2e Jan2016. 🙂 🙂 (ces dates, je m'attendais pour la semaine 53, qui a été la raison pour laquelle cette question thread.. 🙂 )
De ce fait introduire un bug. J'ai juste essayé: pour 2016, retour 52, mais le Calendrier considèrent avoir 53 semaines. En fait, elle a 53 semaines car il commencer avec un jeudi. Je passe en revue votre fonction: je vais poster ci-dessous. Merci de modifier votre réponse afin de supprimer ce bug 🙂

OriginalL'auteur Manjula
12

Rapide de deux liner:
```
Calendar calendar = Calendar.getInstance();
Integer weeksOfYear = calendar.getActualMaximum(Calendar.WEEK_OF_YEAR);
```
Il aurait été agréable de voir une explication plus détaillée de cette méthode. getActualMaximum de manière itérative en compte le nombre total en fonction de l'heure, alors que getMaximum retourne la valeur maximale de ce champ. Donc getActualMaximum est en effet la réponse à cette question.
Ce doit être la accepté de répondre!

OriginalL'auteur Samuel
10

Vous pouvez coder vous-même avec les informations suivantes à partir de ISO semaine date.

En moyenne, une année a 53 semaines tous les 5,6 ans.

La suite de 71 ans dans un des 400 ans de cycle (ajouter 2000 pour les années courantes) ont 53 semaines. Ans non inscrits ont de 52 semaines.

004, 009, 015, 020, 026, 032, 037, 043, 048, 054, 060, 065, 071, 076, 082, 088, 093, 099, 105, 111, 116, 122, 128, 133, 139, 144, 150, 156, 161, 167, 172, 178, 184, 189, 195, 201, 207, 212, 218, 224, 229, 235, 240, 246, 252, 257, 263, 268, 274, 280, 285, 291, 296, 303, 308, 314, 320, 325, 331, 336, 342, 348, 353, 359, 364, 370, 376, 381, 387, 392, 398.

Vous pouvez utiliser les informations ci-dessus pour revenir à 52 ou 53 en conséquence 🙂

OriginalL'auteur COD3BOY

    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, 2015);
    cal.set(Calendar.MONTH, Calendar.DECEMBER);
    cal.set(Calendar.DAY_OF_MONTH, 31);
    System.out.println(cal.get(Calendar.WEEK_OF_YEAR));

Il ne fonctionne pas à chaque année. Même votre exemple ne retour "1" au lieu de 53.
Mais c'est une semaine 01. Numéro de la semaine est définie dans la norme ISO-8601. La semaine 1 est celui avec le premier jeudi de l'année.

OriginalL'auteur pap

4

Je voudrais donner mon point de vue sur l'utilisation de la Date de la nouvelle API de Java 8 avec la main à l'exécution de code:
```
private static long getNumberOfWeeksInYear(LocalDate date) {
    LocalDate middleOfYear = date.withDayOfMonth(1).withMonth(6);
    return middleOfYear.range(WeekFields.ISO.weekOfWeekBasedYear()).getMaximum();
}

public static void main(String[] args) {
    for (int year = 2000; year < 2400; year++) {
        long numberOfWeeks = getNumberOfWeeksInYear(LocalDate.of(year, 1, 1));
        if (numberOfWeeks != 52) {
            System.out.println(year + " has " + numberOfWeeks + " weeks");
        }
    }
}
```
La sortie est:

2004 a 53 semaines
2009 a 53 semaines
2015 a 53 semaines

2020 53 semaines
2026 dispose de 53 semaines
2032 dispose de 53 semaines
...

Et ainsi de suite...

La date.withDayOfMonth(1).withMonth(6); truc, c'est parce que l'omission de cette résultats légèrement différents de la sortie si LocalDate.of(year, 1, 1) est passé:

2004 a 53 semaines
2005 a 53 semaines
...

Je suis encore nouveau pour le Java 8 date de l'API, mais mon je suis assez sûr que ce comportement est dommage parce que 2005-01-01 est la partie de la semaine 53 de 2014. Cela rend date.range(WeekFields.ISO.weekOfWeekBasedYear()).getMaximum() de retourner le nombre de semaines pour la semaine en fonction de l'année de 2014.

OriginalL'auteur Magnilex

Lien vers la réponse

gregorianCalendar.set(year, 12, 31);
int totalWeeks = gregorianCalendar.getMaximum(Calendar.WEEK_OF_YEAR);

OriginalL'auteur murt

@Manjula Weerasinge réponse en fait introduire un bug pour 2016. Voici une meilleure solution.

Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
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(year)){
   if (weekDay == Calendar.THURSDAY || weekDay == Calendar.WEDNESDAY)
      return 53;
   else
      return 52;
} else {
   if (weekDay == Calendar.THURSDAY)
      return 53;
   else
      return 52;
}

OriginalL'auteur Luca Nicoletti

Cette méthode calcule le nombre de semaines de l'année ISO à l'aide de la Joda time library.

    import org.joda.time.DateTime;
    import org.joda.time.DateTimeZone;

    public static int weeksInYear(int year) {
        return new DateTime(DateTimeZone.forID("America/Los_Angeles"))
            .withWeekyear(year + 1)
            .withWeekOfWeekyear(1)
            .minusWeeks(1)
            .getWeekOfWeekyear();
    }

OriginalL'auteur Marian Zetu

0

Pour le format de date ISO, nous pouvons calculer le nombre de semaines comme suit:
```
int getNoOfWeeks(int year) {
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, year);
    cal.setMinimalDaysInFirstWeek(4);
    cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
    return cal.getActualMaximum(Calendar.WEEK_OF_YEAR);
}
```
Donc, pour l'année = 2018, il sera de retour 52, pour 2019, il sera également de retour 52, mais à l'horizon 2020, il sera de retour 53 de l'année ISO dispose de 52 ou de 53 semaines.

OriginalL'auteur arifng

Vous devez vous connecter pour publier un commentaire.