TimeUnit Enum का उपयोग करके नैनोसेकंड को सेकंड में कैसे बदलें?

Question

नैनोसेकंड से सेकंड में मान कैसे बदलें?

यहाँ कोड सेगमेंट है:

import java.io.*;
import java.util.concurrent.*; 
..

class Stamper { 

public static void main (String[] args) { 
long start = System.nanoTime(); 
//some try with nested loops 
long end = System.nanoTime(); 
long elapsedTime = end - start;

System.out.println("elapsed: " + elapsedTime + "nano seconds\n");

//convert to seconds 
TimeUnit seconds = new TimeUnit(); 
System.out.println("which is " + seconds.toSeconds(elapsedTime) + " seconds"); 
}}

त्रुटि है

Stamper.java:16:  enum types may not be instantiated.

इसका क्या मतलब है?

Comments

त्रुटि का मतलब है कि आप प्रकार को तुरंत नहीं कर सकते TimeUtil, क्योंकि यह एक enum(एन्यूमरेटर) है। यदि आप उपयोग करना चाहते हैं TimeUnit, तो आपको TimeUnit.NANOSECONDS.toSeconds(elapsedTime)इसके बजाय उपयोग करना चाहिए । सौभाग्य!

— डैनियल केविस्ट

Answer 1

ठीक है, आप केवल 1,000,000,000 से भाग दे सकते हैं:

long elapsedTime = end - start;
double seconds = (double)elapsedTime / 1_000_000_000.0;

यदि आप TimeUnitकनवर्ट करने के लिए उपयोग करते हैं, तो आपको अपना परिणाम लंबे समय तक प्राप्त होगा, इसलिए आप दशमलव परिशुद्धता खो देंगे लेकिन पूरी संख्या परिशुद्धता बनाए रखेंगे।

Comments

लेकिन क्या होगा अगर एक दूसरे परिवर्तन में नैनोसेकंड की संख्या? : पी

— जियोफैटनज़

यह उत्तर अब गलत है - convert()और toFoo()विधियाँ longअब वापस आती

— राईकिंग करें

@ बारबार हालांकि यह जवाब अभी भी सही है कि TimeUnitसमाधान में विशिष्टता का नुकसान होता है। TimeUnit.SECONDS.convert(500, TimeUnit.MILLISECONDS);वापस आ जाएगा 0, नहीं 0.5। यह केवल आपके उपयोग-मामले पर निर्भर करता है कि इनमें से कौन सा बेहतर है।

— nbrooks

यहाँ @nbrooks के साथ पूरी तरह से सहमत हैं। TimeUnit का उपयोग करना दूसरे के अंशों को आउटपुट नहीं करेगा, बदले में 0. लौटाएगा। यदि आप हार्ड कोडित 10 अंकों की संख्या का उपयोग नहीं करना चाहते हैं तो 1E9 जैसी किसी चीज़ का उपयोग करें। उदाहरण के लिए: double seconds = ((double) nanoseconds) / 1E9; मैं इसे हर बार एक व्यक्तिगत प्राथमिकता के रूप में करूंगा।

— टेकट्रिप

यदि आप एक सेकंड के अंश चाहते हैं, तो टाइमअनिट इनम पद्धति पर इस विधि का उपयोग करें। TimeUnit Enum का उपयोग निकटतम सेकंड के लिए भी नहीं होता है, यह अनिवार्य रूप से बस एक सेकंड के अंशों को काट देता है। तो 4.9999999, बस 4. होगा

— डिक लुकास

Answer 2

TimeUnit enum

निम्नलिखित अभिव्यक्ति का उपयोग करता है TimeUnit एनमोस (जावा 5 और बाद में) का उपयोग नैनोसेकंड से सेकंड में परिवर्तित करने के लिए करती है:

TimeUnit.SECONDS.convert(elapsedTime, TimeUnit.NANOSECONDS)

Comments

ऐसा नहीं है कि इस पद्धति में एक सेकंड के अंश शामिल नहीं हैं। तो 4.9999999, बस 4 सेकंड का होगा।

— डिक लुकास

यह पसंद किया जाता है क्योंकि आपको कभी भी 1 नहीं लिखना चाहिए, इसके बाद 0 की एक पूरी गड़बड़ी के कारण यह बहुत त्रुटि वाला होता है।

— डिमॉन्गोलेम

आप इसे इस तरह से लिख सकते हैं elapsedTime = (end_time - start_time) / 1e9;

— हसोन सेप

अगर मैं ५ ९ मिनट और ५० सेकंड रहूं तो यह अभी भी कहती है ० एच बीता हुआ ... जो आदर्श नहीं है। तो क्या इस विधि को भिन्नों के साथ बनाने का कोई तरीका है?

— user1156544

Answer 3

TimeUnit एक एनम है, इसलिए आप एक नया नहीं बना सकते हैं।

निम्नलिखित 1000000000000ns सेकंड में परिवर्तित हो जाएगा।

TimeUnit.NANOSECONDS.toSeconds(1000000000000L);

Comments

मेरा मानना ​​है कि यह 10e + 9 नहीं 1e + 12 है!

— एडम एरोल्ड

यह एक बहुत देर से उत्तर है, लेकिन उदाहरण में संख्या एक सेकंड में नैनो की संख्या नहीं है, यह सिर्फ एक संख्या है जिसे परिवर्तित करना है। पूरा विचार उन मूल्यों को नहीं जानना है।

— निक वेय्स

मुझे लगता है कि यह स्वीकृत उत्तर होना चाहिए। Toxxx () का उपयोग करना कन्वर्ट () का उपयोग करने के लिए बेहतर है क्योंकि कन्वर्ट के साथ () यह स्पष्ट नहीं है कि रूपांतरण किस दिशा में होता है, जबकि toxx () के साथ यह है।

— क्लिटोस काइराकौ

Answer 4

वर्बोसिटी को कम करने के लिए, आप स्थैतिक आयात का उपयोग कर सकते हैं:

import static java.util.concurrent.TimeUnit.NANOSECONDS;

-और इसके बाद ही टाइप करें

NANOSECONDS.toSeconds(elapsedTime);

Answer 5

आपको लिखना चाहिए:

    long startTime = System.nanoTime();        
    long estimatedTime = System.nanoTime() - startTime;

एक चर में एंडटाइम को असाइन करने से कुछ नैनोसेकंड हो सकते हैं। इस दृष्टिकोण में आपको सटीक बीता हुआ समय मिलेगा।

और तब:

TimeUnit.SECONDS.convert(estimatedTime, TimeUnit.NANOSECONDS)

Answer 6

यह एक डबल प्रारूप में सेकंड में समय बदल देगा, जो पूर्णांक मान से अधिक सटीक है:

double elapsedTimeInSeconds = TimeUnit.MILLISECONDS.convert(elapsedTime, TimeUnit.NANOSECONDS) / 1000.0;

Answer 7

JDK9 + समाधान का उपयोग कर java.time.Duration

Duration.ofNanos(1_000_000L).toSeconds()

https://docs.oracle.com/javase/9/docs/api/java/time/Duration.html#ofNanos-long-

https://docs.oracle.com/javase/9/docs/api/java/time/Duration.html#toSeconds--