DateFormat d = new SimpleDateFormat("D");
System.out.println(d.format(date));

import java.util.Calendar;
// ...
final int julianDay = Calendar.getInstance().get(Calendar.DAY_OF_YEAR);

notez que cela ne tient pas compte de l'accord" commence à midi " réclamé par ce site bizarre que vous avez mentionné. Cela pourrait être corrigé en vérifiant l'heure, bien sûr.

si nous obtenons un double rendez-vous avec julian tel que chordiant decision manager

http://java.ittoolbox.com/groups/technical-functional/java-l/java-function-to-convert-julian-date-to-calendar-date-1947446

ce qui suit fonctionne mais le second n'est pas pris en charge Comment puis-je convertir entre une date Java et le numéro Julian day?

public static String julianDate (String julianDateStr) {

    try{
        // Calcul date calendrier Gr?gorien ? partir du jour Julien ?ph?m?ride 
        // Tous les calculs sont issus du livre de Jean MEEUS "Calcul astronomique" 
        // Chapitre 3 de la soci?t? astronomique de France 3 rue Beethoven 75016 Paris 
        // Tel 01 42 24 13 74 
        // Valable pour les ann?es n?gatives et positives mais pas pour les jours Juliens n?gatifs
        double jd=Double.parseDouble(julianDateStr);
          double z, f, a, b, c, d, e, m, aux;
            Date date = new Date();
            jd += 0.5;
            z = Math.floor(jd);
            f = jd - z;

            if (z >= 2299161.0) {
              a = Math.floor((z - 1867216.25) / 36524.25);
              a = z + 1 + a - Math.floor(a / 4);
            } else {
              a = z;
            }

            b = a + 1524;
            c = Math.floor((b - 122.1) / 365.25);
            d = Math.floor(365.25 * c);
            e = Math.floor((b - d) / 30.6001);
            aux = b - d - Math.floor(30.6001 * e) + f;
            Calendar calendar = new GregorianCalendar();
            calendar.setTime(date);
            calendar.set(Calendar.DAY_OF_MONTH, (int) aux);

            double hhd= aux-calendar.get(Calendar.DAY_OF_MONTH);                
            aux = ((aux - calendar.get(Calendar.DAY_OF_MONTH)) * 24);




            calendar.set(Calendar.HOUR_OF_DAY, (int) aux);

            calendar.set(Calendar.MINUTE, (int) ((aux - calendar.get(Calendar.HOUR_OF_DAY)) * 60));



         // Calcul secondes 
            double mnd = (24 * hhd) - calendar.get(Calendar.HOUR_OF_DAY);
            double ssd = (60 * mnd) - calendar.get(Calendar.MINUTE); 
            int ss = (int)(60 * ssd);
            calendar.set(Calendar.SECOND,ss);



            if (e < 13.5) {
              m = e - 1;
            } else {
              m = e - 13;
            }
            // Se le resta uno al mes por el manejo de JAVA, donde los meses empiezan en 0.
            calendar.set(Calendar.MONTH, (int) m - 1);
            if (m > 2.5) {
              calendar.set(Calendar.YEAR, (int) (c - 4716));
            } else {
              calendar.set(Calendar.YEAR, (int) (c - 4715));
            }


        SimpleDateFormat sdf=new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
        //System.out.println("Appnumber= "+appNumber+" TimeStamp="+timeStamp+" Julian Date="+julianDateStr+" Converted Date="+sdf.format(calendar.getTime()));
        return sdf.format(calendar.getTime());

}catch(Exception e){
    e.printStackTrace();
}
return null;

}  

j'ai lu tous les billets et quelque chose n'est pas très clair je pense.

user912567 a mentionné Jean Meeus, et il a absolument raison

la définition la plus précise que j'ai trouvée est donnée par Jean Meeus dans son livre "Astronomical Algorithms" (a must have, really...).

la Date Julienne est un date, exprimé comme d'habitude, avec une année, un mois et un jour.

Jour Julien est un (un nombre réel), à compter de l'année -4712 et de l'est "...continu nombre de jours..."(et fraction de jour). utile échelle de temps utilisée pour des calculs astronomiques précis.

Jean Meeus : "Le Jour Julien n'a rien à voir avec le calendrier Julien" ("Astronomical algorithms", 2ème Édition, p.59)

tl;dr

LocalDate.now( ZoneId.of( “America/Montreal” ) ).getDayOfYear()

"jour Julien" terminologie

le terme "Julian day" est parfois utilisé de façon vague pour signifier le ordinal jour de l'année, ou date ordinale, ce qui signifie un nombre de 1 à 365 ou 366 (les années bissextiles). Le 1er janvier est 1, janvier 2 est 2, le 31 Décembre est 365 (ou 366 dans les années bissextiles).

Ce lâche (mauvaise) utilisation de Julian vient probablement de la utilisation en astronomie et autres zones de suivi des dates comme un nombre continu de jours depuis midi temps universel le 1er janvier, 4713 BCE (sur le calendrier Julien). Aujourd'hui, la date julienne approche les deux millions et demi,2,457,576 aujourd'hui.

java.temps

la java.le cadre de temps intégré dans Java 8 et plus fournit une facilité facile pour obtenir le jour de l'année.

LocalDate classe représente une date seule valeur sans Heure de la journée et sans fuseau horaire. Vous pouvez interroger pour le jour de l'année.

LocalDate localDate = LocalDate.of ( 2010 , Month.JUNE , 8 );
int dayOfYear = localDate.getDayOfYear ();

Dump à console. Les résultats montrent que le 8 juin 2010 est bien le jour # 159.

System.out.println ( "localDate: " + localDate + " | dayOfYear: " + dayOfYear );

localDate: 2010-06-08 | dayOfYear: 159

un fuseau horaire est crucial pour déterminer une date. Pour un moment donné, la date varie autour du globe par zone. Par exemple, quelques minutes après minuit à Paris, La France est un nouveau jour alors qu'encore "hier" en Montréal Québec.

ZoneId z = ZoneId.of( “America/Montreal” );
LocalDate today = LocalDate.now( z );
int dayOfYear = today.getDayOfYear ();

aller dans l'autre direction, d'un numéro à un rendez-vous.

LocalDate ld = Year.of( 2017 ).atDay( 159 ) ;

java.temps

java.temps framework est intégré à Java 8 et plus tard. Ces classes supplantent le vieux gênant!--66-->héritage classes de date-heure telles que java.util.Date,Calendar,&SimpleDateFormat.

le Joda-Time projet, maintenant dans mode de maintenance, conseille la migration vers le java.temps classes.

Pour en savoir plus, consultez le Tutorial Oracle. Et rechercher le débordement de la pile pour de nombreux exemples et explications. Spécification JSR 310.

Vous pouvez échanger java.temps objets directement avec votre base de données. Utiliser un JDBC driver compatible avec JDBC 4.2 ou plus tard. Pas besoin de chaînes, pas besoin de java.sql.* classes.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, Java SE 10, et plus tard
  • Built-in.
  • fait partie de L'API Java standard avec une implémentation groupée.
  • Java 9 ajoute quelques fonctionnalités mineures et corrections.
• Java SE 6 et Java SE 7
  • Beaucoup de java.la fonctionnalité time est rétroportée à Java 6 & 7 en ThreeTen-Backport.
• Android
  • versions ultérieures des implémentations du bundle Android de la java.les classes de temps.
  • Pour plus tôt Android (<26 ans), le ThreeTenABP le projet s'adapte ThreeTen-Backport (mentionné ci-dessus). Voir comment utiliser ThreeTenABP....

ThreeTen-Extra le projet étend java.temps avec des cours supplémentaires. Ce projet est un terrain d'essai pour de futurs possibles ajouts à java.temps. Vous pouvez trouver quelques classes utiles ici Interval,YearWeek,YearQuarter et plus.