हमें जावा में शिफ्ट ऑपरेटर का उपयोग करने की आवश्यकता क्यों है?

Question

1. विभाजन और गुणा का उपयोग करने के बजाय शिफ्ट ऑपरेटरों का उपयोग करने का उद्देश्य क्या है?

2. क्या शिफ्ट ऑपरेटरों का उपयोग करने के कोई अन्य लाभ हैं?

3. किसी को शिफ्ट ऑपरेटर का उपयोग करने का प्रयास क्यों करना चाहिए?

Answer 1

डिवीजन और गुणा वास्तव में बिट पारी ऑपरेटरों का एक प्रयोग नहीं कर रहे हैं। वे कुछ पुराने 'अनुकूलन' हैं जो कुछ लागू करना चाहते हैं।

वे बिट ऑपरेशंस हैं, और पूर्णांक के भीतर बिट्स के स्तर पर काम करते समय पूरी तरह से जरूरी हैं।

उदाहरण के लिए, मेरे पास दो बाइट्स हैं जो दो-बाइट (16-बिट) हस्ताक्षरित मान के उच्च-आदेश और निम्न-क्रम बाइट हैं। मान लें कि आपको उस मूल्य को बनाने की जरूरत है। जावा में, यह है:

int high = ...; 
int low = ...; 
int twoByteValue = (high << 8) | low; 

आप अन्यथा शिफ्ट ऑपरेटर के बिना ऐसा नहीं कर सके।

अपने प्रश्नों के उत्तर देने के लिए: आप उनका उपयोग करें जहां आपको उनका उपयोग करने की आवश्यकता है! और कहीं और नहीं। के रूप में गणितीय संचालन करने का विरोध किया

Answer 2

पारी ऑपरेटर, जब आप तार्किक बिट्स संचालन प्रदर्शन कर रहे हैं प्रयोग किया जाता है।

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

Answer 3

यह भी एन्क्रिप्शन/डिक्रिप्शन में इस्तेमाल हो सकता है .. उदाहरण: http://freedom2blog.com/2010/05/easy-encryption-using-bitwise-exclusive-or-xor/

Answer 4

यह मान जो संख्या है, जहां बिट्स विभिन्न मूल्यों के रूप में वर्गीकृत किया है खुद को का एक संयोजन कर रहे हैं के निर्माण में उपयोगी है। (शॉन ओवेन का जवाब इस बेहतर बताते हैं।)

उदाहरण के लिए, रंग है जो कर रहे हैं के साथ काम:

• एक base16 स्ट्रिंग
• 0xAAAARRRRGGGGBBBB एक पूर्णांक

अपने पूर्णांक प्रारूप में के रूप में के रूप में "#AARRGGBB" , आप एक उपयोग योग्य संख्या के रूप में पूर्णांक के घटक के वास्तविक मान प्राप्त करने के लिए शिफ्ट का उपयोग कर सकते हैं।

public static int stringToColor(String s) throws JSExn { 
    // string starts with '#' - parse integer from string 
    try { 
     // used to build up the return value 
     int a, r, g, b; 

     switch (s.length()) { 
     case 4: 
      a = 0xFF000000; 
      r = Integer.parseInt(s.substring(1, 2), 16); 
      r = r << 16 | r << 20; 
      b = Integer.parseInt(s.substring(2, 3), 16); 
      b = b << 8 | b << 12; 
      g = Integer.parseInt(s.substring(3, 4), 16); 
      g = g | g << 4; 
      break; 
     case 5: 
      a = Integer.parseInt(s.substring(1, 2), 16); 
      a = a << 24 | a << 28; 
      r = Integer.parseInt(s.substring(2, 3), 16); 
      r = r << 16 | r << 20; 
      b = Integer.parseInt(s.substring(3, 4), 16); 
      b = b << 8 | b << 12; 
      g = Integer.parseInt(s.substring(4, 5), 16); 
      g = g | g << 4; 
      break; 
     case 7: 
      a = 0xFF000000; 
      r = Integer.parseInt(s.substring(1, 3), 16) << 16; 
      b = Integer.parseInt(s.substring(3, 5), 16) << 8; 
      g = Integer.parseInt(s.substring(5, 7), 16); 
      break; 
     case 9: 
      a = Integer.parseInt(s.substring(1, 3), 16) << 24; 
      r = Integer.parseInt(s.substring(3, 5), 16) << 16; 
      b = Integer.parseInt(s.substring(5, 7), 16) << 8; 
      g = Integer.parseInt(s.substring(7, 9), 16); 
      break; 
     default: 
      throw new JSExn("Not a valid color: '"+s+"'"); 
     } 

     // return our integer ARGB 
     return a | r | b | g; 
} 

Answer 5

शक्ति में कमी तब होती है जब एक ऑपरेशन को एक समान ऑपरेशन द्वारा प्रतिस्थापित किया जाता है जो तेजी से निष्पादित होता है।

1. अंकगणितीय पारी या तार्किक शिफ्ट के साथ 2 के एक शक्ति से पूर्णांक विभाजन या गुणा की जगह ..
2. बदलाव के संयोजन के साथ एक निरंतर द्वारा पूर्णांक गुणन की जगह, कहते हैं या घटाता है।
3. एक पूर्णांक के साथ एक पूर्णांक द्वारा पूर्णांक विभाजन को प्रतिस्थापित करना, मशीन पूर्णांक की सीमित सीमा का लाभ लेना।

यह गलत क्यों है?

1. गणना बढ़ने के लिए आवश्यक समय के रूप में प्रदर्शन को कम करता है। 2. विभाजन और गुणा जैसे अंकगणितीय संचालन धीमे हैं। 3. महंगी संचालन

लाभ

1. प्रदर्शन में सुधार करता है।
2. तेज़ गणना।

डेमेरिट

1. संहिता की पठनीयता कम हो जाती है।

Answer 6

यह है जब आप झंडे के साथ सौदा उपयोगी है, तो आप सिर्फ एक int चर में सक्रिय झंडे के बारे में जानकारी स्टोर कर सकता है, कृपया इसे देखें:

public class DealingWithShiftOperators { 

    public static void main(String[] args) { 

     int active_flags = 10; 

     printActiveFlags(active_flags); 

    } 

    public static void printActiveFlags(int active_flags) { 

     final int TOTAL_FLAGS = 8; 
     final int MAX_VALUE = 1 << TOTAL_FLAGS; 
     final int MIN_VALUE = 1; 

     int current_flag = MAX_VALUE; 

     do { 
      current_flag = current_flag >> 1; 

      if (active_flags - current_flag < 0) { 
       System.out.println(current_flag + ": off"); 
      } else { 
       active_flags = active_flags - current_flag; 
       System.out.println(current_flag + ": on"); 
      } 

     } while (current_flag > MIN_VALUE); 

    } 

} 

ऊपर के उदाहरण उत्पादन के लिए अनुवर्ती प्रिंट:

128: off 
64: off 
32: off 
16: off 
8: on 
4: off 
2: on 
1: off 

आप देख सकते हैं, active_flags नंबर 2 और नंबर 8. हम सिर्फ एक चर में उस जानकारी को संग्रहीत, अपने मूल्य 10 (8 + 2) है।