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

1. Stringவரிசை

Stringவரிசைகள் பற்றிய சுருக்கமான கண்ணோட்டத்தை உங்களுக்கு வழங்க விரும்புகிறேன் .

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

Scanner console = new Scanner(System.in);
String[] array = new String[10];
for (int i = 0; i < 10; i++)
{
   array[i] = console.nextLine();
}
for (int i = 9; i >= 0; i--)
{
   System.out.println(array[i]);
}

குறியீடு மாறவில்லை! வரிசையை உருவாக்கும் போது மட்டுமே நாங்கள் intமாற்ற வேண்டியிருந்தது . Stringசரி, மற்றும் விசைப்பலகையில் இருந்து சரத்தை படிக்கும் போது, ​​நாங்கள் முறையையும் nextInt()மாற்றினோம் nextLine().

2. Stringநினைவகத்தில் வரிசை

மேலும் ஒரு பயனுள்ள உண்மை. 3 படங்களைக் கருத்தில் கொள்வோம்:

படம் 1.String நினைவகத்தில் ஒரு பொருள் எவ்வாறு அமைக்கப்பட்டிருக்கிறது:

இந்தப் படம் முந்தைய பாடங்களிலிருந்து எடுக்கப்பட்டது.

சரத்தின் உரை நேரடியாக மாறியில் சேமிக்கப்படவில்லை என்பதை நினைவில் கொள்க: அதற்கு ஒரு தனி நினைவகம் ஒதுக்கப்பட்டுள்ளது. ஒரு Stringமாறியானது உரையைச் சேமிக்கும் ஒரு பொருளின் முகவரியை (குறிப்பு) சேமிக்கிறது.

படம் 2. நினைவகத்தில் ஒரு முழு எண் வரிசை எவ்வாறு அமைக்கப்பட்டிருக்கிறது:

இந்தப் படமும் தெரிந்ததே.

படம் 3. நினைவகத்தில் ஒரு சரம் அணிவரிசை எவ்வாறு அமைக்கப்பட்டிருக்கிறது:

இடதுபுறத்தில் ஒரு வரிசை மாறியைக் காண்கிறோம், அதன் வகை String[](இது ஒரு வரிசை பொருளின் முகவரியைச் சேமிக்கிறது).

நடுவில், நமக்கு Stringவரிசை பொருள் உள்ளது.

வலதுபுறத்தில் சில உரைகளை சேமிக்கும் சரம் பொருள்கள் உள்ளன.

வரிசையின் செல்கள் Stringசரங்களைச் சேமித்து வைக்காது (ஸ்ட்ரிங் பொருள்களின் உரை). அதற்கு பதிலாக, அவர்கள் தங்கள் முகவரிகளை (அவர்களுக்கான குறிப்புகள்) சேமித்து வைக்கிறார்கள். Stringமாறிகள் சரம் பொருள்களின் முகவரிகளை (உரை சேமிக்கப்படும் இடத்தில்) சேமிக்கும் அதே வழியில் .

வரிசை செல்களை ஒப்பிடும்போது இதைக் கருத்தில் கொள்ளுங்கள் :

String[] array = new String[10];

array[1] = "Hello";
array[2] = array[1];
array[3] = new String("Hello");
// Compare
array[1] == array[2];
array[1] == array[3];
array[1].equals(array[3]);
array[1].equalsIgnoreCase(array[3]);

3. ஜாவாவில் வேகமான வரிசை துவக்கம்

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

அவர்கள் செய்த முதல் விஷயம், வரிசை துவக்கத்தை எளிதாக்குவது, இதன் மூலம் நீங்கள் ஒரு வரிசையின் ஆரம்ப மதிப்புகளை வழங்குவீர்கள்.

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

int[] months = new int[12];
months[0] = 31; // January
months[1] = 28; // February
months[2] = 31; // March
months[3] = 30; // April
months[4] = 31; // May
months[5] = 30; // June
months[6] = 31; // July
months[7] = 31; // August
months[8] = 30; // September
months[9] = 31; // October
months[10] = 30; // November
months[11] = 31; // December

ஆனால் ஜாவாவின் படைப்பாளர்களுக்கு நன்றி, இதை இன்னும் சுருக்கமாக எழுத ஒரு வழி உள்ளது:

// Lengths of months of the year
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

காற்புள்ளிகளால் பிரிக்கப்பட்ட வரிசையின் அனைத்து மதிப்புகளையும் நீங்கள் பட்டியலிடலாம்!

வசதியானது, இல்லையா? ஆனால் அதெல்லாம் இல்லை.

அது நிகழும்போது, ​​வரிசையின் மதிப்புகளின் வகையின் அடிப்படையில் தொகுப்பி கண்டெய்னரின் வகையை (வரிசை பொருள்) தீர்மானிக்க முடியும். மற்றும் வரிசையின் நீளத்தை தீர்மானிக்க, சுருள் பிரேஸ்களில் எழுதப்பட்ட உறுப்புகளின் எண்ணிக்கையை எண்ணுவது அற்பமானது.

அதாவது இந்தக் குறியீட்டை இன்னும் சுருக்கமாக எழுதலாம்:

// Lengths of months of the year
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

அழகு ஒரு விஷயம், இல்லையா? 🙂

இது "வேகமான வரிசை துவக்கம்" என்று அழைக்கப்படுகிறது. மூலம், இது மற்ற வகைகளுக்கு வேலை செய்கிறது int...

// Names of months of the year
String[] months = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November ", "December"};