ஓ, ஜாவா வரிசைகள். அவர்கள் நூற்றுக்கணக்கான தொடக்க மென்பொருள் உருவாக்குநர்களின் தீவிர அன்பு மற்றும் வெறுப்பின் பொருள். ஏற்கனவே துவக்கப்பட்ட வரிசையில் உறுப்புகளைச் சேர்ப்பது சாத்தியமற்றது, அவர்கள் சொன்னார்கள்… உண்மையில், இது சாத்தியம், ஆனால் ஒரு பாரம்பரிய அர்த்தத்தில் இல்லை… மேலும் இது மிகவும் வசதியானது அல்ல. ஏற்கனவே துவக்கப்பட்ட வரிசையில் புதிய கூறுகளைச் சேர்ப்பது ஒரு வகையான தந்திரம். இருப்பினும், இந்த தந்திரங்கள் ஒரு நேர்காணலிலும் ... சில சமயங்களில் ஒரு புரோகிராமர் வேலையிலும் கைக்கு வரலாம். தரவு வகையைப் பயன்படுத்துவதில் நீங்கள் மகிழ்ச்சியடைகிறீர்கள் என்பதை உறுதிப்படுத்தவும், அதை எவ்வாறு திறமையாகச் செய்வது என்று தெரிந்துகொள்ளவும், ஜாவா வரிசையில் புதிய உறுப்பைச் சேர்ப்பது குறித்த வழிகாட்டியை நாங்கள் எழுதியுள்ளோம். கோட்பாடு மற்றும் குறியீடு மாதிரிகளை கவனமாகப் பார்ப்பதைத் தவிர, இடுகையில் உள்ள நடைமுறைச் சிக்கல்களைச் சரிபார்த்து முடிக்கவும். ஜாவாவில் ஒரு வரிசைக்கு ஒரு புதிய உறுப்பை எவ்வாறு சேர்ப்பது - 1

ஜாவாவில் ஒரு வரிசை என்றால் என்ன

ஒரு வரிசை என்றால் என்ன, அதை ஜாவாவில் எவ்வாறு உருவாக்குவது என்பதை நினைவில் கொள்வோம். நீங்கள் அதை நினைவில் வைத்திருந்தால், "ஜாவா வரிசைகளில் புதிய கூறுகளைச் சேர்ப்பதற்கான 5 வழிகள்" என்ற அடுத்த துணைத் தலைப்புக்குச் செல்ல தயங்க வேண்டாம். ஆரக்கிளின் அதிகாரப்பூர்வ ஜாவா ஆவணம், வரிசைகள் ஒரே தரவு வகையைச் சேர்ந்த மதிப்புகளின் வரிசை என்று கூறுகிறது. முழு எண்களின் தொகுப்பு ஜாவாவில் ஒரு வரிசைக்கு சரியான எடுத்துக்காட்டு . நீங்கள் வரையறுக்கும் அனைத்து மதிப்புகளும் குறியீட்டு எனப்படும் வரிசையில் ஒரு குறிப்பிட்ட நிலைப்பாட்டைக் கொண்டுள்ளன . வரிசைகளை அறிவிக்க மற்றும் துவக்குவதற்கான வழிகள் இங்கே: 

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}
முதல் வழக்கில், நாங்கள் ஒரு வரிசை myArray ஐ வரையறுத்து , 10 உறுப்புகளின் வரிசைக்கு இடத்தை ஒதுக்க ஜாவாவை உருவாக்கினோம், இரண்டாவது 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 lang ஆனது, வரிசைகளை விரிவுபடுத்த அனுமதிக்கும் வகையில் வடிவமைக்கப்பட்ட சேர்() முறையைக் கொண்டுள்ளது , இது கோடர்களுக்கு நிறைய நேரத்தையும் முயற்சியையும் மிச்சப்படுத்துகிறது. இந்த Apache Commons add() முறையானது , நீங்கள் தந்திரமான தேர்வு அல்லது நேர்காணல் கேள்விக்கு பதிலளிக்க வேண்டியிருக்கும் பட்சத்தில், System.arraycopy() முறையை அழைப்பதை அடிப்படையாகக் கொண்டது என்பதை நினைவில் கொள்ள வேண்டும் . உங்கள் திட்டத்தில் நூலகங்களைச் சேர்க்க அப்பாச்சி காமன்ஸ் இணையதளத்திற்குச் சென்று நூலகங்களைப் பதிவிறக்கவும். பின்னர் File → Project Structure → Libraries > + என்பதற்குச் சென்று பதிவிறக்கம் செய்யப்பட்ட ஜார் கோப்புகளைத் தேர்ந்தெடுக்கவும். 

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]

முடிவுரை

அணிவரிசையில் கூறுகளைச் சேர்ப்பது எப்படி என்பதை அறிந்துகொள்வது, டெவலப்பர்கள் பழைய குறியீட்டை அதன் செயல்பாடு மற்றும் வாசிப்புத்திறனைத் தியாகம் செய்யாமல் விரைவாகப் புதுப்பிக்க உதவுகிறது... அல்லது நேர்காணலில் தேர்ச்சி பெறுவதற்காக. ஜாவா வரிசைகளில் கூறுகளைச் சேர்க்க வெவ்வேறு வழிகள் இருப்பதால், உங்களுக்கு வசதியான முறையைத் தேர்வுசெய்ய தயங்காதீர்கள்.

மேலும் வாசிப்பு: