में पहुंचता है Java

⚡ स्मार्ट सारांश

में पहुंचता है Java ये निश्चित आकार के, इंडेक्स-आधारित कंटेनर होते हैं जो एक ही डेटा प्रकार के तत्वों को सन्निहित मेमोरी में संग्रहीत करते हैं, जिससे निरंतर समय पहुंच, अंतर्निर्मित सीमा जांच और एक लंबाई फ़ील्ड मिलती है जो उन्हें अधिकांश मानक-पुस्तकालय संग्रहों का आधार बनाती है।

  • 📦 निश्चित आकार: एक ऐरे में एक ही प्रकार के तत्वों की एक निश्चित संख्या होती है।
  • 🔢 शून्य-आधारित सूचकांक: एलिमेंट्स की संख्या 0 से लेकर लंबाई माइनस एक तक होती है।
  • 🧩 दो प्रकार: Java इसमें एकल-आयामी और बहुआयामी सरणियाँ होती हैं।
  • तीन चरण: प्रत्येक ऐरे को घोषित किया जाता है, और उसका निर्माण किया जाता है। newऔर आरंभ किया गया।
  • सीमा जाँच: JVM त्रुटि उत्पन्न करता है ArrayIndexOutOfBoundsException अंतिम स्लॉट के पार।
  • संदर्भ द्वारा: किसी मेथड के अंदर किए गए एलिमेंट परिवर्तन कॉलर के लिए बने रहते हैं।
  • 📏 लंबाई क्षेत्र: प्रत्येक ऐरे उजागर करता है length सुरक्षित पुनरावृति के लिए।

में पहुंचता है Java

क्या है एक Java सरणी?

A Java सरणी यह एक निश्चित आकार की संरचना है जो एक ही डेटा प्रकार के तत्वों को सन्निहित मेमोरी में संग्रहीत करती है। प्रत्येक तत्व शून्य-आधारित सूचकांक द्वारा पहुँचा जा सकता है, इसलिए पहला तत्व शून्य पर स्थित होता है। 0 और आखिरी में length - 1सरणियाँ इससे विरासत में मिलती हैं Object और लागू करें Serializable और Cloneableऔर इसमें प्रिमिटिव या ऑब्जेक्ट रेफरेंस हो सकते हैं।

क्रमांकित चरों की लंबी श्रृंखलाओं को सरणियों से प्रतिस्थापित किया जाता है। छह स्वतंत्र पूर्णांकों पर विचार करें:

x0 = 0;
x1 = 1;
x2 = 2;
x3 = 3;
x4 = 4;
x5 = 5;

वही छह मान छह लंबाई वाले एक ही ऐरे में मौजूद हैं:

x[0] = 0;
x[1] = 1;
x[2] = 2;
x[3] = 3;
x[4] = 4;
x[5] = 5;

A पाश वेरिएबल ब्रैकेट में इंडेक्स को नियंत्रित कर सकता है, इसलिए प्रत्येक तत्व को संसाधित करने के लिए छह प्रतियों के बजाय तीन लाइनें ही पर्याप्त हैं:

for (int count = 0; count < 5; count++) {
    System.out.println(x[count]);
}

सरणी के प्रकार Java

Java एरे दो प्रकार के होते हैं:

  1. एकल-आयामी सरणी: तत्वों की एक सपाट सूची।
  2. बहुआयामी सरणी: ग्रिड और मैट्रिक्स के लिए उपयोग की जाने वाली सरणियों की एक सरणी।

ऐरे वैरिएबल: घोषणा, निर्माण और आरंभीकरण

ऐरे का उपयोग करना एक तीन कदम प्रक्रिया: घोषित करें, निर्माण करें newफिर आरंभ करें।

1) ऐरे घोषित करें

सिंटेक्स:

<elementType>[] <arrayName>;

or (पुराना सी-शैली वाला प्रारूप, जो अभी भी मान्य है):

<elementType> <arrayName>[];

उदाहरण:

int[] intArray;   // canonical form: brackets on the type
int intArray2[];  // legacy C-style form, discouraged in new code

2) ऐरे का निर्माण करें

सिंटेक्स:

arrayName = new dataType[size];

उदाहरण:

intArray = new int[10]; // defines that intArray will store 10 integer values

घोषणा और निर्माण संयुक्त:

int[] intArray = new int[10];

3) ऐरे को इनिशियलाइज़ करें

intArray[0] = 1; // assigns 1 to the first element (index 0)
intArray[1] = 2; // assigns 2 to the second element (index 1)

एक ही चरण में घोषणा और आरंभीकरण करें ऐरे लिटरल का उपयोग करना:

int[] intArray = {1, 2, 3, 4};
// initialises an integer array of length 4 where the first element is 1,
// the second element is 2, and so on.

पहला ऐरे प्रोग्राम Java

चरण 1) नीचे दिए गए कोड को किसी एडिटर में कॉपी करें:

class ArrayDemo {
    public static void main(String args[]) {
        int array[] = new int[7];

        for (int count = 0; count < 7; count++) {
            array[count] = count + 1;
        }

        for (int count = 0; count < 7; count++) {
            System.out.println("array[" + count + "] = " + array[count]);
        }

        // System.out.println("Length of Array  =  " + array.length);
        // array[8] = 10;
    }
}

चरण 2) कोड को सेव करें, कंपाइल करें और रन करें। आउटपुट देखें।

अपेक्षित उत्पादन:

array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5
array[5] = 6
array[6] = 7

चरण 3) If x यह एक ऐरे रेफरेंस है, x.length यह स्लॉट की संख्या लौटाता है। पहली कमेंट की गई पंक्ति को अनकमेंट करें और दोबारा चलाएँ:

Length of Array  =  7

चरण 4) सी के विपरीत, Java प्रत्येक ऐरे एक्सेस की सीमा-जांच करता है। दूसरी कमेंट की गई पंक्ति को अनकमेंट करें और पुनः चलाएँ:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 8
        at ArrayDemo.main(ArrayDemo.java:11)
Command exited with non-zero status 1

चरण 5) JVM त्रुटि उत्पन्न करता है ArrayIndexOutOfBoundsExceptionC में, इसी तरह की एक्सेस करने पर विफलता के बजाय आसन्न मेमोरी से कचरा डेटा वापस मिलेगा।

Java ऐरे: संदर्भ द्वारा पास करें

एरे को रेफरेंस द्वारा मेथड में पास किया जाता है। मेथड को रेफरेंस की एक कॉपी मिलती है, इसलिए मेथड के अंदर किए गए एलिमेंट परिवर्तन कॉलर को दिखाई देते हैं।

उदाहरण: एरे को संदर्भ द्वारा पास किया जाता है।

चरण 1) नीचे दिए गए कोड को किसी एडिटर में कॉपी करें:

class ArrayDemo {
    public static void passByReference(String a[]) {
        a[0] = "Changed";
    }

    public static void main(String args[]) {
        String[] b = {"Apple", "Mango", "Orange"};
        System.out.println("Before Function Call    " + b[0]);
        ArrayDemo.passByReference(b);
        System.out.println("After Function Call    " + b[0]);
    }
}

चरण 2) कोड को सेव करें, कंपाइल करें और रन करें। आउटपुट देखें।

अपेक्षित उत्पादन:

Before Function Call    Apple
After Function Call    Changed

बहुआयामी सरणियों में Java

बहुआयामी सरणियाँ, सरणियों की सरणियाँ होती हैं। प्रत्येक आयाम के लिए वर्गाकार कोष्ठकों का एक और सेट जोड़ें। चार पंक्तियों और पाँच स्तंभों वाली 2-आयामी पूर्णांक ग्रिड बनाने के लिए:

int[][] twoD = new int[4][5];

आपको केवल पहले (सबसे बाईं ओर) आयाम का आकार पहले से निर्धारित करना होगा। शेष आयामों को अलग-अलग आवंटित किया जा सकता है, और प्रत्येक पंक्ति की अपनी लंबाई हो सकती है। Java 2-डी सरणियाँ सही हैं टेढ़ी-मेढ़ी सरणियाँ.

उदाहरण:

public class Guru99 {
    public static void main(String[] args) {
        // Create a 2-dimensional array with 4 rows and 4 columns.
        int[][] twoD = new int[4][4];

        // Assign three elements to it.
        twoD[0][0] = 1;
        twoD[1][1] = 2;
        twoD[3][2] = 3;

        System.out.print(twoD[0][0] + " ");
    }
}

अपेक्षित उत्पादन:

1

अक्सर पूछे जाने वाले प्रश्न

A Java ऐरे एक निश्चित आकार का कंटेनर है जो एक ही डेटा प्रकार के तत्वों को संग्रहीत करता है। प्रत्येक तत्व को शून्य-आधारित इंडेक्स द्वारा एक्सेस किया जाता है, और प्रत्येक ऐरे में स्लॉट संख्या के साथ एक लंबाई फ़ील्ड होती है।

int[] arr से डिक्लेयर करें, new int[size] से कंस्ट्रक्ट करें, फिर इंडेक्स द्वारा असाइन करें। तीनों को एक ही लाइन में करने के लिए, int[] arr = {1, 2, 3, 4} जैसे लिटरल का उपयोग करें।

Java यह एकल-आयामी और बहुआयामी सरणियों का समर्थन करता है। एक एकल-आयामी सरणी एक सपाट सूची होती है, और एक बहुआयामी सरणी सारणियों की एक सरणी होती है जिसका उपयोग तालिकाओं, ग्रिडों और मैट्रिक्स के लिए किया जाता है।

उदाहरण के लिए, arr.length जैसे लेंथ फ़ील्ड का उपयोग करें। यह स्लॉट की संख्या लौटाता है और किसी भी प्रकार के ऐरे के लिए काम करता है। स्ट्रिंग के विपरीत, ऐरे लेंथ को एक फ़ील्ड के रूप में प्रदर्शित करते हैं, न कि किसी मेथड कॉल के रूप में।

JVM प्रत्येक ऐरे एक्सेस की सीमा जाँच करता है। शून्य से नीचे या लंबाई के बराबर या उससे अधिक इंडेक्स को पढ़ने या लिखने पर ArrayIndexOutOfBoundsException उत्पन्न होता है, जिससे C और अन्य भाषाओं में व्याप्त मेमोरी भ्रष्टाचार संबंधी बग्स से बचाव होता है। C++.

Java यह विधि आर्गुमेंट्स को वैल्यू द्वारा पास करती है, लेकिन एरे के मामले में वह वैल्यू रेफरेंस की एक कॉपी होती है। यह विधि उसी मूल एरे पर कार्य करती है, इसलिए विधि के अंदर तत्वों में होने वाले परिवर्तन कॉलर को दिखाई देते हैं।

मशीन लर्निंग कोड सहायक डिक्लेयर-कंस्ट्रक्ट-इनिशियलाइज़ पैटर्न को पहचानते हैं और लिटरल या लूप को पूरा करते हैं। वे रनटाइम पर ArrayIndexOutOfBoundsException उत्पन्न करने वाली सामान्य त्रुटियों को भी चिह्नित करते हैं।

जी हां। GitHub Copilot एक साधारण भाषा में लिखे गए कमेंट से ऐरे डिक्लेरेशन, लूप, Arrays.sort कॉल और 2-D मैट्रिक्स वॉक की संरचना तैयार करता है। Revउत्पादन डेटा पर चलाने से पहले उत्पन्न सीमाओं को देखें।

इस पोस्ट को संक्षेप में इस प्रकार लिखें: