Giorno giuliano dell'anno a Giava

StackOverflow https://stackoverflow.com/questions/3005577

  •  25-09-2019
  •  | 
  •  

Domanda

Ho visto la "soluzione" su http://www.rgagnon.com/javadetails/java-0506.html, ma non funziona correttamente.Per esempio.ieri (8 giugno) avrebbero dovuto essere 159, ma diceva che erano 245.

Quindi, qualcuno ha una soluzione in Java per ottenere il giorno giuliano a tre cifre della data corrente (non la data giuliana: mi serve il giorno quest'anno)?

Grazie!Segno

È stato utile?

Soluzione

Se tutto quello che volete è l'anno del giorno della, perché don'you basta usare GregorianCalendars campo DAY_OF_YEAR? 

import java.util.GregorianCalendar;
public class CalTest {
    public static void main(String[] argv) {
        GregorianCalendar gc = new GregorianCalendar();
        gc.set(GregorianCalendar.DAY_OF_MONTH, 8);
        gc.set(GregorianCalendar.MONTH, GregorianCalendar.JUNE);
        gc.set(GregorianCalendar.YEAR, 2010);
        System.out.println(gc.get(GregorianCalendar.DAY_OF_YEAR));
}

}

In alternativa, si potrebbe calcolare la differenza tra la data di Julian di oggi e quella di 1 gennaio di quest'anno. Ma essere sicuri di aggiungere 1 al risultato, dal momento che 1 gennaio non è il giorno zero della dell'anno: 

int[] now = {2010, 6, 8};
int[] janFirst = {2010, 1, 1};
double dayOfYear = toJulian(now) - toJulian(janFirst) + 1
System.out.println(Double.valueOf(dayOfYear).intValue());

Altri suggerimenti

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

Si noti che questo non tiene conto del "inizia a mezzogiorno" affare rivendicato da quel sito strano si fa riferimento. Che potrebbe essere risolto semplicemente controllando il tempo, naturalmente.

se otteniamo un doppio appuntamento julian come direttore decisione Chordiant

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

Di seguito è funzionante ma secondo non è preso cura di Come posso convertire tra una Data di Java e Julian numero del giorno?

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;

}

Ho letto tutti i post e credo che qualcosa non sia molto chiaro.

user912567 ha menzionato Jean Meeus e ha assolutamente ragione

La definizione più accurata che ho trovato è quella data da Jean Meeus nel suo libro "Astronomical Algorithms" (da avere assolutamente...).

Julian Date è un data, espresso come al solito, con un anno, un mese e un giorno.

Julian Day è un numero (un numero reale), contato dall'anno -4712 ed è "...un conteggio continuo di giorni..." (e frazione di giorno).UN utile scala temporale utilizzata per calcoli astronomici accurati.

Jean Meeus:"Il giorno giuliano non ha nulla a che vedere con il calendario giuliano" ("Algoritmi astronomici", 2a edizione, p.59)

tl; dott

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

Terminologia del “giorno giuliano”.

Il termine “giorno giuliano” è talvolta usato in modo approssimativo per indicare il ordinale giorno dell'anno, o Data ordinale, ovvero un numero da 1 a 365 o 366 (anni bisestili).Il 1 gennaio lo è 1, il 2 gennaio è 2, il 31 dicembre è 365 (O 366 negli anni bisestili).

Questo uso approssimativo (errato) di Julian probabilmente deriva da uso in astronomia e altri campi di monitoraggio delle date come conteggio continuo di giorni a partire da mezzogiorno del Tempo Universale del 1° gennaio 4713 a.C. (sul Calendario giuliano).Oggi la data giuliana si avvicina ai due milioni e mezzo, 2,457,576 Oggi.

java.time

Il framework java.time integrato in Java 8 e versioni successive fornisce una struttura semplice per ottenere il giorno dell'anno.

IL LocalDate La classe rappresenta un valore di sola data senza ora del giorno e senza fuso orario.Puoi interrogare per il giorno dell'anno.

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

Scarica sulla console.I risultati mostrano che l’8 giugno 2010 è effettivamente il giorno n. 159.

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

datalocale:2010-06-08 | dayofyear:159

Il fuso orario è fondamentale per determinare una data.In ogni dato momento, la data varia in tutto il mondo in base alla zona.Ad esempio, pochi minuti dopo la mezzanotte a Parigi la Francia è un nuovo giorno mentre è ancora “ieri” a Montréal Québec.

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

Andando nella direzione opposta, da un numero a una data.

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

Di java.time

IL java.time framework è integrato in Java 8 e versioni successive.Queste classi soppiantano quelle vecchie e fastidiose eredità classi data-ora come java.util.Date, Calendar, & SimpleDateFormat.

IL Joda-Time progetto, ora in Modalità di manutenzione, consiglia la migrazione al java.time classi.

Per saperne di più, vedere il Tutorial sull'Oracolo.E cerca Stack Overflow per molti esempi e spiegazioni.La specifica è JSR310.

Puoi scambiare java.time oggetti direttamente con il tuo database.Usare un driver JDBC conforme a JDBC4.2 o più tardi.Non c'è bisogno di stringhe, non c'è bisogno di java.sql.* classi.

Dove ottenere le classi java.time?

  • JavaSE8, JavaSE9, JavaSE10, e più tardi
    • Integrato.
    • Parte dell'API Java standard con un'implementazione in bundle.
    • Java 9 aggiunge alcune funzionalità e correzioni minori.
  • JavaSE6 E JavaSE7
    • Gran parte della funzionalità java.time è retroportata su Java 6 e 7 in ThreeTen-Backport.
  • Androide
    • Versioni successive delle implementazioni dei bundle Android delle classi java.time.
    • Per Android precedenti (<26), il file TredieciABP il progetto si adatta ThreeTen-Backport (menzionato sopra).Vedere Come utilizzare ThreeTenABP....

IL Tredieci-Extra il progetto estende java.time con classi aggiuntive.Questo progetto è un banco di prova per possibili future aggiunte a java.time.Potresti trovare alcune classi utili qui come Interval, YearWeek, YearQuarter, E Di più.

È anche possibile ottenere il "Julian Data" o "Data ordinale" in questo modo: 

import java.util.Calendar;
import java.util.Date;

public class MyClass {

  public static void main(String[] args) {
    Calendar cal = Calendar.getInstance();
    LocalDate myObj = LocalDate.now();
    System.out.println(myObj);
    System.out.println("Julian Date:" + cal.get(Calendar.DAY_OF_YEAR));

  }
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top