கோட்ஜிம் பாடத்தில் வரிசைகள் CodeGym இல், நீங்கள் ஜாவா தொடரியல் தேடலின் நிலை 7 இல் வரிசைகளுடன் வேலை செய்யத் தொடங்குகிறீர்கள். மூன்று பாடங்கள் அவர்களுக்கு அர்ப்பணிக்கப்பட்டுள்ளன, அத்துடன் வரிசைகளுடன் பணிபுரியும் உங்கள் திறன்களை ஒருங்கிணைக்க பல்வேறு நிலைகளில் 8 பணிகள் உள்ளன. ஆனால் பாடத்திட்டத்தின் போது நீங்கள் பல முறை வரிசைகளை சந்திப்பீர்கள் (குறிப்பாக, ஜாவா சேகரிப்புகள் தேடலில் மற்றும் உங்கள் எதிர்கால வேலையின் ஒரு பகுதியாக வரிசை வகுப்பு படிக்கப்படும் . |
வரிசை என்றால் என்ன?
ஒரு வரிசை என்பது ஒரே வகை கூறுகளை சேமிக்கும் தரவு அமைப்பு ஆகும். எண்ணிடப்பட்ட கலங்களின் தொகுப்பாக நீங்கள் நினைக்கலாம். ஒவ்வொரு கலத்திலும் சில தரவுகளை வைக்கலாம் (ஒரு கலத்திற்கு ஒரு தரவு உறுப்பு). ஒரு குறிப்பிட்ட செல் அதன் எண்ணைப் பயன்படுத்தி அணுகப்படுகிறது. வரிசையில் உள்ள ஒரு தனிமத்தின் எண் குறியீட்டு என்றும் அழைக்கப்படுகிறது . ஜாவாவில், ஒரு வரிசை ஒரே மாதிரியானது, அதாவது அதன் அனைத்து செல்களும் ஒரே வகை கூறுகளைக் கொண்டிருக்கும். எனவே, முழு எண்களின் வரிசையில் முழு எண்கள் ( int ), சரங்களின் வரிசை - சரங்கள் மட்டுமே உள்ளன, மேலும் நாம் உருவாக்கிய நாய் வகுப்பின் நிகழ்வுகளின் வரிசையில் நாய் பொருள்கள் மட்டுமே இருக்கும் . வேறு வார்த்தைகளில் கூறுவதானால், வரிசையின் முதல் கலத்தில் ஒரு முழு எண்ணையும், இரண்டாவதாக ஒரு சரத்தையும் , மூன்றாவது செல்லில் ஒரு நாயையும் வைக்க ஜாவா அனுமதிக்காது .ஒரு வரிசையை அறிவிக்கிறது
ஒரு வரிசையை எவ்வாறு அறிவிப்பது?
எந்த மாறியைப் போலவே, ஒரு வரிசை ஜாவாவில் அறிவிக்கப்பட வேண்டும். இதை இரண்டு வழிகளில் ஒன்றில் செய்யலாம். அவை சமமானவை, ஆனால் முதல் வழி ஜாவா பாணியுடன் மிகவும் ஒத்துப்போகிறது. இரண்டாவது சி மொழியின் மரபு: பல சி புரோகிராமர்கள் ஜாவாவுக்கு மாறினர், மேலும் அவர்களின் வசதிக்காக ஒரு மாற்று முறை வைக்கப்பட்டுள்ளது. ஜாவாவில் ஒரு வரிசையை அறிவிப்பதற்கான இரண்டு வழிகளையும் அட்டவணை காட்டுகிறது:இல்லை. | ஒரு வரிசையை அறிவிக்கிறது, ஜாவா தொடரியல் | எடுத்துக்காட்டுகள் | கருத்து |
---|---|---|---|
1. |
dataType[] arrayName; |
|
இந்த வழியில் ஒரு வரிசையை அறிவிப்பது நல்லது. இது ஜாவா ஸ்டைல். |
2. |
dataType arrayName[]; |
|
C/C++ இலிருந்து பெறப்பட்ட வரிசை அறிவிப்பு முறை ஜாவாவில் வேலை செய்கிறது |
ஒரு வரிசையை உருவாக்குதல்
ஒரு வரிசையை எவ்வாறு உருவாக்குவது?
மற்ற பொருளைப் போலவே, நீங்கள் ஒரு ஜாவா வரிசையை உருவாக்கலாம், அதாவது புதிய ஆபரேட்டரைப் பயன்படுத்தி நினைவகத்தில் ஒரு இடத்தை ஒதுக்கலாம் . இது இவ்வாறு செய்யப்படுகிறது:
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++ இல் உள்ள வரிசைக்கு சமமானவை அல்ல. அவை கிட்டத்தட்ட டைனமிக் வரிசைகளுக்கான சுட்டிகள் போன்றவை.
GO TO FULL VERSION