வரிசைகளுடன் பணிபுரியும் நுணுக்கங்கள்

1. நினைவகத்தில் அணிவரிசைகள்

முந்தைய எடுத்துக்காட்டுகளில், விளக்கப்படங்கள் கொஞ்சம் துல்லியமாக இல்லை.

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

உறுப்புகளின் வரிசைக்கு ஒதுக்கப்பட்ட நினைவகம் 10 intமற்றும் வரிசையின் முகவரியைச்int[] சேமிக்கும் மாறி ஆகியவை பச்சை நிறத்தில் காட்டப்பட்டுள்ளன.int

ஒப்பிடுகையில், intமதிப்பைச் சேமிக்கும் ஒரு சாதாரண மாறி 199நீல நிறத்தில் காட்டப்பட்டுள்ளது.

நினைவகத்தில் சரங்களை சேமிப்பதை இது கொஞ்சம் நினைவூட்டுகிறது, இல்லையா?

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

int[] a = new int[10];
a[2] = 4;
a[7] = 9;
int[] b = a;

a[9] = b[2] + a[7];

வரிசைப் பொருள் இருந்த இடத்திலேயே இருக்கும், மேலும் aமாறிகள் bஅதே முகவரியை (குறிப்பு) அதே பொருளுக்குச் சேமிக்கும். படத்தைப் பாருங்கள்:

2. வரிசைகளுடன் பணிபுரிவது பற்றிய கூடுதல் விவரங்கள்

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

type[] name = new type[number];

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

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

நீங்கள் ஒரு வரிசை பொருளிலிருந்து தனித்தனியாக ஒரு வரிசை மாறியை உருவாக்கலாம்:

type[] name;
name = new type[number];

மேலும் முக்கியமற்ற ஒரு புள்ளி:

எடுத்துக்காட்டுகள்:

int n = 100;
int[] a = new int[n];

int n = 100;
int[] a = new int[n * 2 + 3];

int n = 100;
int[] a = new int[n];
a[n-1] = 2;
a[n-2] = 3;
a[n/5] = a[n-1] + a[n-2]

// a[99] = 2;
// a[98] = 3;
// a[20] = a[99] + a[98];

3. வரிசை நீளம்

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

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];

இப்போது நீங்கள் அத்தகைய வரிசையை வேறு என்ன செய்ய முடியும்? அதில் எத்தனை கூறுகள் உள்ளன என்பதை எப்படி அறிவது?

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

array.length;

இங்கே arrayவரிசை மாறியின் பெயர் மற்றும் lengthஇது வரிசையின் சொத்தின் பெயர். சொத்தின் மதிப்பை lengthமாற்ற முடியாது: lengthசொத்து தன்னை மற்ற மாறிகளுக்கு ஒதுக்கலாம், ஆனால் அதற்கு எதுவும் ஒதுக்க முடியாது (நீங்கள் இதைச் செய்ய முயற்சித்தால், நிரல் வெறுமனே தொகுக்காது).

முந்தைய உதாரணத்தை இப்படி தொடரலாம்:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];
for (int i = 0; i < array.length; i++)
{
   System.out.println(array[i]);
}

4. ஜாவாவில் அணிவரிசைகள் பற்றிய உண்மைகளின் சுருக்கம்

வரிசைகளைப் பற்றி நமக்குத் தெரிந்தவற்றை மீண்டும் பார்ப்போம்:

உண்மை 1. ஒரு வரிசை பல செல்களைக் கொண்டுள்ளது.

உண்மை 2. குறிப்பிட்ட கலத்தை அதன் எண்ணை (அட்டவணை) பயன்படுத்தி அணுகலாம்.

உண்மை 3. அனைத்து செல்கள் ஒரே வகை.

உண்மை 4. அனைத்து கலங்களின் ஆரம்ப மதிப்பு 0 (கலங்கள் எண்களை சேமித்தால்), null(செல்கள் பொருள் குறிப்புகளை சேமித்தால்) அல்லது false(செல்கள் booleanமதிப்புகளை சேமித்தால்). இந்த அத்தியாயத்தில் இயல்புநிலை மதிப்புகள் பற்றி மேலும் அறிந்து கொள்வீர்கள் .

உண்மை 5. String[] list ஒரு மாறியின் அறிவிப்பு மட்டுமே. இது கொள்கலனை (வரிசை பொருள்) உருவாக்காது. மாறியைப் பயன்படுத்த, நீங்கள் முதலில் ஒரு வரிசையை (கன்டெய்னர்) உருவாக்கி அதை மாறிக்கு ஒதுக்க வேண்டும். கீழே உள்ள உதாரணத்தைப் பார்க்கவும்.

உண்மை 6. நாம் ஒரு வரிசைப் பொருளை (கன்டெய்னர்) உருவாக்கும் போது, ​​அது எவ்வளவு பெரியது, அதாவது எத்தனை செல்களைக் கொண்டுள்ளது என்பதைக் குறிப்பிட வேண்டும். இது போன்ற ஒரு அறிக்கையுடன் செய்யப்படுகிறது: new TypeName[n];

உண்மை 7. ஒரு வரிசையின் நீளத்தை சொத்தைப் பயன்படுத்தி கண்டறியலாம் .length.

உண்மை 8. ஒரு வரிசையை உருவாக்கிய பிறகு, அதன் உறுப்புகளின் வகையை அல்லது அது சேமிக்கும் உறுப்புகளின் எண்ணிக்கையை மாற்ற முடியாது.

String s;
String[] list;

list = new String[10];
int n = list.length;

list = new String[0];

list = null;
System.out.println(list[1]);

list = new String[10];
System.out.println(list[10]);