अरे, जावा अॅरे. ते शेकडो नवशिक्या सॉफ्टवेअर विकसकांच्या तीव्र प्रेम आणि द्वेषाचे वस्तु आहेत. आधीपासून सुरू केलेल्या अॅरेमध्ये घटक जोडणे अशक्य आहे, ते म्हणाले... खरं तर, हे शक्य आहे, परंतु शास्त्रीय अर्थाने नाही... आणि ते फारसे सोयीचे नाही. आधीपासून सुरू केलेल्या अॅरेमध्ये नवीन घटक जोडणे ही एक प्रकारची युक्ती आहे. तथापि, या युक्त्या मुलाखतीत उपयोगी पडू शकतात ... आणि कधीकधी प्रोग्रामरच्या नोकरीमध्ये. तुम्हाला डेटा प्रकार वापरण्याचा आनंद मिळत आहे आणि ते कार्यक्षमतेने कसे करायचे हे जाणून घेण्यासाठी, आम्ही Java अॅरेमध्ये नवीन घटक जोडण्याबद्दल एक मार्गदर्शक लिहिले. सिद्धांत आणि कोडचे नमुने काळजीपूर्वक पाहण्याव्यतिरिक्त, पोस्टमध्ये वैशिष्ट्यीकृत सराव समस्या तपासा आणि पूर्ण करा. Java मध्ये अॅरेमध्ये नवीन घटक कसे जोडायचे - 1

Java मध्ये अॅरे म्हणजे काय

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

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}
पहिल्या प्रकरणात, आम्ही myArray ची व्याख्या केली आणि 10 घटकांच्या अॅरेसाठी जागा वाटप करण्यासाठी Java बनवले, दुसऱ्या myArray1 मध्ये , आम्ही त्यात लगेच 10 मूल्ये प्रविष्ट केली. दोन्ही बाबतीत, घटक 11 फक्त अॅरेमध्ये ढकलला जाऊ शकत नाही. अॅरेसह ऑपरेशन्स करण्यासाठी, डेव्हलपर अॅरेमध्ये असलेल्या मूल्यांच्या निर्देशांकांमध्ये फेरफार करतात. आपण काय केले पाहिजे? अॅरेमध्ये जोडण्याचे सर्वात सामान्य मार्ग पाहू या.

जावा अॅरेमध्ये नवीन घटक जोडण्याचे 5 मार्ग

बरं, अपरिवर्तनीय बदलण्यायोग्य वाटण्यासाठी आमच्या युक्त्या येथे आहेत.
  • अॅरेला सूचीमध्ये रूपांतरित करा
  • मोठ्या क्षमतेसह एक नवीन अॅरे तयार करा आणि अॅरेमध्ये नवीन घटक जोडा
  • System.arraycopy() लागू करत आहे
  • Apache Commons वापरून अॅरे कॉपी करणे
  • ArrayCopyOf() पद्धत लागू करणे
अ‍ॅरेमध्ये घटक जोडण्याच्या या पद्धतींचा बारकाईने विचार करूया.

1. अॅरेला सूचीमध्ये रूपांतरित करणे

आम्ही थेट अॅरेमध्ये नवीन घटक जोडू शकत नसल्यामुळे, त्यांना सूचीमध्ये रूपांतरित करणे, नवीन घटक जोडणे आणि मूल्ये पुन्हा अॅरेमध्ये रूपांतरित करणे ही पुढील सर्वोत्तम गोष्ट आहे. अॅरेला सूचीमध्ये रूपांतरित करण्याचा पहिला मार्ग म्हणजे नवीन अॅरेलिस्ट तयार करण्यासाठी asList() वापरणे. मूल्यांची श्रेणी यशस्वीरित्या बदलल्यानंतर, मूल्य समाविष्ट करण्यासाठी ListAdd() वापरा. एकदा तुम्हाला अ‍ॅरे संपादित करण्याची गरज भासली नाही, तर toArray() पद्धतीच्या मदतीने मूळ डेटा प्रकारात परत रुपांतरित करा . सर्व पद्धती आणि रूपांतरणांसह, हे सुरुवातीला गोंधळात टाकणारे वाटू शकते. गोष्टी साफ करण्यासाठी asList() वापरण्याचे उदाहरण पाहू . 

// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;
 
class ArrayDemo{
   //Let’s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x) {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));
 
       // adding a new element to the array
       arrList.add(x);
 
       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args) {
       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};
 
       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));
 
       //element to be added
       int x = 28;
 
       // call the method to add x in myArray
       myArray = addX(myArray, x);
 
       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}
आउटपुट आहे:
प्रारंभिक अॅरे: [0, 1, 2, 45, 7, 5, 17] 28 जोडलेले अॅरे: [0, 1, 2, 45, 7, 5, 17, 28]
तर, प्रोग्राममध्ये आम्ही 7 व्हॅल्यूजचा myArray यशस्वीरित्या तयार केला आहे , तो भरला आहे आणि प्रिंट आउट केला आहे. मग आम्ही ठरवले की आमच्यासाठी दहा मूल्ये पुरेसे नाहीत. बरं, आम्ही Arrays.asList पद्धत वापरून myArray ला ArrayList arrList मध्ये रूपांतरित केले . येथे 28 आहे, जो घटक जोडायचा आहे. आम्ही ते ArrayList arrList मध्ये जोडले, आणि नंतर toArray() पद्धत वापरून पुन्हा अॅरेमध्ये रूपांतरित केले आणि नवीन अॅरे प्रिंट केले.

2. मोठ्या क्षमतेसह नवीन अॅरे तयार करा

अॅरेमध्ये अधिक घटक जोडण्याचा सर्वात सामान्य मार्ग म्हणजे सुरवातीपासून एक नवीन, मोठा, अॅरे तयार करणे, जुन्या घटकांचे घटक ठेवणे आणि नवीन घटक जोडणे. येथे प्रक्रियेचा चरण-दर-चरण वॉकथ्रू आहे:
  • a+n क्षमतेसह नवीन अॅरे तयार करा (a — मूळ अॅरे क्षमता, n — तुम्ही जोडू इच्छित असलेल्या घटकांची संख्या).
  • मागील डेटा श्रेणीतील सर्व घटक नवीन, तसेच नवीन मूल्यांमध्ये जोडा.
  • परिणामी अॅरे मुद्रित करा.
स्वतः असा अॅरे तयार करण्याचा प्रयत्न करा आणि खालील उदाहरणामध्ये तुमच्या कोडची त्याच्याशी तुलना करा: 

// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {
   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}
आउटपुट आहे:
प्रारंभिक अॅरे: [0, 1, 2, 45, 7, 5, 17] 28 जोडलेले अॅरे:[0, 1, 2, 45, 7, 5, 17, 28]
बरं, अॅरेमध्ये नवीन घटक जोडण्याचा हा मार्ग सर्वात सोपा आहे.

3. System.arrayCopy() लागू करणे

System.arrayCopy() स्त्रोत अॅरेच्या गंतव्यस्थानावर मोठ्या अॅरेचे वाटप करण्यासाठी मोठ्या प्रमाणावर वापरलेली पद्धत आहे. विकसक पद्धतीच्या कंसात नवीन अॅरेमध्ये कॉपी करू इच्छित क्रम निर्दिष्ट करू शकतो. पद्धत कशी कार्य करते हे पाहण्यासाठी आणि ती स्वतःसाठी वापरण्याचा प्रयत्न करा, एक कटाक्ष टाका आणि खालील उदाहरण चालवून पहा: 

import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
       //we create a new Object here, an array of bigger capacity 
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
आउटपुट आहे:
नवीन घटक जोडण्यापूर्वी myArray: [20, 21, 3, 4, 5, 88] myArray नवीन घटक जोडण्यापूर्वी: [20, 21, 3, 4, 5, 88, 12]
येथे आपण myArray अ‍ॅरे तयार केला आहे , तो मुद्रित केला आहे आणि आमची addElement पद्धत वापरून नवीन घटक जोडला आहे , जो System.arrayCopy() वर तयार केला आहे .

4. अॅरे कॉपी करण्यासाठी Apache Commons वापरणे

चला एक नॉन-स्टँडर्ड मार्ग वापरूया. बहुदा, तृतीय-पक्ष लायब्ररी Apache Commons lang. हा Apache Commons प्रकल्पाचा एक भाग आहे जो पुन्हा वापरता येण्याजोग्या Java घटकांच्या सर्व पैलूंवर केंद्रित आहे. प्रकल्पाबद्दलचे ज्ञान अनावश्यक होणार नाही. Apache Commons lang मध्ये एक पद्धत add() आहे जी विशेषतः विस्तारित अॅरेला परवानगी देण्यासाठी डिझाइन केलेली आहे, यामुळे कोडरचा बराच वेळ आणि मेहनत वाचते. हे लक्षात ठेवण्यासारखे आहे की ही Apache Commons add() पद्धत कॉलिंग System.arraycopy() पद्धतीवर आधारित आहे जर तुम्हाला एखाद्या अवघड परीक्षा किंवा मुलाखतीच्या प्रश्नाचे उत्तर द्यायचे असेल तर. तुमच्या प्रोजेक्टमध्ये लायब्ररी जोडण्यासाठी Apache Commons वेबसाइटवर जा आणि लायब्ररी डाउनलोड करा. नंतर फाइल → प्रोजेक्ट स्ट्रक्चर → लायब्ररी > + वर जा आणि डाउनलोड केलेल्या जार फाइल्स निवडा. 

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {
       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}
आउटपुट आहे:
myArray: [0, 1, 2, 3, 4] जोडलेल्या संख्येसह नवीन अॅरे: [0, 1, 2, 3, 4, 5]

5. ArrayCopyOf() लागू करणे

ArrayCopyOf() अॅरेमध्ये नवीन घटक जोडण्याची आणखी एक पद्धत आहे. जसे की Apache Commons lang add() हे ऑपरेशन करण्यासाठी आंतरिकरित्या System.arraycopy() कॉल करते . तथापि, बहुतेक विकासक ArrayCopyOf() ला प्राधान्य देतात कारण ते कोड संक्षिप्त आणि वाचनीय ठेवण्याची परवानगी देते. अॅरेमध्ये नवीन घटक जोडण्यासाठी ArrayCopyOf() वापरण्याचे येथे एक उदाहरण आहे : 

import java.util.Arrays;
class ArrayDemo {
   private static <X> X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
आउटपुट आहे:
नवीन घटक जोडण्यापूर्वी myArray: [20, 21, 3, 4, 5, 88] myArray नवीन घटक जोडण्यापूर्वी: [20, 21, 3, 4, 5, 88, 12]

निष्कर्ष

अॅरेमध्ये घटक कसे जोडायचे हे जाणून घेणे विकसकांना जुन्या कोडची कार्यक्षमता आणि वाचनीयतेचा त्याग न करता त्वरीत अद्यतनित करण्यात मदत करते… किंवा फक्त मुलाखत पास करण्यासाठी. Java अॅरेमध्ये घटक जोडण्याचे वेगवेगळे मार्ग असल्याने, तुम्हाला सोयीस्कर असलेली पद्धत निवडण्यास मोकळ्या मनाने.

अधिक वाचन: