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

“ரிஷி, அர்ரேஸ் வகுப்பின் மற்ற முறைகளைப் பற்றி அறிய ஆவலுடன் காத்திருக்கிறேன்.

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

"ம்..."

"சும்மா கிண்டல். ஒருவகையில். நிச்சயமாக, நான் எல்லாவற்றையும் சிறப்பாக விளக்குவேன், ஆனால் ஏதாவது வந்தால் - நல்ல மந்திரவாதியை நினைவில் வையுங்கள். நான் இன்றைய பாடத்தை முறையுடன் தொடங்குகிறேன் 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);

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

Arrays.copyOf()

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

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

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

"இது இன்னும் சாத்தியமில்லை!

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

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

"இந்த முறை செய்யும் இரண்டு விஷயங்கள் இதுதான் 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);

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

Arrays.sort()

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

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

"நன்றாக செயல்படும் வரிசையாக்க வழிமுறைகள், எழுதுவது அவ்வளவு எளிதானது அல்ல என்று நான் சொல்ல வேண்டும். இன்னும் துல்லியமாக, இது ஒரு நிலையான பணியாகும், மேலும் ஒரு மாணவராக, சில சமயங்களில் வரிசையாக்க அல்காரிதம்களை எழுதுவதைப் பயிற்சி செய்வது உங்களைப் பாதிக்காது. ஆனால் வேலையில், அது சக்கரத்தை மீண்டும் கண்டுபிடிப்பதில் உங்கள் நேரத்தை வீணடிக்காமல் இருப்பது நல்லது. ஜாவாவின் படைப்பாளிகள் வகுப்பில் இந்த 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);

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

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

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

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

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

" உறுப்புகளின் எண்ணிக்கையை நீங்கள் கருத்தில் கொள்ளும்போது அதிக ஒப்பீடுகள் இல்லை!"

"அதைத்தான் நான் சொல்கிறேன். QuickSort அல்காரிதம் மிகவும் திறமையானது.

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

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

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

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

"இந்த வழக்கில், அல்காரிதம் எதிர்மறை குறியீட்டை வழங்கும் .

ஆவணப்படுத்தல்

"எல்லாம் தெளிவாக உள்ளது ரிஷி! இது மிகவும் சுவாரஸ்யமாக இருந்தது."

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

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

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