char_x <(char_y + 1) == char_x <= char_y?

Question

हाय सब मैं जावा स्रोत कोड के कुछ के माध्यम से ब्राउज़िंग गया था जब मैं इस में आए (java.lang.Character):

public static boolean isHighSurrogate(char ch) { 
    return ch >= MIN_HIGH_SURROGATE && ch < (MAX_HIGH_SURROGATE + 1); 
} 

public static boolean isLowSurrogate(char ch) { 
    return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1); 
} 

मैं सोच रहा था क्यों किया था लेखक उच्च सीमा को 1 जोड़ा गया है और कर रही एक तुलना कम से , बस कम से कम या बराबर तुलना करने की बजाय?

मैं समझ सकता हूं कि क्या यह पठनीयता में मदद करता है, लेकिन इस मामले में ऐसा लगता है कि ऐसा नहीं लगता है।

मैं सोच रहा था क्या इसके बाद के संस्करण कोड और इस बीच क्या अंतर है:

public static boolean isHighSurrogate(char ch) { 
    return ch >= MIN_HIGH_SURROGATE && ch <= MAX_HIGH_SURROGATE; 
} 

public static boolean isLowSurrogate(char ch) { 
    return ch >= MIN_LOW_SURROGATE && ch <= MAX_LOW_SURROGATE; 
} 

Answer 1

शायद लेखक सभी आधा खुला पर्वतमाला बनाने के लिए Dijkstra's advice के अनुरूप होना करने के लिए कोशिश कर रहा है - प्रारंभ बिंदु समावेशी है और एंडपॉइंट अनन्य है।

यहां कोई अर्थ अंतर है, लेकिन बाईटकोड में एक सूक्ष्म अंतर है: (ch + 1) एक int तो पहले कोड स्निपेट एक charchar की तुलना जबकि दूसरा दो charchar की तुलना करता है एक intint की तुलना द्वारा पीछा करता है। इससे कोई अर्थपूर्ण अंतर नहीं होता है - निहित कास्ट व्यापक प्रकार के होते हैं और इसलिए कोड स्निपेट में अतिप्रवाह का कोई जोखिम नहीं होता है।

बाहर इसके JIT द्वारा किया अनुकूलन के प्रकार के दायरे के भीतर अच्छी तरह से अनुकूलन और intint की तुलना एक 2 बाइट अहस्ताक्षरित int तुलना में वापस परिवर्तित तो मैं एक को पसंद करते हैं किसी विशेष प्रदर्शन कारण नहीं दिख रहा है दूसरे पर

मैं के रूप में

MIN_LOW_SURROGATE <= ch && ch <= MAX_LOW_SURROGATE 

बात इस तरह का लिखने के लिए करते हैं कि जिस तरह से बीच में ch यह एक पाठक है कि ch बाहरी मूल्यों की सीमा के भीतर परीक्षण किया जा रहा है के लिए स्पष्ट कर देता है।

Answer 2

मैं कहूंगा कि कोडिंग के दो तरीकों के बीच वास्तव में कोई अंतर नहीं है, यह केवल स्वाद का मामला है जो आप पसंद करेंगे, क्योंकि आपके पास वास्तव में दो अलग-अलग कार्यान्वयनों में से कोई एक लाभ नहीं है।

मैं सोच रहा था कि लेखक ने उच्च सीमा तक 1 क्यों जोड़ा और कम से कम या बराबर तुलना करने की बजाय तुलना करने से कम से कम किया?

मेरा मतलब है, आप दूसरी पसंद क्यों पसंद करेंगे? क्या मुझे यहाँ कुछ याद आती है?

Answer 3

क्योंकि लेखक एक सी ++ या एक असेंबलर लड़का था।

यह>> से>> बनाने के लिए तेज़ है और यह < = < से तेज़ है। असल में, जब आप < बी लिखते हैं तो संकलक < = बी + 1 बनाता है, इसलिए यह एक अतिरिक्त और तुलना करता है, क्योंकि केवल उपलब्ध असेंबली निर्देश < = करता है। यदि आप हाथ में कोड में उस योग को लिखते हैं, तो एक सी ++ कंपाइलर संकलन समय पर परिणाम के वास्तविक मूल्य के साथ MIN_HIGH_SURROGATE + 1 बदल देगा। तो आप एक निर्देश, और एक चक्र प्राप्त करते हैं।

लेकिन यह सब अजीब तर्क केवल संकलित कोड के लिए आवेदन कर रहा है, जैसे सी ++ या सी या एएसएम।

संपादित

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

यह सुनिश्चित करने के लिए कि 1 जोड़ते समय कोई ओवरफ़्लो नहीं है, माइक्रोप्रोसेसर पहले घटाता है, फिर एक जोड़ता है।

Answer 4

जंगली अनुमान

सरोगेट चरित्र, यूनिकोड कोड पॉइंट्स जो बेसिक बहुभाषी विमान परे केरेक्टर को अभिव्यक्त करने UTF-16 में जोड़े में उपयोग किया जाता है की एक श्रृंखला के किसी भी।

मेरे दृष्टिकोण में वह 8 बिट सामानों को अनदेखा करना चाहता था, जिसका अर्थ है कि अधिकतम 0xFF था। 0xFF + 1 बह जाएगा और 0x00 पर वापस जायेगा। तुलना हमेशा झूठी बनाते हैं।

तो यदि कोड 8 बिट्स के वर्णों के साथ संकलित किया गया था। यह हमेशा झूठी (यूटीएफ -16 रेंज के बाहर) लौटाएगा, जबकि अगर यह एक छत को संकलित करता है> 8 बिट्स 0xFF + 1 0x100 होगा और अभी भी काम करेगा।

उम्मीद है कि यह आपके लिए कुछ बाधा बनाता है।