வணக்கம்! முன்பு உங்கள் பயிற்சியில், நாங்கள் ஒற்றைப் பொருள்களுடன் (மற்றும் பழமையான வகைகள்) பணியாற்றியுள்ளோம். ஆனால் ஒரே ஒரு பொருளுக்குப் பதிலாக ஒரு முழுப் பொருள்களுடன் வேலை செய்ய வேண்டுமானால் என்ன செய்வது? எடுத்துக்காட்டாக, எங்கள் நிறுவனத்தில் உள்ள அனைத்து ஊழியர்களின் பிறந்தநாள் பட்டியலை உருவாக்க விரும்புகிறோம். இது பின்வருமாறு வடிவமைக்கப்பட்ட 30 சரங்களைக் கொண்டிருக்க வேண்டும்: "சாரா ஹஃப்மேன், ஜனவரி 25" வரிசை எனப்படும் சிறப்பு தரவு கட்டமைப்பிலிருந்து நாங்கள் பயனடைவோம் . ஒரு வரிசையை உண்மையான பொருளுடன் ஒப்பிட்டுப் பார்த்தால், அது பாதுகாப்பு வைப்புப் பெட்டிகளைக் கொண்ட வங்கி பெட்டகத்தைப் போலவே இருக்கும்: ஒரு வரிசையானது "பெட்டிகளையும்" கொண்டுள்ளது. ஒவ்வொரு பெட்டியிலும் ஏதாவது ஒன்றை (ஒரு உறுப்பு) வைக்கலாம். ஒரு உறுப்பை அணுக, அதன் பெட்டி எண்ணை (இண்டெக்ஸ்) தெரிந்து கொள்ள வேண்டும். ஒரு வரிசை உருவாக்கப்படுவது இதுதான்:
public class Main {
public static void main(String[] args) {
String [] birthdays = new String[10];
}
}
இங்கே நாம் 10 கூறுகளைக் கொண்ட ஒரு வரிசையை உருவாக்குகிறோம். வரிசையின் சில அம்சங்களை நீங்கள் உடனடியாக கவனிக்கலாம்:
இது நன்கு வரையறுக்கப்பட்ட தரவு வகையின் கூறுகளை சேமிக்கிறது . நாம் ஒரு String array ஐ உருவாக்கினால், அதில் வேறு எதையும் சேமிக்க முடியாது. வரிசை உருவாக்கப்படும் போது தரவு வகை குறிப்பிடப்படுகிறது . இது ஒரு பாதுகாப்பு வைப்புப் பெட்டியிலிருந்து வேறுபடும் இடம் (இதில் ஒரு வாடிக்கையாளர் தான் விரும்புவதைச் சேமிக்க முடியும்).
வரிசையை உருவாக்கும்போது அதன் அளவு குறிப்பிடப்பட வேண்டும் . நீங்கள் அதை பின்னர் குறிப்பிடவோ அல்லது வரிசையை உருவாக்கிய பிறகு அதன் அளவை மாற்றவோ முடியாது .
நாம் ஒரு வரிசையை உருவாக்குகிறோம் என்பது வெளிப்பாட்டின் இருபுறமும் உள்ள சதுர அடைப்புக்குறிகளால் குறிக்கப்படுகிறது. குறிப்பு மாறியின் பெயருக்கு முன்னும் பின்னும் அவற்றைக் குறிப்பிடலாம். எந்த வழியும் வேலை செய்யும்:
String [] birthdays = new String[10];
String birthdays [] = new String[10];
நீங்கள் ஒரு வரிசையில் ஏதாவது ஒன்றை எழுத விரும்பினால், மதிப்பு எழுதப்படும் பெட்டியின் குறியீட்டை நீங்கள் குறிப்பிட வேண்டும். ஒரு வரிசையில் உள்ள பெட்டிகள் 0 முதல் எண்ணப்படும். பூஜ்ஜியத்தில் இருந்து எண்ணுவது நிரலாக்கத்தில் மிகவும் பொதுவான நடைமுறையாகும். நீங்கள் எவ்வளவு விரைவாகப் பழகுகிறீர்களோ, அவ்வளவு சிறந்தது :) இதன் பொருள், நீங்கள் முதல் பெட்டியில் சில மதிப்பை வைக்க விரும்பினால் , இதைச் செய்யுங்கள்:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
}
}
இப்போது ஜனாவின் பிறந்தநாள், ஊழியர்களின் பிறந்தநாள் வரிசையின் முதல் கலத்தில் சேமிக்கப்பட்டுள்ளது: இதே முறையில் நீங்கள் மற்ற மதிப்புகளைச் சேர்க்கலாம்:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
}
}
ரோஸியின் பிறந்தநாளை எட்டாவது பெட்டியுடன் சேர்த்துள்ளோம் என்பதை நினைவில் கொள்ளவும் (பெட்டி எண். 7 எட்டாவது பெட்டி என்பதை நீங்கள் மறந்துவிடவில்லையா?) . மற்ற எல்லா கலங்களையும் நாங்கள் நிரப்பவில்லை என்பதை நீங்கள் பார்க்கலாம். நாம் ஒரு வரிசையில் மதிப்புகளை எழுத வேண்டியதில்லை. அப்படி எந்த தேவையும் இல்லை. நிச்சயமாக, உறுப்புகளை வரிசையாக எழுதுவது, எத்தனை பெட்டிகள் இலவசம் மற்றும் எத்தனை ஆக்கிரமிக்கப்பட்டுள்ளன என்பதைக் கண்காணிப்பதை மிகவும் எளிதாக்குகிறது, மேலும் இது வரிசையை "துளைகள்" கொண்டிருப்பதைத் தடுக்கிறது. பெட்டிகளில் ஒன்றின் உள்ளடக்கத்தைப் பெற விரும்பினால், (பாதுகாப்பு வைப்புப் பெட்டியைப் போலவே) அதன் எண்ணை நீங்கள் அறிந்து கொள்ள வேண்டும். இது இவ்வாறு செய்யப்படுகிறது:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
String rosieBirthday = birthdays[7];
System.out.println(rosieBirthday);
}
}
கன்சோல் வெளியீடு: ரோஸி மில்ஸ், ஜனவரி 3, நாங்கள் ஒரு Stringமாறியை உருவாக்கி, கம்பைலரிடம் சொன்னோம்: " பிறந்தநாள் வரிசையில் குறியீட்டு 7 உடன் உள்ள பெட்டியைக் கண்டுபிடித்து, அதில் உள்ள மதிப்பை ரோஸி பிறந்தநாள்String என்ற மாறிக்கு ஒதுக்கவும் ". அது சரியாகவே செய்தது. வரிசைகளுடன் பணிபுரியும் போது, ஒரு சிறப்புச் சொத்தைப் பயன்படுத்தி அவற்றின் நீளத்தை எளிதாகக் கண்டறியலாம்: நீளம் .
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
int birthdaysLength = birthdays.length;
System.out.println(birthdaysLength);
}
}
கன்சோல் வெளியீடு: 10 குறிப்பு: lengthசொத்து வரிசை அளவை சேமிக்கிறது, நிரம்பிய பெட்டிகளின் எண்ணிக்கை அல்ல. எங்கள் அணிவரிசை 3 மதிப்புகளை மட்டுமே சேமிக்கிறது, ஆனால் அதை உருவாக்கியபோது அதன் அளவை 10 எனக் குறிப்பிட்டோம். இதுவே புலம் lengthதரும் மதிப்பு. இது ஏன் கைக்கு வரும்? சரி, நீங்கள் அனைத்து பிறந்த நாட்களின் பட்டியலைக் காட்ட விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம் (யாரும் மறக்கப்படவில்லை என்பதை சரிபார்க்க). நீங்கள் இதை ஒரு எளிய சுழற்சியில் செய்யலாம்:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[2] = "Jeremiah Leonard, July 12";
birthdays [3] = "Kenny Russo, September 7";
birthdays[4] = "Tommie Barnes, November 9";
birthdays [5] = "Roman Baranov, August 14";
birthdays [6] = "Chanice Andersen, April 1";
birthdays[7] = "Rosie Mills, January 3";
birthdays [8] = "Keenan West, October 19";
birthdays [9] = "Abraham McArthur, May 3";
for (int i = 0; i < birthdays.length; i++) {
System.out.println(birthdays[i]);
}
}
}
சுழற்சியில், நாம் மாறியை அறிவிக்கிறோம் i, இது பூஜ்ஜியத்திற்கு துவக்கப்படுகிறது. ஒவ்வொரு பாஸிலும், எங்கள் அணிவரிசையிலிருந்து குறியீட்டு i உடன் உறுப்பைப் பெற்று அதன் மதிப்பைக் காட்டுவோம். லூப் 10 மறு செய்கைகளைச் செய்யும், மேலும் நான் 0 முதல் 9 ஆக அதிகரிக்கும் - மேலும் எண்கள் நமது அணிவரிசையின் உறுப்புகளின் குறியீடுகளாக இருக்கும்! இதன் விளைவாக, பிறந்தநாள்[0] முதல் பிறந்தநாள்[9] வரை அனைத்து மதிப்புகளையும் காண்பிப்போம், உண்மையில், நீங்கள் ஒரு வரிசையை உருவாக்க மற்றொரு வழி உள்ளது. எடுத்துக்காட்டாக, நீங்கள் intஇது போன்ற ஒரு வரிசையை உருவாக்கலாம்:
public class Main {
public static void main(String[] args) {
int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
}
}
இந்த நுட்பம் "குறுக்குவழி துவக்கம்" என்று அழைக்கப்படுகிறது. இது மிகவும் வசதியானது, ஏனென்றால் நாம் ஒரே நேரத்தில் ஒரு வரிசையை உருவாக்கி அதை மதிப்புகளுடன் நிரப்புகிறோம். வரிசையின் அளவை நாம் வெளிப்படையாகக் குறிப்பிட வேண்டியதில்லை: குறுக்குவழி துவக்கத்துடன், புலம் lengthதானாகவே அமைக்கப்படும்.
public class Main {
public static void main(String[] args) {
int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
System.out.println(numbers.length);
}
}
கன்சோல் வெளியீடு: 9 இப்போது, நினைவகத்தில் அணிவரிசைகள் எவ்வாறு சேமிக்கப்படுகின்றன என்பதைப் பற்றி சிறிது. எங்களிடம் மூன்று பொருள்களின் வரிசை உள்ளது என்று வைத்துக்கொள்வோம் Cat:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat[] cats = new Cat[3];
cats[0] = new Cat("Thomas");
cats[1] = new Cat("Behemoth");
cats[2] = new Cat("Lionel Messi");
}
}
நீங்கள் இங்கே சில விஷயங்களைப் புரிந்து கொள்ள வேண்டும்:
ப்ரிமிடிவ்ஸ் விஷயத்தில், ஒரு வரிசை குறிப்பிட்ட மதிப்புகளின் தொகுப்பை சேமிக்கிறது (எ.கா. intகள்). பொருள்களின் விஷயத்தில், ஒரு வரிசை குறிப்புகளின் தொகுப்பை சேமிக்கிறது .
வரிசை catsமூன்று கூறுகளைக் கொண்டுள்ளது, ஒவ்வொன்றும் ஒரு பொருளைக் குறிக்கும்Cat . குறிப்புகள் ஒவ்வொன்றும் தொடர்புடைய பொருள் சேமிக்கப்பட்டுள்ள நினைவக முகவரியைக் குறிக்கிறது.
வரிசை உறுப்புகள் நினைவகத்தில் ஒரு தொகுதியில் அமைக்கப்பட்டிருக்கும். அவற்றை விரைவாகவும் திறமையாகவும் அணுகுவதற்கு இது செய்யப்படுகிறது.
இவ்வாறு, catsஅனைத்து பொருள்களும் (வரிசை உறுப்புகள்) சேமிக்கப்படும் நினைவகத்தின் தொகுதியைக் குறிக்கிறது. Cats[0]இந்தத் தொகுதிக்குள் ஒரு குறிப்பிட்ட முகவரியைக் குறிப்பிடுகிறது. ஒரு அணியானது பொருட்களை மட்டும் சேமித்து வைப்பதில்லை என்பதை புரிந்து கொள்ள வேண்டியது அவசியம்: அது ஒரு பொருளே. இது சரங்கள் அல்லது எண்களின் வரிசையை மட்டுமல்ல, வரிசைகளின் வரிசைகளையும் உருவாக்க முடியுமா என்ற கேள்விக்கு நம்மை வழிநடத்துகிறது . மற்றும் பதில் ஆம், நம்மால் முடியும்! ஒரு வரிசை மற்ற வரிசைகள் உட்பட எந்த பொருட்களையும் சேமிக்க முடியும். அத்தகைய வரிசை இரு பரிமாணங்கள் என்று அழைக்கப்படுகிறது . நாம் அதை பார்வைக்கு பிரதிநிதித்துவப்படுத்தினால், அது ஒரு சாதாரண அட்டவணையைப் போலவே இருக்கும். ஒவ்வொன்றும் 10 வினாடிகளை சேமிக்கக்கூடிய 3 வரிசைகளின் வரிசையை உருவாக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம் int. இது இப்படி இருக்கும்:
ஒவ்வொரு வரியும் ஒரு வரிசையைக் குறிக்கிறது int. முதல் வரிசையில் 1 முதல் 10 வரையிலான எண்கள் உள்ளன, இரண்டாவது வரிசையில் -1 முதல் -10 வரை, மூன்றாவது - சீரற்ற எண்களின் தொகுப்பு. இந்த வரிசைகள் ஒவ்வொன்றும் எங்கள் இரு பரிமாண வரிசையின் பெட்டிகளில் சேமிக்கப்படும். குறியீட்டில், இரு பரிமாண வரிசையின் துவக்கம் இப்படி இருக்கும்:
public static void main(String[] args) {
Cat[][] cats = new Cat[3][5];
}
எங்கள் இரு பரிமாண வரிசை பூனைகள் ஒவ்வொரு அணியிலும் 5 பெட்டிகளுடன் 3 வரிசைகளை சேமிக்கின்றன . இரண்டாவது வரிசையின் மூன்றாவது பெட்டியில் ஒரு பொருளை வைக்க விரும்பினால் , இதைச் செய்வோம்:
public static void main(String[] args) {
Cat[][] cats = new Cat[3][5];
cats[1][2] = new Cat("Fluffy");
}
[1]இரண்டாவது வரிசையைக் குறிக்கிறது, மேலும் [2]அந்த வரிசையின் மூன்றாவது பெட்டியைக் குறிக்கிறது. இரு பரிமாண வரிசை பல வரிசைகளைக் கொண்டிருப்பதால், அதன் மூலம் மீண்டும் செயல்பட மற்றும் அதன் அனைத்து மதிப்புகளையும் (அல்லது அதன் அனைத்து கூறுகளையும் நிரப்பவும்), நமக்கு ஒரு உள்ளமைக்கப்பட்ட வளையம் தேவை:
for (int i = 0; i < cats.length; i++) {
for (int j = 0; j < cats[i].length; j++) {
System.out.println(cats[i][j]);
}
}
வெளிப்புற சுழற்சியில் (மாறி i), எங்கள் இரு பரிமாண வரிசையில் உள்ள அனைத்து வரிசைகளையும் மீண்டும் செய்கிறோம். உள் சுழற்சியில் (மாறி j), ஒவ்வொரு வரிசையின் அனைத்து கூறுகளையும் கடந்து செல்கிறோம். இதன் விளைவாக, பூனைகள்[0][0] (முதல் வரிசை, முதல் உறுப்பு) முதலில் காட்டப்படும், அதைத் தொடர்ந்து பூனைகள்[0][1] (முதல் வரிசை, இரண்டாவது உறுப்பு). நாங்கள் முதல் வரிசையைக் கடந்த பிறகு, பூனைகள்[1][0] , பூனைகள்[1][1] , பூனைகள்[1][2] போன்றவற்றைக் காண்பிப்போம் . மேலும், இரு பரிமாண வரிசைகளும் ஆதரிக்கின்றன. சுருக்கெழுத்து துவக்கம்:
int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};
numbersசாதாரணமாக, நாம் இரு பரிமாண வரிசையை ஒரு என அறிவிப்போம் int[3][3], ஆனால் இந்த சுருக்கெழுத்து மதிப்புகளை உடனடியாகக் குறிப்பிட உதவுகிறது. உங்களுக்கு இரு பரிமாண வரிசை ஏன் தேவை? பிரபலமான "போர்க்கப்பல்" விளையாட்டை எளிதாக மீண்டும் உருவாக்க நீங்கள் ஒன்றைப் பயன்படுத்தலாம்: "போர்க்கப்பலில்", ஆடுகளத்தின் கட்டமைப்பை எளிதாக விவரிக்க முடியும்: ஒவ்வொன்றும் 10 உறுப்புகள் கொண்ட 10 அணிகளின் இரு பரிமாண வரிசை. நீங்கள் இந்த இரண்டு அணிவரிசைகளை உருவாக்குகிறீர்கள் (ஒன்று உங்களுக்காகவும் ஒன்று உங்கள் எதிரிக்காகவும்)
int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];
சில மதிப்புகளை (எ.கா. எண்கள் அல்லது குறியீடுகள்) பயன்படுத்தி உங்கள் கப்பல்களின் இருப்பிடத்துடன் தொடர்புடைய உறுப்புகளை நிரப்பவும், பின்னர் குறிப்பிட்ட உறுப்புகளுக்கான ஆயங்களை அழைக்கவும்:
போர்க்கப்பல் பலகை1[0][2]!
செல்வி! போர்க்கப்பல் பலகை2[2][4]!
ஹிட்!
போர்க்கப்பல் பலகை2[2][5]!
ஹிட்!
போர்க்கப்பல் பலகை2[2][6]!,
மூழ்கியது!
இது வரிசைகளின் முதல் அறிமுகத்தை முடிக்கிறது, ஆனால் அது அவர்களுடனான எங்கள் தொடர்புக்கான ஆரம்பம் மட்டுமே. பின்வரும் பாடங்களில், அவற்றைப் பயன்படுத்துவதற்கான சுவாரஸ்யமான வழிகளைக் காண்போம், மேலும் இந்தத் தரவுக் கட்டமைப்பில் மிகவும் வசதியாக வேலை செய்ய ஜாவாவின் உள்ளமைக்கப்பட்ட செயல்பாடுகள் என்ன என்பதையும் அறிந்துகொள்வோம் :)
ஒரு வரிசையானது "பெட்டிகளையும்" கொண்டுள்ளது. ஒவ்வொரு பெட்டியிலும் ஏதாவது ஒன்றை (ஒரு உறுப்பு) வைக்கலாம். ஒரு உறுப்பை அணுக, அதன் பெட்டி எண்ணை (இண்டெக்ஸ்) தெரிந்து கொள்ள வேண்டும். ஒரு வரிசை உருவாக்கப்படுவது இதுதான்:
சில மதிப்பை வைக்க விரும்பினால் , இதைச் செய்யுங்கள்:
ஒரு அணியானது பொருட்களை மட்டும் சேமித்து வைப்பதில்லை என்பதை புரிந்து கொள்ள வேண்டியது அவசியம்: அது ஒரு பொருளே. இது சரங்கள் அல்லது எண்களின் வரிசையை மட்டுமல்ல, வரிசைகளின் வரிசைகளையும் உருவாக்க முடியுமா என்ற கேள்விக்கு நம்மை வழிநடத்துகிறது . மற்றும் பதில் ஆம், நம்மால் முடியும்! ஒரு வரிசை மற்ற வரிசைகள் உட்பட எந்த பொருட்களையும் சேமிக்க முடியும். அத்தகைய வரிசை இரு பரிமாணங்கள் என்று அழைக்கப்படுகிறது . நாம் அதை பார்வைக்கு பிரதிநிதித்துவப்படுத்தினால், அது ஒரு சாதாரண அட்டவணையைப் போலவே இருக்கும். ஒவ்வொன்றும் 10 வினாடிகளை சேமிக்கக்கூடிய 3 வரிசைகளின் வரிசையை உருவாக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம் 
"போர்க்கப்பலில்", ஆடுகளத்தின் கட்டமைப்பை எளிதாக விவரிக்க முடியும்: ஒவ்வொன்றும் 10 உறுப்புகள் கொண்ட 10 அணிகளின் இரு பரிமாண வரிசை. நீங்கள் இந்த இரண்டு அணிவரிசைகளை உருவாக்குகிறீர்கள் (ஒன்று உங்களுக்காகவும் ஒன்று உங்கள் எதிரிக்காகவும்)
GO TO FULL VERSION