java - System.currentTimeMillis()बनाम नई तिथि()बनाम कैलेंडर.getInstance()। GetTime()




performance date calendar (8)

System.currentTimeMillis() स्पष्ट रूप से सबसे कुशल है क्योंकि यह ऑब्जेक्ट भी नहीं बनाता है, लेकिन new Date() वास्तव में केवल एक पतली आवरण है जो लंबे समय तक है, इसलिए यह बहुत पीछे नहीं है। दूसरी तरफ, Calendar अपेक्षाकृत धीमी और जटिल है, क्योंकि इसे काफी जटिलता और तारीखों और समय (लीप साल, डेलाइट बचत, टाइमज़ोन इत्यादि) के सभी अंतर्निहितताओं से निपटना है।

आम तौर पर आपके आवेदन के भीतर लंबी टाइमस्टैम्प या Date ऑब्जेक्ट्स के साथ सौदा करने का एक अच्छा विचार है, और केवल Calendar उपयोग करें जब आपको वास्तव में दिनांक / समय की गणना करने की आवश्यकता होती है, या उपयोगकर्ता को प्रदर्शित करने के लिए तिथियां प्रारूपित करने की आवश्यकता होती है। यदि आपको बहुत कुछ करना है, तो क्लीनर इंटरफ़ेस और बेहतर प्रदर्शन के लिए, जोडा टाइम का उपयोग करना शायद एक अच्छा विचार है।

जावा में, उपयोग करने के प्रदर्शन और संसाधन प्रभाव क्या हैं

System.currentTimeMillis() 

बनाम

new Date() 

बनाम

Calendar.getInstance().getTime()

जैसा कि मैं इसे समझता हूं, System.currentTimeMillis () सबसे कुशल है। हालांकि, अधिकांश अनुप्रयोगों में, उस लंबे मूल्य को मनुष्यों के लिए सार्थक कुछ भी करने के लिए दिनांक या कुछ समान वस्तु में परिवर्तित करने की आवश्यकता होगी।


मेरी मशीन पर मैंने इसे जांचने की कोशिश की। मेरा परिणाम:

Calendar.getInstance().getTime() (*1000000 times) = 402ms
new Date().getTime(); (*1000000 times) = 18ms
System.currentTimeMillis() (*1000000 times) = 16ms

जीसी के बारे में मत भूलना (यदि आप Calendar.getInstance() या new Date() )


आपके आवेदन के आधार पर, आप इसके बजाय System.nanoTime() का उपयोग करने पर विचार करना चाहेंगे।


जेडीके को देखते हुए, Calendar.getInstance() getInstance Calendar.getInstance() लिए सबसे कम कन्स्ट्रक्टर यह है:

public GregorianCalendar(TimeZone zone, Locale aLocale) {
    super(zone, aLocale);
    gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone);
    setTimeInMillis(System.currentTimeMillis());
}

इसलिए यह आपके द्वारा सुझाए गए कार्यों को स्वचालित रूप से करता है। तिथि का डिफ़ॉल्ट कन्स्ट्रक्टर यह रखता है:

public Date() {
    this(System.currentTimeMillis());
}

इसलिए वास्तव में सिस्टम समय प्राप्त करने की आवश्यकता नहीं है जबतक कि आप इसके साथ अपना कैलेंडर / डेट ऑब्जेक्ट बनाने से पहले कुछ गणित करना नहीं चाहते हैं। इसके अलावा मुझे जावा के अपने कैलेंडर / डेट क्लास के प्रतिस्थापन के रूप में उपयोग करने के लिए जोडा-टाइम की सिफारिश करनी होगी यदि आपका उद्देश्य डेट गणनाओं के साथ काम करना है।


मैंने कोशिश की:

        long now = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            new Date().getTime();
        }
        long result = System.currentTimeMillis() - now;

        System.out.println("Date(): " + result);

        now = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            System.currentTimeMillis();
        }
        result = System.currentTimeMillis() - now;

        System.out.println("currentTimeMillis(): " + result);

और परिणाम था:

तिथि (): 199

वर्तमान टाइममिलिस (): 3


System.currentTimeMillis() स्पष्ट रूप से सबसे तेज़ है क्योंकि यह केवल एक विधि कॉल है और कोई कचरा कलेक्टर की आवश्यकता नहीं है।


मैं सभी प्रकार की गणनाओं के लिए System.currentTimeMillis() द्वारा लौटाए गए मान का उपयोग करना पसंद करता हूं और केवल Calendar या Date उपयोग करता हूं यदि मुझे वास्तव में मनुष्यों द्वारा पढ़ा जाने वाला मान प्रदर्शित करने की आवश्यकता है। यह आपके डेलाइट-सेविंग-टाइम बग का 99% भी रोक देगा। :)


Just for the record, another approach is to use the prime decomposition. If every factor of the decomposition is even, then the number is a perfect square. So what you want is to see if a number can be decomposed as a product of squares of prime numbers. Of course, you don't need to obtain such a decomposition, just to see if it exists.

First build a table of squares of prime numbers which are lower than 2^32. This is far smaller than a table of all integers up to this limit.

A solution would then be like this:

boolean isPerfectSquare(long number)
{
    if (number < 0) return false;
    if (number < 2) return true;

    for (int i = 0; ; i++)
    {
        long square = squareTable[i];
        if (square > number) return false;
        while (number % square == 0)
        {
            number /= square;
        }
        if (number == 1) return true;
    }
}

I guess it's a bit cryptic. What it does is checking in every step that the square of a prime number divide the input number. If it does then it divides the number by the square as long as it is possible, to remove this square from the prime decomposition. If by this process, we came to 1, then the input number was a decomposition of square of prime numbers. If the square becomes larger than the number itself, then there is no way this square, or any larger squares, can divide it, so the number can not be a decomposition of squares of prime numbers.

Given nowadays' sqrt done in hardware and the need to compute prime numbers here, I guess this solution is way slower. But it should give better results than solution with sqrt which won't work over 2^54, as says mrzl in his answer.





java performance date time calendar