ஜாவாவில் வரிசைகள்

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

வரிசை என்றால் என்ன?

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

ஒரு வரிசையை அறிவிக்கிறது

ஒரு வரிசையை எவ்வாறு அறிவிப்பது?

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

ஒரு வரிசையை உருவாக்குதல்

ஒரு வரிசையை எவ்வாறு உருவாக்குவது?

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

new typeOfArray[length]; 

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

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

இங்கே நாம் myArray எனப்படும் முழு எண்களின் வரிசையை உருவாக்கினோம் , இது 10 செல்களைக் கொண்டுள்ளது என்பதை கம்பைலருக்குத் தெரிவிக்கிறது (ஒவ்வொன்றும் ஒரு முழு எண்ணைக் கொண்டிருக்கும்). இருப்பினும், ஒரு வரிசையை அறிவிக்கும் போது உடனடியாக உருவாக்க பின்வரும் சுருக்கமான தொடரியல் பயன்படுத்துவது மிகவும் பொதுவானது:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

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

int[] myArray = new int[10];

பத்து முழு எண்களின் வரிசையைப் பெறுகிறோம், மேலும் நிரல் மதிப்புகளை மாற்ற ஏதாவது செய்யும் வரை, ஒவ்வொரு கலத்திலும் 0 இருக்கும்.

ஜாவாவில் வரிசை நீளம்

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

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

வெளியீடு:

10

ஒரு வரிசையை துவக்கி அதன் உறுப்புகளை அணுகுதல்

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

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

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

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

மேலும், புதிய ஆபரேட்டரைத் தவிர்க்கலாம்:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

ஜாவாவில் திரையில் ஒரு வரிசையை எவ்வாறு காண்பிப்பது?

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

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

நிரல் பின்வருவனவற்றைக் காண்பிக்கும்:

Winter 
Spring 
Summer 
Autumn

ஜாவாவில் ஒரு பரிமாண மற்றும் பல பரிமாண வரிசைகள்

ஆனால் எண்கள், சரங்கள் அல்லது பிற பொருள்களின் வரிசையை உருவாக்காமல், வரிசைகளின் வரிசையை உருவாக்க விரும்பினால் என்ன செய்வது? இதைச் செய்ய ஜாவா உங்களை அனுமதிக்கிறது. நாம் ஏற்கனவே அறிந்திருக்கும் வரிசை வகை ( int[] myArray = new int[8] ) ஒரு பரிமாண வரிசை என அறியப்படுகிறது. ஆனால் வரிசைகளின் வரிசை இரு பரிமாண வரிசை என்று அழைக்கப்படுகிறது. இது ஒரு வரிசை எண் மற்றும் நெடுவரிசை எண்ணைக் கொண்ட அட்டவணை போன்றது. அல்லது, நேரியல் இயற்கணிதத்தின் அடிப்படைகளை நீங்கள் கற்றுக்கொண்டிருந்தால், அதை ஒரு அணியாக நீங்கள் நினைக்கலாம். நமக்கு ஏன் இத்தகைய வரிசைகள் தேவை? சரி, மெட்ரிக்குகள் மற்றும் அட்டவணைகள் மற்றும் இதே போன்ற கட்டமைப்பைக் கொண்ட பிற பொருள்களை நிரல் செய்ய. எடுத்துக்காட்டாக, ஒரு சதுரங்கப் பலகையை 8x8 வரிசை மூலம் குறிப்பிடலாம். ஒரு பல பரிமாண வரிசை பின்வருமாறு அறிவிக்கப்பட்டு உருவாக்கப்படுகிறது:

Int[][] myTwoDimentionalArray = new int[8][8];

இந்த வரிசையில் சரியாக 64 கூறுகள் உள்ளன: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] மற்றும் myTwoDimentionalArray[1][7] . எனவே சதுரங்கப் பலகையைப் பிரதிநிதித்துவப்படுத்த இதைப் பயன்படுத்தினால், A1 என்பது myTwoDimentionalArray[0][0] மற்றும் E2 என்பது myTwoDimentionalArray[4][1] க்கு ஒத்திருக்கும் . ஆனால் இதை எவ்வளவு தூரம் தள்ள முடியும்? ஜாவாவில், நீங்கள் வரிசைகளின் வரிசையைக் குறிப்பிடலாம்... வரிசைகளின் வரிசைகள் மற்றும் பல. நிச்சயமாக, முப்பரிமாண மற்றும் உயர் பரிமாண வரிசைகள் மிகவும் அரிதாகவே பயன்படுத்தப்படுகின்றன. உதாரணமாக, ரூபிக் கனசதுரத்தை நிரல் செய்ய முப்பரிமாண வரிசையைப் பயன்படுத்தலாம்.

வரிசைகளுடன் வேலை செய்வதற்கான பயனுள்ள முறைகள்

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

ஒரு வரிசையை வரிசைப்படுத்துதல்

void sort(int[] myArray, int fromIndex, int toIndex) முறையானது ஒரு முழு எண் வரிசை அல்லது துணைவரிசையை ஏறுவரிசையில் வரிசைப்படுத்துகிறது.

ஒரு அணிவரிசையில் ஒரு உறுப்பைத் தேடுகிறது

int binarySearch(int[] myArray, int from Index, int toIndex, int key) . இந்த முறை வரிசைப்படுத்தப்பட்ட myArray array அல்லது subarray இல், Index முதல் Index வரையிலான முக்கிய உறுப்பைத் தேடுகிறது . உருப்படி கண்டுபிடிக்கப்பட்டால், அது அதன் குறியீட்டை வழங்குகிறது. இல்லையெனில், அது (-இன்டெக்ஸ்)-1 ஐத் தருகிறது .

ஒரு வரிசையை சரமாக மாற்றுகிறது

String toString(int[] myArray) முறை ஒரு வரிசையை சரமாக மாற்றுகிறது. ஜாவாவில், வரிசைகள் ஸ்ட்ரிங்() க்கு மேலெழுதப்படாது . இதன் பொருள், " திரையில் ஒரு வரிசையைக் காட்டு " என்ற தலைப்பில் உள்ள பத்தியில் உள்ளதைப் போல ஒரு நேரத்தில் ஒரு உறுப்பைக் காட்டிலும் ஒரு முழு வரிசையையும் ஒரே நேரத்தில் (System.out.println(myArray)) காட்ட முயற்சித்தால் , நீங்கள் பெறுவீர்கள் வகுப்பின் பெயர் மற்றும் வரிசையின் ஹெக்ஸாடெசிமல் ஹாஷ் ( Object.toString() ஆல் வரையறுக்கப்பட்டது ). நீங்கள் ஒரு தொடக்கநிலையாளராக இருந்தால், toString முறை பற்றிய விளக்கம் உங்களுக்கு புரியாமல் இருக்கலாம் . ஆரம்பத்தில், நீங்கள் தேவையில்லை, ஆனால் இந்த முறையைப் பயன்படுத்துவது ஒரு வரிசையைக் காண்பிப்பதை எளிதாக்குகிறது. லூப்பைப் பயன்படுத்தாமல் வரிசையை எளிதாகக் காட்ட ஜாவா உங்களை அனுமதிக்கிறது. கீழே உள்ள உதாரணம் இதை நிரூபிக்கிறது.

வரிசைப்படுத்துதல், பைனரி தேடல் மற்றும் toString ஆகியவற்றைப் பயன்படுத்தி ஒரு எடுத்துக்காட்டு

முழு எண்களின் வரிசையை உருவாக்குவோம், அதை toString ஐப் பயன்படுத்திக் காண்பிப்போம், வரிசைப்படுத்தும் முறையைப் பயன்படுத்தி வரிசைப்படுத்துவோம் , பின்னர் அதில் சில எண்ணைக் கண்டுபிடிப்போம்.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

வெளியீடு:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

முதல் சரம் toString ஐப் பயன்படுத்தாமல் வரிசையைக் காண்பிக்கும் முயற்சியாகும் . இரண்டாவது toString ஐப் பயன்படுத்தி காட்டப்படும் வரிசை . மூன்றாவது வரிசைப்படுத்தப்பட்ட வரிசை. நான்காவது என்பது வரிசைப்படுத்தப்பட்ட வரிசையில் (5) நாம் தேடிய எண்ணின் குறியீடாகும் (நாம் பூஜ்ஜியத்தில் இருந்து எண்ணுகிறோம் என்பதை நினைவில் கொள்ளுங்கள், எனவே வரிசையின் நான்காவது தனிமத்தின் குறியீடு 3 ஆகும்). ஐந்தாவது சரத்தில், -1 ஐக் காண்கிறோம். இது தவறான அணிவரிசை அட்டவணை. நாம் தேடிய எண் (இந்த வழக்கில், 0) வரிசையில் இல்லை என்பதை இது சமிக்ஞை செய்கிறது.

சுருக்கமாக வரிசைகள்

• ஒரு வரிசையின் அத்தியாவசிய பண்புகள்: அதில் வைக்கப்பட்டுள்ள தரவின் வகை, அதன் பெயர் மற்றும் அதன் நீளம்.
  வரிசை உருவாக்கப்படும் போது கடைசி சொத்து தீர்மானிக்கப்படுகிறது (வரிசைக்கு நினைவகம் ஒதுக்கப்படும் போது). வரிசை அறிவிக்கப்படும் போது முதல் இரண்டு பண்புகள் தீர்மானிக்கப்படுகின்றன.

• வரிசை அளவு (கலங்களின் எண்ணிக்கை) ஒரு முழு எண்ணாக இருக்க வேண்டும்

• ஒரு வரிசையை உருவாக்கிய பிறகு அதன் நீளத்தை மாற்றுவது சாத்தியமில்லை.

• ஒரு வரிசை உறுப்பை அதன் குறியீட்டின் மூலம் அணுகலாம்.

• ஜாவாவில் உள்ள எல்லாவற்றையும் போலவே அணிவரிசைகளில் உள்ள கூறுகளும் பூஜ்ஜியத்தில் இருந்து எண்ணப்படுகின்றன.

• ஒரு வரிசை உருவாக்கப்பட்ட பிறகு, அது இயல்புநிலை மதிப்புகளால் நிரப்பப்படும்.

• ஜாவாவில் உள்ள வரிசைகள் C++ இல் உள்ள வரிசைக்கு சமமானவை அல்ல. அவை கிட்டத்தட்ட டைனமிக் வரிசைகளுக்கான சுட்டிகள் போன்றவை.

வரிசைகள் பற்றிய பயனுள்ள பொருட்கள்

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