"ऋषी, मी अ‍ॅरे क्लासच्या उर्वरित पद्धतींबद्दल जाणून घेण्यास उत्सुक आहे.

"शिकण्याचा एवढा आवेश तुमच्या जुन्या शिक्षकांना खूश करू शकत नाही! पण, जर तुम्हाला खरोखर सर्वकाही शोधायचे असेल, तर Google नावाचा एक दयाळू विझार्ड तुम्हाला रात्रंदिवस मदत करेल."

"अं..."

"फक्त गंमत करत आहे. एक प्रकारचा. नक्कीच, मी सर्वकाही चांगले समजावून सांगेन, परंतु जर काही समोर आले तर - चांगल्या विझार्डला लक्षात ठेवा. मी आजचा धडा या पद्धतीसह सुरू करेन 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)

" पहिल्या आणि शेवटच्या सेलचे निर्देशांक कुठे भरायचे आहेत.

" Java च्या चांगल्या (किंवा वाईट) जुन्या परंपरेनुसार, लक्षात ठेवा की शेवटचा घटक श्रेणीमध्ये समाविष्ट केलेला नाही.

उदाहरण:

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

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


String str = Arrays.toString(x);
आम्ही सेल x[3], x[4], x[5], आणि x[6]मूल्यासह भरत आहोत 999. अॅरेचे सेल शून्यापासून सुरू होऊन क्रमांकित केले जातात!

व्हेरिएबलमध्ये strमूल्य असते
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

" Arrays.fill()पद्धत फक्त एक-आयामी अॅरेसह कार्य करते. जर तुम्ही या पद्धतीला द्वि-आयामी अॅरे पास केले, तर ती एक-आयामी मानली जाईल, त्यानंतरच्या सर्व परिणामांसह.

Java university

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

व्हेरिएबलमध्ये str2मूल्य असते व्हेरिएबलमध्ये मूल्य असते
"[1, 2, 3, 4, 5]"

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

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

व्हेरिएबलमध्ये str2मूल्य असते व्हेरिएबलमध्ये मूल्य असते
"[16, 17, 18, 19, 20]"

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

Arrays.sort()

"आणि शेवटी, मी सर्वात... mmm... शेवटची आनंददायी पद्धत सोडली: क्रमवारी . प्रोग्रामिंगमध्ये अॅरे बर्‍याचदा क्रमवारी लावल्या जातात. अॅरेसह काम करताना येथे शीर्ष 3 सर्वात लोकप्रिय क्रिया आहेत:

  • अॅरेची क्रमवारी लावत आहे
  • अॅरेचा किमान (किंवा कमाल) घटक शोधणे
  • अॅरेमधील घटकाची अनुक्रमणिका निश्चित करणे (अ‍ॅरेमधील घटक शोधणे)

"चांगली कामगिरी करणारे सॉर्टिंग अल्गोरिदम, मी म्हणायलाच पाहिजे, लिहिणे इतके सोपे नाही. अधिक तंतोतंत, हे एक मानक कार्य आहे, आणि एक विद्यार्थी म्हणून, काहीवेळा वर्गीकरण अल्गोरिदम लिहिण्याचा सराव करणे तुम्हाला त्रास देणार नाही. परंतु कामावर, ते आहे. चाक पुन्हा शोधण्यात तुमचा वेळ वाया न घालवणे चांगले. Java च्या निर्मात्यांनी ही 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);

व्हेरिएबलमध्ये strमूल्य असते
"[-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);

व्हेरिएबलमध्ये strमूल्य असते
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

"अ‍ॅरे क्रमवारी लावण्यासाठी, Java सर्वात जलद क्रमवारी लावणारे अल्गोरिदम वापरते — 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);
 xआहे
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(निर्देशांक 0आणि 2स्वीकार्य देखील आहेत)
8
-7

"इच्छित घटक अॅरेमध्ये अनेक वेळा दिसल्यास काय ?"

"हा एक वैध प्रश्न आहे, अमिगो. या प्रकरणात, अल्गोरिदम त्यापैकी एकाची अनुक्रमणिका परत करेल (त्याची कोणतीही हमी नाही, म्हणा, ती पहिली असेल किंवा उलट - या डुप्लिकेट घटकांपैकी अगदी शेवटची असेल) ."

"अरेमध्ये इच्छित घटक अजिबात नसल्यास काय?"

"या प्रकरणात, अल्गोरिदम नकारात्मक निर्देशांक देईल .

दस्तऐवजीकरण

"सगळं स्पष्ट आहे, ऋषी! हे खूप इंटरेस्टिंग होतं."

"जर तुम्हाला हे खरोखरच मनोरंजक वाटले असेल, तर तुमच्या आरामात वर्गाचे अधिकृत दस्तऐवजीकरण आणि ओरॅकल वेबसाइटवरीलArrays त्याच्या पद्धती पहा .

"तुम्ही जवळून पाहू शकता, उदाहरणार्थ, Arrays.mismatch()आणि Arrays.compare()पद्धती. तुम्ही बहुधा त्यांचा चांगला उपयोग करू शकाल.

"आणि पद्धतींच्या संख्येमुळे गोंधळून जाऊ नका. प्रत्येक पद्धतीमध्ये 5-10 रूपे आहेत, जे फक्त त्यांच्या पॅरामीटर प्रकारांमध्ये भिन्न आहेत."