फिर से हैलो! :) आज के पाठ में, हम जावा में Arrays वर्ग के बारे में बात करेंगे। पिछले पाठ में, हमें एक ऐसी डेटा संरचना के बारे में पता चला जिसे एक सरणी कहा जाता है। हमने सीखा कि उन्हें कैसे बनाया जाता है और उन्हें डेटा से कैसे भरा जाता है। और हमने देखा कि कैसे वे मेमोरी में स्टोर होते हैं। आज हम सरणियों के साथ काम करने के कुछ कार्यों और उदाहरणों को देखेंगे जिन्हें आप वास्तविक कार्य में अक्सर देखेंगे। उदाहरण के लिए, इस स्थिति की कल्पना करें: हमारे पास 10 यादृच्छिक संख्याओं की एक सरणी है।
हमारा काम इस सरणी को आरोही क्रम में क्रमबद्ध करना है: सबसे छोटे से सबसे बड़े तक। अंत में, यह इस तरह दिखना चाहिए: [-234, -2, 16, 26, 35, 43, 92, 99, 167] हम यह कैसे करते हैं? यह कार्य तुच्छ नहीं है। हमने पहले कभी ऐसा नहीं किया है:/कोई विचार? बूझने की कोशिश करो। यहाँ एक समाधान है:
सरणी के सभी तत्वों के माध्यम से जाओ। प्रत्येक तत्व की अगले के साथ तुलना करें ([0] के साथ [1], [1] के साथ [2], [2] के साथ [3], आदि)। यदि वर्तमान तत्व अगले से अधिक है, तो हम उन्हें स्वैप करते हैं और फिर अगले तत्व पर जाते हैं। यदि नहीं, तो उन्हें वैसे ही रहने दें और आगे बढ़ें
इस प्रकार, तत्वों के पहले पास के बाद, सबसे बड़ा मान (167) अंतिम सेल में होने की गारंटी है।
अब हम फिर से सभी तत्वों से गुजरेंगे, लेकिन इस बार हम अनुक्रमणिका [0] से अंतिम तत्व (सबसे बड़ी संख्या पहले से ही अपनी जगह पर है) से शुरू करेंगे और समान तुलना और अदला-बदली करेंगे। इस पास के बाद, अंतिम सेल में, हमारे पास दूसरा सबसे बड़ा मान (99) होगा।
इस प्रक्रिया को उतनी बार दोहराएं जितनी बार हमारे पास सरणी तत्व हैं।
हमारे पास विचार है। अब हमें केवल कोड लिखने की जरूरत है। यह इस तरह दिख रहा है:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
उह ... यह थोड़ा जटिल लगता है -_- भले ही सामान्य सिद्धांत समझ में आता है, फिर भी हमें इस तरह के सरल कार्य को हल करने के लिए काफी कोड लिखना पड़ता है। ठीक है, शायद हमने खुद को कम करके आंका है? हमने जो कार्य निपटाया है वह शायद अभी भी हमारे लिए बहुत जटिल है। आइए कुछ सरल प्रयास करें। उदाहरण के लिए, समान संख्या सरणी लें।
हमारा काम इसकी सामग्री को किसी अन्य सरणी में कॉपी करना है।
int [] numbersCopy = new int[10];
इस बारे में सोचें कि आप सरणियों के बारे में जो पहले से जानते हैं उसका उपयोग करके आप इसे कैसे करेंगे? उदाहरण के लिए, आप एक लूप में numbers सरणी के माध्यम से जा सकते हैं और क्रमिक रूप से इसके तत्वों को numbersCopy में लिख सकते हैं :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
ठीक है, उह, यहाँ हमने मूल रूप से यह किया है! ऐसा लगता है कि हमने समस्या का समाधान कर लिया है। हालाँकि, यदि आपको अक्सर ऐसा करने की आवश्यकता होती है, तो आपके कोड में समान लूप का एक समूह होगा। वास्तव में, ये (और अन्य) कार्य लंबे समय से जावा के रचनाकारों द्वारा हल किए गए हैं। हमें "पहिए को सुदृढ़ करने" और अपने स्वयं के समाधान को कोड करने की आवश्यकता नहीं है। सरणियों के साथ काम करते समय सामान्य कार्य करने में आपकी मदद करने के लिए एक विशेष स्थैतिक वर्ग ( सरणी ) होता है। जावा प्रोग्रामर्स द्वारा सामना किए जाने वाले सबसे सामान्य कार्यों को करने के तरीके इस वर्ग में जोड़े गए हैं। उदाहरण के लिए, एक सरणी को छाँटने का कार्य, जिसे हमने संभालने की कोशिश की, एक पंक्ति में हल हो गई:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
Arrays.sort () विधि सरणी को सॉर्ट करती है। और इसका एल्गोरिदम हमारे द्वारा लिखे गए कोड से कहीं अधिक कुशल है। कंसोल आउटपुट: [ -234 , -2, 16, 26, 35, 43, 80, 92, 99 , 167 ] . Java में Arrays toString() मेथड को अपने आप ओवरराइड नहीं करते हैं । तो, अगर आप बस लिखते हैं
System.out.println(numbers.toString());
ऑब्जेक्ट क्लास के toString() को कॉल किया जाएगा। एक ऐरे के लिए, आउटपुट कुछ इस तरह होगा: [I@4554617c हम अब इस बारे में विस्तार से नहीं जानेंगे कि वास्तव में यह आउटपुट क्यों है। मुख्य बात यह है कि यह स्पष्ट रूप से वह नहीं है जिसकी हमें आवश्यकता है। लेकिन Arrays.toString() ठीक वही करता है जो हम चाहते हैं। वैसे, नकल भी आसानी से Arrays वर्ग के साथ पूरी की जाती है:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
हम Arrays.copyOf() विधि को हमारे मूल सरणी (जिसमें से हम मूल्यों की प्रतिलिपि बनाना चाहते हैं) और नई सरणी की लंबाई जिसमें हम डेटा कॉपी कर रहे हैं, पास करते हैं। इस मामले में, हमने संख्या.लंबाई को लंबाई के रूप में इंगित किया है, क्योंकि हम संपूर्ण सरणी की प्रतिलिपि बनाना चाहते हैं। अगर हम केवल पहले कुछ तत्वों की प्रतिलिपि बनाना चाहते हैं, तो हम एक नई छोटी सरणी की लंबाई निर्दिष्ट कर सकते हैं:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
यहां हमने 4 को नई सरणी की लंबाई के रूप में निर्दिष्ट किया है। तदनुसार, संख्याओं के केवल पहले 4 तत्वों को नई सरणी में कॉपी किया जाएगा। कंसोल आउटपुट: [167, -2, 16, 99] वैसे, Arrays आपको सरणी की शुरुआत के बजाय मध्य से एक सरणी का हिस्सा कॉपी करने देता है:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
आउटपुट: [16, 99, 26, 92] संख्याओं को दूसरे एरे से दूसरे एरे से दूसरे (सम्मिलित) से छठे (सम्मिलित नहीं) तत्व में कॉपी किया गया था। हमें दो सरणियों की तुलना करने की भी आवश्यकता हो सकती है। जैसा कि toString () विधि के साथ होता है, सरणियाँ स्वयं समान () विधि को ओवरराइड नहीं करती हैं। तो अगर हम उनकी इस तरह से तुलना करने की कोशिश करते हैं
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
तो हम झूठे हो जाते हैं। ऐसा इसलिए है क्योंकि Object.equals() , जो संदर्भों की तुलना करता है, को कॉल किया जाएगा। और जाहिर है, वे अलग हैं! लेकिन हमें जो चाहिए वह सरणी सामग्री की तुलना करना है, संदर्भों की नहीं। Arrays वर्ग बराबरी () विधि को ओवरराइड करता है ताकि वह वही कर सके जो हम चाहते हैं :
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
आउटपुट: सच वैसे, Arrays वर्ग न केवल साधारण सरणियों के साथ काम करता है, बल्कि द्वि-आयामी सरणियों के साथ भी काम करता है:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
आउटपुट: क्या ये द्वि-आयामी सरणियाँ समान हैं? सच [[1, 2, 3], [4, 5, 6], [7, 8, 9]] जैसा कि आप देख सकते हैं, Arrays.copyOf() विधि द्वि-आयामी सरणी की प्रतिलिपि बनाने में सक्षम थी। और द्वि-आयामी सरणी की तुलना और प्रदर्शित करने के लिए कक्षा में विशेष विधियां हैं: deepEquals और deepToString() । भविष्य में, आप बार-बार देखेंगे (और इस तथ्य में आनन्दित होंगे) कि जावा के रचनाकारों ने प्रोग्रामर द्वारा अक्सर सामना की जाने वाली बहुत सी स्थितियों का अनुमान लगाया, और भाषा में उनके लिए तैयार समाधान लागू किए। इन समाधानों का उपयोग करना पहिए को फिर से लगाने की तुलना में बहुत आसान और अधिक सुविधाजनक है, है ना? :) Oracle वेबसाइट पर Arrays वर्ग के लिए प्रलेखन पढ़ना सुनिश्चित करें । आपकी पढ़ाई में गुड लक!
GO TO FULL VERSION