Remarque, je ne veux pas millis de Epoch. Je veux le nombre de millisecondes actuellement sur l'horloge.
Donc, par exemple, j'ai ce morceau de code.
Date date2 = new Date();
Long time2 = (long) (((((date2.getHours() * 60) + date2.getMinutes())* 60 ) + date2.getSeconds()) * 1000);
Y a-t-il un moyen d'obtenir des millisecondes avec la date? Y a-t-il un autre moyen de faire cela?
Note: System.currentTimeMillis()
me donne des millis d'Epoch, ce qui n'est pas ce que je recherche.
Tu veux dire?
long millis = System.currentTimeMillis() % 1000;
BTW Windows ne permet pas de voyager dans le temps jusqu'en 1969
C:\> date
Enter the new date: (dd-mm-yy) 2/8/1969
The system cannot accept the date entered.
Utiliser le calendrier
Calendar.getInstance().get(Calendar.MILLISECOND);
ou
Calendar c=Calendar.getInstance();
c.setTime(new Date()); /* whatever*/
//c.setTimeZone(...); if necessary
c.get(Calendar.MILLISECOND);
En pratique, je pense que cela sera presque toujours égal à System.currentTimeMillis ()% 1000; sauf si quelqu'un a des sauts millisecondes ou si un calendrier est défini avec une époque qui n'est pas sur une seconde limite.
Calendar.getInstance().get(Calendar.MILLISECOND);
J'ai essayé quelques-uns ci-dessus, mais ils semblent réinitialiser @ 1000
Celui-ci fonctionne vraiment, et devrait également prendre en considération l'année
long millisStart = Calendar.getInstance().getTimeInMillis();
et faites de même pour l'heure de fin si nécessaire.
Vous demandez la fraction de seconde de l'heure actuelle sous forme de millisecondes (pas compte depuis Epoch).
Instant.now() // Get current moment in UTC, then…
.get( ChronoField.MILLI_OF_SECOND ) // interrogate a `TemporalField`.
2017-04-25T03: 01: 14.113Z →
113
Voir ceci code exécuté en direct sur IdeOne.com .
La manière moderne est avec les classes Java.time.
Capturez le moment actuel en UTC.
Instant.now()
Utilisez la méthode Instant.get
pour interroger la valeur d'un TemporalField
. Dans notre cas, la TemporalField
que nous voulons est ChronoField.MILLI_OF_SECOND
.
int millis = Instant.now().get( ChronoField.MILLI_OF_SECOND ) ; // Get current moment in UTC, then interrogate a `TemporalField`.
Ou faites le calcul vous-même.
Plus probablement, vous demandez ceci pour un fuseau horaire spécifique. La fraction de seconde est probablement identique à celle de Instant
mais il y a tellement d'anomalies avec les fuseaux horaires, j'hésite à faire cette hypothèse.
ZonedDateTime zdt = ZonedDateTime.now( ZoneId.of( "America/Montreal" ) ) ;
Interrogez la fraction de seconde. La question demandait millisecondes , mais les classes Java.time utilisent une résolution plus fine de nanosecondes . Cela signifie que le nombre de nanosecondes sera compris entre 0 et 999 999 999.
long nanosFractionOfSecond = zdt.getNano();
Si vous voulez vraiment en millisecondes, tronquez les données plus fines en divisant par un million. Par exemple, une demi-seconde correspond à 500 000 000 nanosecondes et à 500 millisecondes.
long millis = ( nanosFractionOfSecond / 1_000_000L ) ; // Truncate nanoseconds to milliseconds, by a factor of one million.
Le cadre Java.time est intégré à Java 8 et versions ultérieures. Ces classes supplantent les anciennes classes gênantes héritées _ date-heure telles que Java.util.Date
, Calendar
_, & SimpleDateFormat
.
Le projet Joda-Time , désormais en mode maintenance , conseille de migrer vers les classes Java.time .
Pour en savoir plus, consultez le Tutoriel Oracle . Et recherchez Stack Overflow pour de nombreux exemples et explications. La spécification est JSR 310 .
Où obtenir les classes Java.time?
Le projet ThreeTen-Extra étend Java.time avec des classes supplémentaires. Ce projet est un terrain d'essai pour d'éventuels ajouts à Java.time. Vous pouvez y trouver des classes utiles telles que Interval
_, YearWeek
, YearQuarter
_ et plus _.
Je pense que vous pouvez utiliser Joda-Time pour le faire. Jetez un coup d’œil à la classe DateTime
et à sa méthode getMillisOfSecond
. Quelque chose comme
int ms = new DateTime().getMillisOfSecond() ;
En Java 8, vous pouvez simplement faire
ZonedDateTime.now().toInstant().toEpochMilli()
résultats : le nombre de millisecondes depuis l'époque du 1970-01-01T00: 00: 00Z
J'ai fait le test en utilisant Java 8L'importance de l'ordre du constructeur prend toujours 0 millisecondes et le concat entre 26 et 33 millisecondes sous et l'itération d'une concaténation de 1000
J'espère que ça aide d'essayer avec votre idée
public void count() {
String result = "";
StringBuilder builder = new StringBuilder();
long millis1 = System.currentTimeMillis(),
millis2;
for (int i = 0; i < 1000; i++) {
builder.append("hello world this is the concat vs builder test enjoy");
}
millis2 = System.currentTimeMillis();
System.out.println("Diff: " + (millis2 - millis1));
millis1 = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
result += "hello world this is the concat vs builder test enjoy";
}
millis2 = System.currentTimeMillis();
System.out.println("Diff: " + (millis2 - millis1));
}