अॅरे वर्ग

हॅलो पुन्हा! :) आजच्या धड्यात आपण जावा मधील अॅरे क्लासबद्दल बोलू. शेवटच्या धड्यात, आपल्याला अ‍ॅरे नावाची अशी डेटा रचना कळली. आम्ही ते कसे तयार करायचे आणि डेटासह कसे भरायचे ते शिकलो. आणि ते मेमरीमध्ये कसे साठवले जातात ते आम्ही पाहिले. आज आम्ही काही कार्ये आणि अ‍ॅरेसह कार्य करण्याची उदाहरणे पाहू जी तुम्हाला वास्तविक कामात अनेकदा दिसतील. उदाहरणार्थ, या परिस्थितीची कल्पना करा: आमच्याकडे 10 यादृच्छिक संख्या आहेत.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

आमचे कार्य हे अ‍ॅरे चढत्या क्रमाने क्रमवारी लावणे आहे: सर्वात लहान ते मोठे. सरतेशेवटी, ते असे दिसले पाहिजे: [-२३४, -२, १६, २६, ३५, ४३, ९२, ९९, १६७] आपण ते कसे करू? हे काम क्षुल्लक नाही. आम्ही हे यापूर्वी कधीही केले नाही :/ काही कल्पना आहेत? अंदाज लावण्याचा प्रयत्न करा. येथे एक उपाय आहे:

• अॅरेच्या सर्व घटकांमधून जा. प्रत्येक घटकाची पुढील ([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[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

आमचे कार्य त्याच्या सामग्रीची दुसर्या अॅरेमध्ये कॉपी करणे आहे.

int [] numbersCopy = new int[10];

तुम्हाला अ‍ॅरे बद्दल आधीच माहिती आहे ते वापरून तुम्ही ते कसे कराल याचा विचार करा? उदाहरणार्थ, तुम्ही लूपमध्ये नंबर अॅरेमधून जाऊ शकता आणि अनुक्रमे त्याचे घटक 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];
       }

   }
}

ठीक आहे, अरे, येथे आम्ही मुळात ते केले आहे! असे दिसते की आम्ही समस्या सोडवली आहे. तथापि, आपल्याला हे वारंवार करण्याची आवश्यकता असल्यास, आपल्या कोडमध्ये एकसारखे लूप असतील. खरं तर, ही (आणि इतर) कार्ये Java च्या निर्मात्यांनी दीर्घकाळ सोडवली आहेत. आम्हाला "चाक पुन्हा शोधण्याची" आणि स्वतःचे समाधान कोड करण्याची आवश्यकता नाही. अ‍ॅरेसह कार्य करताना सामान्य कार्ये करण्यास मदत करण्यासाठी एक विशेष स्थिर वर्ग ( अॅरे ) आहे . Java प्रोग्रामरना भेडसावणारी सर्वात सामान्य कार्ये करण्याच्या पद्धती या वर्गात जोडल्या गेल्या आहेत. उदाहरणार्थ, अॅरेची क्रमवारी लावण्याचे कार्य, जे आम्ही हाताळण्याचा प्रयत्न केला, ते एका ओळीत सोडवले जाते:

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] टीप: अॅरेला स्ट्रिंगमध्ये रूपांतरित करण्यासाठी, आम्ही अॅरे क्लासची दुसरी पद्धत वापरली: Arrays.toString() . Java मधील अॅरे toString() पद्धत स्वतःहून ओव्हरराइड करत नाहीत . तर, जर तुम्ही फक्त लिहा

System.out.println(numbers.toString());

ऑब्जेक्ट क्लासच्या toString() ला कॉल केला जाईल. अॅरेसाठी, आउटपुट असे काहीतरी असेल: [I@4554617c हे नक्की आउटपुट का आहे याबद्दल आम्ही आता तपशीलात जाणार नाही. मुख्य गोष्ट अशी आहे की हे स्पष्टपणे आपल्याला आवश्यक नाही. पण Arrays.toString() आपल्याला हवे तेच करते. तसे, अॅरे क्लाससह कॉपी करणे देखील सहजपणे पूर्ण केले जाते:

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() पद्धतीकडे आमचा मूळ अॅरे (ज्यामधून आम्हाला व्हॅल्यू कॉपी करायची आहे) आणि नवीन अॅरेची लांबी ज्यामध्ये आम्ही डेटा कॉपी करत आहोत. या प्रकरणात, आम्ही लांबी म्हणून numbers.length सूचित केले आहे, कारण संपूर्ण अॅरे कॉपी करायची आहे. आम्हाला फक्त पहिले काही घटक कॉपी करायचे असल्यास, आम्ही नवीन लहान अॅरेची लांबी निर्दिष्ट करू शकतो:

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 घटक नवीन अॅरेमध्ये कॉपी केले जातील. कन्सोल आउटपुट: [१६७, -२, १६, ९९] तसे, अॅरे तुम्हाला अॅरेच्या सुरूवातीऐवजी मध्यभागी अॅरेचा भाग कॉपी करू देते:

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));

   }
}

आउटपुट: [१६, ९९, २६, ९२] दुसऱ्या अॅरेमधून दुसऱ्या (समावेशक) पासून सहाव्या (समावेशक नाही) घटकापर्यंत संख्या नवीन अॅरेमध्ये कॉपी केली गेली. आम्हाला दोन अॅरेची तुलना देखील करावी लागेल. toString() पद्धतीप्रमाणे , अ‍ॅरे स्वतःच equals() पद्धतीला ओव्हरराइड करत नाहीत. म्हणून जर आपण त्यांची अशी तुलना करण्याचा प्रयत्न केला तर

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 वर्ग आपल्याला पाहिजे तसे करण्यासाठी equals() पद्धत ओव्हरराइड करतो:

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));
   }
}

आउटपुट: खरे तसे, अॅरे वर्ग केवळ सामान्य अॅरेसहच नाही तर द्विमितीय अॅरेसह देखील कार्य करतो:

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));
   }
}

आउटपुट: हे द्विमितीय अॅरे समान आहेत का? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] तुम्ही बघू शकता, Arrays.copyOf() पद्धत द्विमितीय अॅरे कॉपी करण्यास सक्षम होती. आणि वर्गामध्ये द्विमितीय अॅरेची तुलना आणि प्रदर्शन करण्यासाठी विशेष पद्धती आहेत: deepEquals आणि deepToString() . भविष्यात, तुम्हाला वारंवार दिसेल (आणि या वस्तुस्थितीचा आनंद घ्या) की Java च्या निर्मात्यांनी प्रोग्रामरना वारंवार सामोरे जाणाऱ्या बर्‍याच परिस्थितींचा अंदाज लावला होता आणि त्यांच्यासाठी भाषेत तयार उपाय लागू केले होते. चाक पुन्हा शोधण्यापेक्षा हे उपाय वापरणे खूप सोपे आणि अधिक सोयीस्कर आहे, बरोबर? :) ओरॅकल वेबसाइटवर अॅरे क्लाससाठी कागदपत्रे वाचण्याची खात्री करा . तुमच्या अभ्यासात शुभेच्छा!