வரிசைகள் வகுப்பு, பகுதி 2

1.Arrays.fill()

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

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

அல்லது நீங்கள் முறையை அழைக்கலாம் Arrays.fill(), இது சரியாக அதே காரியத்தைச் செய்கிறது: இது அனுப்பப்பட்ட மதிப்புடன் கடந்து சென்ற வரிசையை நிரப்புகிறது. இது எப்படி இருக்கிறது என்பது இங்கே:

Arrays.fill(name, value)

மேலே உள்ள எடுத்துக்காட்டில் உள்ள குறியீட்டை இன்னும் கொஞ்சம் சுருக்கமாகவும் தெளிவாகவும் செய்யலாம்:

int[] x = new int[100];
Arrays.fill(x, 999);

Arrays.fill()முழு வரிசையையும் அல்ல, அதன் ஒரு பகுதியை சில மதிப்புடன் நிரப்பவும் நீங்கள் முறையைப் பயன்படுத்தலாம் :

Arrays.fill(name, first, last, value)

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

உதாரணமாக:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

இந்த Arrays.fill()முறை ஒரு பரிமாண வரிசைகளுடன் மட்டுமே செயல்படுகிறது. நீங்கள் முறைக்கு இரு பரிமாண வரிசையை அனுப்பினால், அது ஒரு பரிமாணமாக கருதப்படும், அடுத்தடுத்த அனைத்து விளைவுகளுடன்.

2.Arrays.copyOf()

உங்களுக்கு ஏற்கனவே தெரியும், வரிசையை உருவாக்கிய பிறகு அதன் அளவை மாற்ற முடியாது.

ஆனால் நீங்கள் உண்மையிலேயே விரும்பினால் என்ன செய்வது?

சரி, நீங்கள் உண்மையிலேயே விரும்பினால், உங்களால் முடியும்!

• விரும்பிய நீளத்தின் புதிய வரிசையை உருவாக்கவும்
• முதல் வரிசையிலிருந்து அனைத்து கூறுகளையும் அதில் நகலெடுக்கவும்.

மூலம், இந்த Arrays.copyOf()முறை சரியாக என்ன செய்கிறது. இதை அழைப்பது போல் தெரிகிறது:

Type[] name2 = Arrays.copyOf(name, length);

இந்த முறை ஏற்கனவே உள்ள வரிசையை மாற்றாது , மாறாக புதிய வரிசையை உருவாக்கி , பழைய அணிவரிசையின் கூறுகளை அதில் நகலெடுக்கிறது.

உறுப்புகள் பொருந்தவில்லை என்றால் (நீளம் ஏற்கனவே இருக்கும் வரிசையின் நீளத்தை விட குறைவாக உள்ளது ), கூடுதல் மதிப்புகள் புறக்கணிக்கப்படும்.

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

உதாரணமாக:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

நீங்கள் நீளம் 10 வரிசையிலிருந்து 5 நீளத்தின் வரிசையைப் பெற விரும்பினால், ஆனால் அது முதல் 5 ஐ விட கடைசி 5 கூறுகளைக் கொண்டிருக்க வேண்டுமா?

இந்த வழக்கில், வகுப்பின் மற்றொரு முறை Arraysகைக்குள் வரும் - தி Arrays.copyOfRange(). நாம் அழைக்கும் போது அது எப்படி இருக்கும் என்பது இங்கே:

Type[] name2 = Arrays.copyOfRange(name, first, last);

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

உதாரணமாக:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

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

• ஒரு வரிசையை வரிசைப்படுத்துதல்
• ஒரு அணிவரிசையின் குறைந்தபட்ச (அல்லது அதிகபட்ச) உறுப்பைக் கண்டறிதல்
• ஒரு வரிசையில் ஒரு தனிமத்தின் குறியீட்டை தீர்மானித்தல் (ஒரு வரிசையில் ஒரு உறுப்பைக் கண்டறிதல்)

அதனால்தான் ஜாவாவின் படைப்பாளிகள் இந்த sort()முறையை வகுப்பில் சேர்த்துள்ளனர் Arrays. இதை அழைப்பது போல் தெரிகிறது:

Arrays.sort(name);

இந்த முறை அனுப்பப்பட்ட வரிசையை ஏறுவரிசையில் வரிசைப்படுத்துகிறது.

உதாரணமாக:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);

String str = Arrays.toString(x);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

சிறந்தது, இல்லையா? நீங்கள் ஒரு முறையை அழைத்தீர்கள், இப்போது உங்களிடம் வரிசைப்படுத்தப்பட்ட வரிசை உள்ளது. அழகு.

மூலம், முழு வரிசையை மட்டுமல்ல, அதன் ஒரு பகுதியையும் வரிசைப்படுத்த இந்த முறையைப் பயன்படுத்தலாம். இதை அழைப்பது போல் தெரிகிறது:

Arrays.sort(name, first, last);

முதலில் மற்றும் கடைசியாக இருக்கும் முதல் மற்றும் கடைசி கலங்களின் குறியீடுகள் வரிசையைத் தொட வேண்டும்.

உதாரணமாக:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

வரிசைகளை வரிசைப்படுத்த, ஜாவா வேகமான வரிசையாக்க வழிமுறையைப் பயன்படுத்துகிறது - QuickSort . அதன் கணக்கீட்டு சிக்கலானது வரிசையின் அளவைப் பொறுத்தது மற்றும் N log(N) சூத்திரத்தைப் பயன்படுத்தி கணக்கிடப்படுகிறது.

1000 உறுப்புகளின் வரிசையை வரிசைப்படுத்துவது வரிசை உறுப்புகளின் 3,000 ஒப்பீடுகளை உள்ளடக்கும். ஒரு மில்லியன் தனிமங்களின் வரிசையை வரிசைப்படுத்துவது சுமார் 6 மில்லியன் ஒப்பீடுகளை உள்ளடக்கும்.

5.Arrays.binarySearch()

சரி, வகுப்பின் மிகவும் சுவாரஸ்யமான முறைகளில் கடைசியாக Arraysகொடுக்கப்பட்ட மதிப்பை ஒரு வரிசையில் தேட முடியும். இது சாதாரண தேடல் அல்ல - இது அன்பான பைனரி தேடல் . இது பின்வருமாறு கொதிக்கிறது:

• முதலில், வரிசை வரிசைப்படுத்தப்படுகிறது.
• பின்னர் வரிசையின் நடுத்தர உறுப்பு நாம் தேடும் ஒன்றோடு ஒப்பிடப்படுகிறது.
• நடு உறுப்பை விட உறுப்பு அதிகமாக இருந்தால், வரிசையின் வலது பாதியில் தேடல் தொடர்கிறது.
• நாம் தேடும் உறுப்பு நடுத்தர உறுப்பை விட குறைவாக இருந்தால், தேடல் வரிசையின் இடது பாதியில் தொடர்கிறது.

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

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

இதை அழைப்பது போல் தெரிகிறது:

int index = Arrays.binarySearch(name, value);

nameஏற்கனவே வரிசைப்படுத்தப்பட்ட (உதாரணமாக, முறையைப் பயன்படுத்தி) அனுப்ப வேண்டிய வரிசையின் பெயர் எங்கே Arrays.sort(). மற்றும் valueநாம் வரிசையில் தேடும் உறுப்பு. முறையின் மூலம் கிடைக்கும் முடிவு, விரும்பிய வரிசை உறுப்பின் குறியீடாகும் .

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

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

வரிசையில் தேடப்படும் உறுப்புக்கான பல நிகழ்வுகள் இருந்தால், அல்காரிதம் அவற்றில் ஒன்றின் குறியீட்டை வெறுமனே திருப்பித் தரும் (இது முதல் அல்லது நேர்மாறாக - இவற்றில் கடைசியாக இருக்கும் என்பதற்கு எந்த உத்தரவாதமும் இல்லை . நகல் கூறுகள்)."

அணிவரிசையில் உறுப்பு காணப்படவில்லை என்றால் , குறியீட்டு எதிர்மறையாக இருக்கும்.

Arrays6. வகுப்பில் உள்ள ஆரக்கிள் ஆவணத்திற்கான இணைப்பு

Arraysநீங்கள் மிகவும் ஆர்வமாக இருந்தால், வகுப்பு மற்றும் அதன் அனைத்து முறைகள் பற்றிய அனைத்தையும் அதிகாரப்பூர்வ ஆவணத்தில் படிக்கலாம் href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">ஆரக்கிள் இணையதளத்தில்.

Arrays.mismatch()உதாரணமாக, நீங்கள் மற்றும் முறைகள் பற்றி படிக்கலாம் Arrays.compare(). ஒருவேளை நீங்கள் எப்படியாவது அவை பயனுள்ளதாக இருக்கும்.

மேலும் முறைகளின் எண்ணிக்கையால் குழப்பமடைய வேண்டாம். ஒவ்வொரு முறையிலும் 5-10 வகைகள் உள்ளன, அவை அவற்றின் அளவுரு வகைகளில் மட்டுமே வேறுபடுகின்றன.