प्रोग्रामिंग में अक्सर डेटा के बड़े सेट को प्रबंधित और हेरफेर करना शामिल होता है, जिसके लिए कुशल और प्रभावी डेटा संरचनाएं महत्वपूर्ण होती हैं। ऐरे कंप्यूटर विज्ञान में एक मौलिक डेटा संरचना है और एक ही प्रकार के तत्वों के एक निश्चित आकार के अनुक्रम को संग्रहीत करने का साधन प्रदान करता है। इस ब्लॉग में, हम जावा में सरणियों के माध्यम से गहराई से यात्रा करेंगे: यह समझेंगे कि वे क्या हैं, उनका सिंटैक्स, उन पर कैसे काम करना है, और उनकी मेमोरी प्रबंधन।

हमें सारणियों की आवश्यकता क्यों है?

जावा में वेरिएबल्स के साथ काम करते समय, आप प्रत्येक को अलग-अलग घोषित और आरंभ कर सकते हैं, जैसे:

java
int a = 19;
String name = "John Doe";

हालाँकि, यदि आपको एक ही प्रकार के कई मानों को संभालने की आवश्यकता है तो यह दृष्टिकोण अक्षम हो जाता है। उदाहरण के लिए, यदि आपको एकाधिक रोल नंबर या नाम संग्रहीत करने हैं, तो प्रत्येक मान को हार्ड कोडिंग करना व्यावहारिक नहीं है। सारणियाँ आपको मूल्यों के संग्रह को कुशलतापूर्वक संग्रहीत करने की अनुमति देकर काम में आती हैं। उदाहरण के लिए, यदि आपको पांच रोल नंबर संग्रहीत करने की आवश्यकता है, तो आप सरणियों का उपयोग कर सकते हैं।

सारणियाँ क्या हैं?

एक सरणी अनिवार्य रूप से एक ही प्रकार के डेटा आइटम का एक संग्रह है। ऐरे आदिम डेटा प्रकारों जैसे पूर्णांक, फ़्लोट्स और वर्ण, साथ ही ऑब्जेक्ट को संग्रहीत कर सकते हैं। उदाहरण के लिए:

int[] rollNumbers = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};

सारणियों का सिंटेक्स

जावा में एक सरणी घोषित करने का सिंटैक्स सीधा है:

dataType[] arrayName = new dataType[size];

उदाहरण के लिए, पांच पूर्णांकों की एक सरणी बनाने के लिए:

int[] rollNumbers = new int[5];

वैकल्पिक रूप से, आप एक पंक्ति में एक सरणी घोषित और आरंभ कर सकते हैं:

int[] rollNumbers = {23, 55, 9, 18, 45};

सारणियों के लक्षण

सजातीय तत्व

किसी सरणी में, सभी तत्व एक ही प्रकार के होने चाहिए। आप एक ही सरणी में प्रकारों को मिश्रित नहीं कर सकते; उदाहरण के लिए:

int[] nums = {1, 2, "three"}; // Will cause a compile-time error

निश्चित आकार

एक बार एक सरणी बन जाने के बाद, उसका आकार निश्चित हो जाता है। आप इसका आकार बढ़ा या छोटा नहीं कर सकते. यह बाधा अक्सर अधिक गतिशील डेटा आवश्यकताओं के लिए ArrayList जैसी अन्य डेटा संरचनाओं के चयन का कारण बन सकती है।

आंतरिक मेमोरी प्रबंधन

जावा में ऐरे से मिलकर बनता है:

• स्टैक मेमोरी: सरणी के संदर्भ चर को संग्रहीत करता है।
• हीप मेमोरी: वास्तविक सरणी ऑब्जेक्ट और उसके तत्वों को संग्रहीत करता है।

जब आप एक सरणी घोषित करते हैं, तो संदर्भ स्टैक मेमोरी में बनाया जाता है, और सरणी ऑब्जेक्ट ढेर मेमोरी में संग्रहीत होता है।

मेमोरी आवंटन

किसी सरणी के मेमोरी आवंटन में दो महत्वपूर्ण चरण होते हैं:

1. घोषणा: संदर्भ चर बनाया गया है, लेकिन यह कहीं भी इंगित नहीं करता है।
2. प्रारंभीकरण: संदर्भ चर ढेर में वास्तविक सरणी ऑब्जेक्ट को इंगित करता है, जिसमें तत्व शामिल हैं।

उदाहरण के लिए:

int[] rollNumbers; // Declaration
rollNumbers = new int[5]; // Initialization

गतिशील मेमोरी आवंटन

जावा गतिशील मेमोरी आवंटन करता है, जिसका अर्थ है कि रनटाइम पर, यह आवश्यकतानुसार मेमोरी आवंटित करता है, जिससे यह मेमोरी प्रबंधन में कुशल हो जाता है।

ऐरे में इनपुट और आउटपुट

इनपुट ले रहे हैं

उपयोगकर्ता इनपुट के साथ एक सरणी को पॉप्युलेट करने के लिए, आप कंसोल से इनपुट पढ़ने के लिए स्कैनर के साथ एक लूप का उपयोग कर सकते हैं।

Scanner scanner = new Scanner(System.in);
int[] arr = new int[5];
for (int i = 0; i 




  
  
  मुद्रण सारणियाँ


आप अधिक पठनीय आउटपुट के लिए लूप्स या Arrays.toString() उपयोगिता विधि का उपयोग करके एरे प्रिंट कर सकते हैं।


for (int i = 0; i 



या


System.out.println(Arrays.toString(arr));





  
  
  बहुआयामी सारणियाँ


द्वि-आयामी सरणियाँ, या मैट्रिक्स, सरणियों की सरणियाँ हैं। 2डी सरणी के लिए सिंटैक्स इस तरह दिखता है:


int[][] matrix = new int[3][3];





  
  
  उदाहरण




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




2डी सरणी में तत्वों के गतिशील इनपुट के लिए, नेस्टेड लूप का उपयोग किया जाता है।


  
  
  ArrayList: एक गतिशील विकल्प


जावा में ऐरे निश्चित आकार के होते हैं, जिससे संकलन समय पर तत्वों की संख्या अज्ञात होने पर अक्षमताएं पैदा होती हैं। जावा कलेक्शन फ्रेमवर्क के भाग, ArrayList वर्ग का उपयोग करके इस सीमा को दूर किया जा सकता है।


  
  
  ऐरेलिस्ट का उपयोग करना


ArrayList वर्ग गतिशील आकार बदलने की सुविधा प्रदान करता है। यहां ArrayList बनाने का सिंटैक्स दिया गया है:


ArrayList numbers = new ArrayList();




आप तत्वों को गतिशील रूप से जोड़ और हेरफेर कर सकते हैं:


numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println(numbers); // Output: [1, 2, 3]

numbers.set(1, 10); // Change element at index 1
System.out.println(numbers); // Output: [1, 10, 3]

numbers.remove(0); // Remove element at index 0
System.out.println(numbers); // Output: [10, 3]

boolean contains = numbers.contains(10); // Check if the list contains 10
System.out.println(contains); // Output: true





  
  
  ArrayList की आंतरिक कार्यप्रणाली


आंतरिक रूप से, ArrayList प्रारंभिक निश्चित क्षमता के साथ गतिशील सरणियों का उपयोग करता है। जब यह क्षमता समाप्त हो जाती है, तो अधिक क्षमता वाली एक नई सरणी बनाई जाती है, और मौजूदा तत्वों की प्रतिलिपि बनाई जाती है। यह प्रक्रिया सुनिश्चित करती है कि जैसे-जैसे तत्व जोड़े जाते हैं, ArrayList गतिशील रूप से बढ़ सकती है।


  
  
  सामान्य सारणी संचालन



  
  
  अधिकतम तत्व ढूँढना


किसी सरणी में अधिकतम तत्व ढूंढने के लिए, सरणी के माध्यम से पुनरावृत्त करें और उच्चतम मान का ट्रैक रखें:


int max = arr[0];
for (int i = 1; i  max) {
        max = arr[i];
    }
}
System.out.println("Maximum value: "   max);





  
  
  किसी सारणी को उलटना


किसी सरणी को उलटने के लिए, दो-पॉइंटर तकनीक का उपयोग करें:


public static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start 



रिवर्स फ़ंक्शन को कॉल करना:


int[] arr = {1, 2, 3, 4, 5};
reverse(arr);
System.out.println(Arrays.toString(arr)); // Output: [5, 4, 3, 2, 1]





  
  
  निष्कर्ष


ऐरे जावा में एक महत्वपूर्ण डेटा संरचना है, जो डेटा सेट के भंडारण और हेरफेर को कुशलतापूर्वक सक्षम बनाता है। आकार में निश्चित होने पर, सजातीय डेटा प्रकारों से निपटने के दौरान सरणियाँ शक्तिशाली और बहुमुखी होती हैं। गतिशील डेटा आवश्यकताओं के लिए, ArrayList अतिरिक्त लचीलापन प्रदान करता है, जिससे आकार में मनमानी वृद्धि की अनुमति मिलती है। इन संरचनाओं और उनके संचालन को समझना अधिक उन्नत प्रोग्रामिंग और डेटा प्रबंधन के लिए आधार तैयार करता है। इसके अलावा, सरणी संचालन का अभ्यास करने और उनके अंतर्निहित मेमोरी प्रबंधन को समझने से अधिक कुशल और अनुकूलित कोड लिखने में मदद मिलती है।