Te traemos la respuesta a esta problema, al menos eso pensamos. Si continuas con alguna duda puedes dejarlo en el apartado de comentarios y con placer te ayudaremos
Solución:
No, Java no tiene esa capacidad.
Tiene System.nanoTime(), pero eso solo da una compensación de un tiempo previamente conocido. Entonces, aunque no puede tomar el número absoluto de esto, puede usarlo para medir una precisión de nanosegundos (o superior).
Tenga en cuenta que JavaDoc dice que si bien esto proporciona una precisión de nanosegundos, eso no significa una precisión de nanosegundos. Así que tome un módulo adecuadamente grande del valor de retorno.
tl; dr
Java 9 y posterior: resolución de hasta nanosegundos al capturar el momento actual. Eso es 9 dígitos de fracción decimal.
Instant.now()
2017-12-23T12:34:56.123456789Z
Para limitar a microsegundos, truncar.
Instant // Represent a moment in UTC.
.now() // Capture the current moment. Returns a `Instant` object.
.truncatedTo( // Lop off the finer part of this moment.
ChronoUnit.MICROS // Granularity to which we are truncating.
) // Returns another `Instant` object rather than changing the original, per the immutable objects pattern.
2017-12-23T12:34:56.123456Z
En la práctica, verá solo microsegundos capturados con .now ya que los relojes de hardware de computadora convencionales contemporáneos no tienen una precisión de nanosegundos.
Detalles
Las otras respuestas están algo desactualizadas a partir de Java 8.
java.tiempo
Java 8 y versiones posteriores vienen con el marco java.time. Estas nuevas clases sustituyen a las problemáticas clases de fecha y hora defectuosas que se incluyeron en las primeras versiones de Java, como java.util.Date/.Calendar y java.text.SimpleDateFormat. El marco está definido por JSR 310, inspirado en Joda-Time, ampliado por el proyecto ThreeTen-Extra.
Las clases en java.time se resuelven en nanosegundos, mucho más finos que los milisegundos que usaban las antiguas clases de fecha y hora y Joda-Time. Y más fino que los microsegundos solicitados en la Pregunta.
Clock Implementación
Si bien las clases java.time admiten datos que representan valores en nanosegundos, las clases aún no generar valores en nanosegundos. los now() Los métodos utilizan la misma implementación de reloj anterior que las clases de fecha y hora anteriores, System.currentTimeMillis(). tenemos lo nuevo Clock interfaz en java.time pero la implementación para esa interfaz es el mismo viejo reloj de milisegundos.
Por lo que podría dar formato a la representación textual del resultado de ZonedDateTime.now( ZoneId.of( "America/Montreal" ) ) para ver nueve dígitos de una fracción de segundo, pero solo los primeros tres dígitos tendrán números como este:
2017-12-23T12:34:56.789000000Z
Nuevo reloj en Java 9
Las implementaciones OpenJDK y Oracle de Java 9 tienen un nuevo valor predeterminado Clock implementación con granularidad más fina, hasta la capacidad completa de nanosegundos de las clases java.time.
Consulte el problema de OpenJDK, Aumente la precisión de la implementación de java.time.Clock.systemUTC(). Ese problema se ha implementado con éxito.
2017-12-23T12:34:56.123456789Z
En una MacBook Pro (Retina, 15 pulgadas, finales de 2013) con macOS Sierra, obtengo el momento actual en microsegundos (hasta seis dígitos de fracción decimal).
2017-12-23T12:34:56.123456Z
Reloj de hardware
Recuerde que incluso con un nuevo más fino Clock implementación, sus resultados pueden variar según la computadora. Java depende del reloj del hardware de la computadora subyacente para conocer el momento actual.
- los resolución de los relojes de hardware varían ampliamente. Por ejemplo, si el reloj de hardware de una computadora en particular solo admite granularidad de microsegundos, los valores de fecha y hora generados tendrán solo seis dígitos de fracciones de segundo y los últimos tres dígitos serán ceros.
- los exactitud de los relojes de hardware varían ampliamente. Solo porque un reloj genera un valor con varios dígitos de fracción decimal de segundo, esos dígitos pueden ser inexactos, solo aproximaciones, a la deriva del tiempo real, como podría leerse en un reloj atómico. En otras palabras, el hecho de que vea un montón de dígitos a la derecha de la marca decimal no significa que pueda confiar en que el tiempo transcurrido entre dichas lecturas sea true en ese grado diminuto.
Puedes usar System.nanoTime():
long start = System.nanoTime();
// do stuff
long end = System.nanoTime();
long microseconds = (end - start) / 1000;
para obtener el tiempo en nanosegundos pero es una medida estrictamente relativa. No tiene un significado absoluto. Solo es útil para comparar con otros nanotiempos para medir cuánto tiempo se tardó en hacer algo.