सरणी वर्ग, भाग 2

"ऋषि, मैं वास्तव में Arrays वर्ग की बाकी विधियों के बारे में जानने के लिए उत्सुक हूँ।

"सीखने का ऐसा उत्साह आपके पुराने शिक्षक को खुश किए बिना नहीं रह सकता! लेकिन, अगर आप वास्तव में सब कुछ पता लगाना चाहते हैं, तो Google नाम का एक दयालु जादूगर दिन-रात आपकी मदद करेगा।"

"उह..."

"बस मज़ाक कर रहा हूँ। बेशक, मैं सब कुछ बेहतर समझाऊंगा, लेकिन अगर कुछ भी आता है - अच्छे जादूगर को याद करो। मैं आज का पाठ विधि के साथ शुरू Arrays.fillकरूँगा

"सरणियों के साथ काम करते समय, जावा प्रोग्रामर को अक्सर समान मान के साथ सरणी भरने की आवश्यकता होती है। आप निश्चित रूप से एक लूप लिख सकते हैं और लूप में सरणी के प्रत्येक सेल को कुछ मान निर्दिष्ट कर सकते हैं:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"या इन सबके बजाय, आप Arrays.fill()विधि को कॉल कर सकते हैं, जो बिल्कुल वही काम करता है: यह पास किए गए सरणी को पास किए गए मान से भरता है। यहां बताया गया है कि यह कैसा दिखता है:

Arrays.fill(name, value)

और उपरोक्त उदाहरण में कोड को थोड़ा और अधिक कॉम्पैक्ट और स्पष्ट बनाया जा सकता है:

int[] x = new int[100];
Arrays.fill(x, 999);

"सुंदर!"

"आप Arrays.fill()पूरे सरणी को भरने के लिए विधि का उपयोग भी कर सकते हैं, लेकिन इसका एक हिस्सा, कुछ मूल्य के साथ:

Arrays.fill(name, first, last, value)

"जहां पहले और आखिरी में भरे जाने वाले पहले और आखिरी सेल के सूचकांक हैं।

" जावा की अच्छी (या बुरी) पुरानी परंपरा के अनुसार, याद रखें कि अंतिम तत्व श्रेणी में शामिल नहीं है।

उदाहरण:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

" Arrays.fill()विधि केवल एक-आयामी सरणी के साथ काम करती है। यदि आप विधि के लिए दो-आयामी सरणी पास करते हैं, तो इसे सभी आगामी परिणामों के साथ एक-आयामी माना जाएगा।

Arrays.copyOf()

"अमीगो, कृपया मुझे बताएं कि सरणी के बनने के बाद उसका आकार कैसे बदला जाए?"

"उम्म... यह एक पेचीदा सवाल है, ठीक है? मैं अब उतना अनुभवहीन नहीं हूं। सही उत्तर यह है कि आप नहीं कर सकते! आप किसी सरणी के बनने के बाद उसका आकार नहीं बदल सकते।"

"लेकिन क्या होगा यदि आप वास्तव में चाहते हैं?"

"यह अभी भी असंभव है!

"वास्तव में, यदि आप वास्तव में चाहते हैं, तो आप कर सकते हैं! एक प्रोग्रामिंग ट्रिक की मदद से:

1. सबसे पहले, आप वांछित लंबाई की एक नई सरणी बनाते हैं
2. फिर आप सभी तत्वों को पहले सरणी से कॉपी करते हैं।

"ये दो चीजें हैं जो Arrays.copyOf()विधि करती है। इसे कॉल करना ऐसा दिखता है:

Type[] name2 = Arrays.copyOf(name, length);

"यह विधि मौजूदा सरणी को नहीं बदलती है , बल्कि इसके बजाय एक नई सरणी बनाती है और पुराने सरणी के तत्वों को इसमें कॉपी करती है।"

"क्या होगा यदि नई सरणी की लंबाई मौजूदा की लंबाई से कम है ?

"महान प्रश्न, अमीगो! यदि तत्व फिट नहीं होते हैं, तो अतिरिक्त मूल्यों को आसानी से अनदेखा कर दिया जाता है।"

"और अगर, इसके विपरीत, अतिरिक्त कोशिकाएं हैं, तो उनके शुरुआती मूल्य क्या हैं?

"यदि नई सरणी की लंबाई पुराने की लंबाई से अधिक है, तो कोशिकाएं शून्य से भर जाती हैं।

उदाहरण:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"और क्या होगा यदि आप लंबाई 10 की सरणी से लंबाई 5 की सरणी प्राप्त करना चाहते हैं, लेकिन आपको पहले 5 के बजाय अंतिम 5 तत्वों को शामिल करने की आवश्यकता है? इस मामले में, आपको कक्षा की एक और विधि की आवश्यकता है। यह Arraysहै Arrays.copyOfRange(). इसे कॉल करना ऐसा दिखता है:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"यह विधि एक नई सरणी भी बनाती है, लेकिन इसे मूल सरणी में मनमानी जगह से तत्वों से भरती है। जहां पहले और आखिरी तत्वों के सूचकांक हैं जिन्हें नए सरणी में रखा जाना चाहिए। क्या आप मुझे बता सकते हैं कि क्या अंतिम तत्व इस श्रेणी में शामिल है?"

"हा! जैसा कि मेरे महान शिक्षक कहा करते थे, ' जावा की अच्छी (या बुरी) पुरानी परंपरा के अनुसार, याद रखें कि अंतिम तत्व सीमा में शामिल नहीं है '।"

"अमीगो, तुम ठीक हमारी आँखों के सामने बढ़ रहे हो।

उदाहरण:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"और अंत में, मैंने सबसे ... एमएमएम... अंतिम के लिए सुखद विधि छोड़ी: सॉर्टिंग । एरेज़ को प्रोग्रामिंग में अक्सर सॉर्ट किया जाता है। सरणियों के साथ काम करते समय यहां शीर्ष 3 सबसे लोकप्रिय क्रियाएं हैं:

• एक सरणी छँटाई
• किसी सरणी का न्यूनतम (या अधिकतम) तत्व ढूँढना
• एक सरणी में एक तत्व के सूचकांक का निर्धारण (एक सरणी में एक तत्व ढूँढना)

"अच्छा प्रदर्शन करने वाले सॉर्टिंग एल्गोरिदम, मुझे कहना होगा, लिखना इतना आसान नहीं है। अधिक सटीक रूप से, यह एक मानक कार्य है, और एक छात्र के रूप में, कभी-कभी सॉर्टिंग एल्गोरिदम लिखने का अभ्यास करने से आपको नुकसान नहीं होगा। लेकिन काम पर, यह है पहिए को फिर से बनाने में अपना समय बर्बाद न करना बेहतर है। जावा के रचनाकारों ने कक्षा sort()में विधि को शामिल किया Arrays। यह ऐसा है जो इसे कॉल करता है:

Arrays.sort(name);

यह विधि पारित सरणी को आरोही क्रम में क्रमबद्ध करती है।

उदाहरण:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"उत्कृष्ट! मैंने केवल एक विधि बुलाई और सरणी क्रमबद्ध हो गई। सुंदरता की बात!"

"वैसे, आप न केवल संपूर्ण सरणी को सॉर्ट कर सकते हैं, बल्कि इसके केवल एक भाग को भी सॉर्ट कर सकते हैं। इसे कॉल करना ऐसा दिखता है:

Arrays.sort(name, first, last);

"जहां पहले और आखिरी पहले और आखिरी कोशिकाओं के सूचकांक हैं जिन्हें सॉर्ट करना चाहिए। और ...

"मैं पहले से ही जानता हूं कि आप क्या कहने जा रहे हैं! 'जावा की अच्छी (या बुरी) पुरानी परंपरा के अनुसार, याद रखें कि अंतिम तत्व श्रेणी में शामिल नहीं है' ।

उदाहरण:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"सरणियों को क्रमबद्ध करने के लिए, जावा सबसे तेज़ छँटाई एल्गोरिथ्म - क्विकसॉर्ट का उपयोग करता है। इसकी कम्प्यूटेशनल जटिलता सरणी के आकार पर निर्भर करती है और सूत्र एन लॉग (एन) का उपयोग करके गणना की जाती है।

"1000 तत्वों की सरणी को क्रमबद्ध करने में सरणी तत्वों की लगभग 10,000 तुलना शामिल होगी। दस लाख तत्वों की सरणी को सॉर्ट करने में लगभग 20 मिलियन तुलना शामिल होंगी।"

" जब आप तत्वों की संख्या पर विचार करते हैं तो बहुत अधिक तुलना नहीं!"

"बिल्कुल वही बात मैं कह रहा हूँ। QuickSort एल्गोरिद्म बहुत कुशल है।

Arrays.binarySearch()

"ठीक है, और कक्षा के सबसे दिलचस्प तरीकों में से अंतिम Arraysएक सरणी में दिए गए मान की खोज करने में सक्षम है। यह कोई सामान्य खोज नहीं है - यह प्रिय बाइनरी खोज है । यह इसके लिए उबलता है:

• सबसे पहले, सरणी क्रमबद्ध है।
• फिर सरणी के मध्य तत्व की तुलना उस से की जाती है जिसकी हम तलाश कर रहे हैं।
• यदि तत्व मध्य तत्व से बड़ा है, तो सरणी के दाहिने आधे भाग में खोज जारी रहती है।
• यदि हम जिस तत्व की तलाश कर रहे हैं वह मध्य तत्व से कम है, तो सरणी के बाएं आधे भाग में खोज जारी रहती है।

"क्योंकि सरणी को सॉर्ट किया गया है, एक ही तुलना में इसके आधे हिस्से को खत्म करना संभव है। फिर अगले चरण में, हम एक और आधे को टॉस करते हैं, और इसी तरह।"

"शानदार! हम बहुत तेज़ी से सीधे लक्ष्य की ओर बढ़ते हैं!"

"बिल्कुल सही। एक मिलियन (!) तत्वों की एक सरणी में, बाइनरी सर्च एल्गोरिदम केवल 20 तुलनाओं में वांछित तत्व की अनुक्रमणिका पा सकता है। एल्गोरिदम की कमी यह है कि सरणी को पहले क्रमबद्ध किया जाना चाहिए, और सॉर्टिंग में भी समय लगता है।

इसे कॉल करने जैसा दिखता है:

int index = Arrays.binarySearch(name, value);

"सरणी का नाम कहां nameहै, जिसे पहले से ही क्रमबद्ध किया जाना चाहिए (उदाहरण के लिए, Arrays.sort()विधि का उपयोग करके)। और valueवह तत्व है जिसे हम सरणी में खोज रहे हैं। विधि द्वारा लौटाया गया परिणाम वांछित सरणी तत्व का सूचकांक है .

उदाहरण:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"क्या होगा यदि वांछित तत्व सरणी में कई बार प्रकट होता है ?"

"यह एक वैध प्रश्न है, अमीगो। इस मामले में, एल्गोरिथ्म उनमें से एक का सूचकांक लौटाएगा (इस बात की कोई गारंटी नहीं है कि यह सबसे पहले होगा, या इसके विपरीत - इन डुप्लिकेट तत्वों में से अंतिम) "

"क्या होगा यदि सरणी में वांछित तत्व बिल्कुल नहीं है?"

"इस मामले में, एल्गोरिथ्म एक नकारात्मक सूचकांक लौटाएगा ।

प्रलेखन

"सब कुछ स्पष्ट है, ऋषि! यह बहुत दिलचस्प था।"

"यदि आपको वास्तव में यह बहुत दिलचस्प लगता है, तो अपने खाली समय में Oracle वेबसाइट पर कक्षा के आधिकारिक दस्तावेज़ीकरण Arraysऔर इसकी विधियों के माध्यम से स्किम करें ।

"आप करीब से देख सकते हैं, उदाहरण के लिए, Arrays.mismatch()और Arrays.compare()विधियां। आप उन्हें अच्छे उपयोग में लाने में सक्षम होंगे।

"और विधियों की संख्या से भ्रमित न हों। प्रत्येक विधि में 5-10 संस्करण होते हैं, जो केवल उनके पैरामीटर प्रकारों में भिन्न होते हैं।"