அணிவரிசைகள் - ஒரு உதவி வகுப்பு

"அமிகோ, நிரலாக்கத்தில் அணிவரிசைகள் எவ்வளவு பயனுள்ளவை என்பதை நீங்கள் இப்போது உணர்ந்திருப்பீர்கள் என்று நம்புகிறேன்?"

"நிச்சயமாக, ரிஷி! நான் ஏற்கனவே ஒன்றுக்கு மேற்பட்ட பணிகளைத் தீர்த்துவிட்டேன்."

"உங்கள் பணிகளில் மீண்டும் மீண்டும் செயல்கள் உள்ளதா? நீங்கள் மீண்டும் மீண்டும் செய்த மாதிரி."

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

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

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

Arrays"ஜாவாவின் படைப்பாளிகள் இதைப் பற்றி யோசித்து, சிறப்பு வகுப்பை (அதன் முழுப்பெயர் ) உருவாக்கினர் java.util.Arrays, அதில் மிகவும் பிரபலமான வரிசை தொடர்பான செயல்களைச் சேர்த்தனர்."

"ஹ்ம்ம்... ரொம்ப சுவாரஸ்யமா இருக்கு. அதுக்கப்புறம் என்ன இருக்கு?

"ஒவ்வொரு சந்தர்ப்பத்திற்கும் இது நிறைய முறைகளைக் கொண்டுள்ளது, ஆனால் முதலில் அவற்றில் 10-ஐ மட்டுமே கருத்தில் கொள்வோம் - எளிமையான மற்றும் பெரும்பாலும் பயன்படுத்தப்படும்.

Arrays.toString()

"நாம் பார்க்கப்போகும் முதல் முறை Arrays.toString(). ஆனால் முதலில், ஒரு சிறிய பின்னணி.

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

String str = name.toString();

" nameவரிசை மாறியின் பெயர் எங்கே, மற்றும் strவரிசையின் சரம் பிரதிநிதித்துவத்தை சேமிக்கும் மாறியின் பெயர். அமிகோ, நீங்கள் முறையைப் பயன்படுத்தி திரையில் ஒரு வரிசையை அச்சிட முயற்சித்தீர்களா ?System.out.println(name)

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

"பெரும்பாலும் நீங்கள் இதைப் போன்ற ஒன்றைப் பார்த்திருக்கலாம்:

I@37afeb11

"முதல் எழுத்து Iஎன்பது அது ஒரு intவரிசை என்றும், அதற்குப் பின் வரும் குறியீடுகள்@ நினைவகத்தில் உள்ள ஒரு பொருளின் முகவரி என்றும் அர்த்தம். இதை நினைவகத்தில் உள்ள வரிசையின் முகவரி என்று நீங்கள் நினைக்கலாம். ஒருபுறம், இது துல்லியமாக இல் சேமிக்கப்பட்ட தகவல். வரிசை மாறி, ஆனால் மறுபுறம், நீங்கள் வேறு ஏதாவது எதிர்பார்த்தீர்கள், இல்லையா?"

"சரியாக! வரிசையில் உள்ள மதிப்புகளைப் பார்க்க நான் திட்டமிட்டிருந்தேன். இதுதான் நான் எதிர்பார்த்த கடைசி விஷயம்."

"அதனால்தான் அவர்கள் ஒரு Arrays.toString()முறையைக் கொண்டு வந்தனர் - ஒரு வரிசையின் மதிப்புகளைக் காட்ட. நாங்கள் அதை இப்படி அழைக்கிறோம்:

String str = Arrays.toString(name);

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

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

int[] array = {};
String str = Arrays.toString(array);

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

Arrays.deepToString()

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

[I@37afeb11, I@37afeb21, I@37afeb31]

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

"அப்படியானால் என்ன செய்வது? இரு பரிமாண வரிசையை எவ்வாறு சரியாகக் காட்டுவது?"

"ஜாவாவின் படைப்பாளிகளும் இதை எதிர்பார்த்தனர். இந்த நோக்கத்திற்காக, Arraysவகுப்பில் மற்றொரு சிறப்பு முறை உள்ளது - deepToString(). இதை அழைப்பது போல் தெரிகிறது:

String str = Arrays.deepToString(name);

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

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

int[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

Arrays.equals()

"திரையில் வரிசைகளை எப்படிக் காட்டுவது என்று நாங்கள் கண்டுபிடித்தோம். வரிசைகளை ஒப்பிடுவது பற்றி என்ன? சரங்களை ஒப்பிடுவதற்கு நாம் என்ன முறைகளைப் பயன்படுத்தலாம் என்பது உங்களுக்கு நினைவிருக்கிறதா?"

"நான் வழக்கமாக இந்த equalsமுறையைப் பயன்படுத்துகிறேன்!

"ஆம், equals, மேலும் equalsIgnoreCase(இது பெரிய எழுத்து மற்றும் சிறிய எழுத்துகளைப் பொருட்படுத்தாமல் சரங்களை ஒப்பிடுகிறது).

"நல்ல செய்தி: நீங்கள் வரிசைகளுக்கான முறையைப் பயன்படுத்தலாம் equals. மோசமான செய்தி: இது வரிசைகளின் உள்ளடக்கங்களை ஒப்பிடாது. equalsவரிசைகளின் முறை ஆபரேட்டரைப் போலவே செய்கிறது ==- இது குறிப்புகளை ஒப்பிடுகிறது.

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

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

"அப்படியானால் நாம் என்ன செய்வது? வரிசைகளை அவற்றின் உள்ளடக்கத்தின் அடிப்படையில் எவ்வாறு ஒப்பிடுவது?"

"மீண்டும் Arraysவகுப்பு எங்கள் மீட்புக்கு வருகிறது. இன்னும் குறிப்பாக, அதன் Arrays.equals()முறை. இதை நாம் இப்படித்தான் அழைக்கிறோம்:

Arrays.equals(name1, name2)

true" வரிசைகள் சம நீளம் மற்றும் அவற்றின் உறுப்புகள் சமமாக இருந்தால் முறை திரும்பும் . இல்லையெனில், அது திரும்பும் false.

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

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

Arrays.deepEquals()

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

"இவ்வாறு, பல பரிமாண வரிசைகளை ( ) சரியாக ஒப்பிட்டுப் பார்க்க n = 1, 2, 3,... , அவர்கள் ஒரு முறையைக் கொண்டு வந்தனர் Arrays.deepEquals(). அதை அழைப்பது இப்படி இருக்கும்:

Arrays.deepEquals(name1, name2)

true" வரிசைகள் சம நீளம் மற்றும் அவற்றின் கூறுகள் சமமாக இருந்தால் முறை திரும்பும் . இல்லையெனில், அது திரும்பும்false. அணிவரிசையில் உள்ள உறுப்புகளும் அணிவரிசைகளாக இருந்தால், Arrays.deepEquals()அவற்றை ஒப்பிடுவதற்கு முறை பயன்படுத்தப்படுகிறது, மற்றும் பல.

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

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.deepEquals(x1, x2);

"நன்றி, ரிஷி! எதிர்காலத்தில் என் வாழ்க்கையை எளிதாகவும் மகிழ்ச்சியாகவும் மாற்ற இந்தப் பாடம் எனக்குத் தேவைப்பட்டது. இப்போது நான் அரேய்ஸ் வகுப்பின் முறைகளைப் பயன்படுத்தி எனது நிரல்களை இன்னும் வேகமாக எழுதுவேன்.

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