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

1. Arraysவர்க்கம்

நாம் முன்பு குறிப்பிட்டது போல, வரிசைகள் மிகவும் பயனுள்ளவை மற்றும் நிரலாக்கத்தில் அடிக்கடி பயன்படுத்தப்படுகின்றன.

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

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

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

2.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);

"[1, 2, 3]"

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

"[]"

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

"[Hi, How's, life?]"

3.Arrays.deepToString()

ஆனால் நீங்கள் இரு பரிமாண வரிசையை ஒரு சரம் (அதைக் காட்ட) முறைக்கு மாற்ற முயற்சித்தால் using the Arrays.toString(), உங்களுக்குத் தெரிந்த ஒன்றைக் காண்பீர்கள்:

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

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

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

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

String str = Arrays.deepToString(name);

இந்த முறையானது இரு பரிமாண, ஒரு பரிமாண, முப்பரிமாண அல்லது பொதுவாக எந்தப் பரிமாணத்தையும் கொண்ட வரிசைகளை அனுப்பலாம், மேலும் இது எப்போதும் வரிசையின் கூறுகளைக் காண்பிக்கும்.
குறிப்பு: இந்த Arrays.deepToString()முறை ஒரு பரிமாண வரிசைகளுடன் செயல்படாது (உதாரணமாக, int[]).

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

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

"[1, 2, 3]"

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

"[[1, 1], [2, 2], [3, 3]]"

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

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

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

சரங்களை ஒப்பிட, எங்களிடம் equalsமற்றும் equalsIgnoreCaseமுறைகள் உள்ளன, ஆனால் வரிசைகள் என்ன முறைகளைக் கொண்டுள்ளன?

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

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

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = 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);

5.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);