अॅरे वर्ग, भाग २

१.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()

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

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

यामुळेच 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);

"[-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]"

अ‍ॅरे क्रमवारी लावण्यासाठी, Java सर्वात जलद क्रमवारी लावणारा अल्गोरिदम वापरते — QuickSort . त्याची संगणकीय जटिलता अॅरेच्या आकारावर अवलंबून असते आणि N log(N) सूत्र वापरून गणना केली जाते.

1000 घटकांच्या अॅरेची क्रमवारी लावताना अॅरे घटकांच्या सुमारे 3,000 तुलनांचा समावेश असेल. एक दशलक्ष घटकांच्या अॅरेची क्रमवारी लावताना सुमारे 6 दशलक्ष तुलनांचा समावेश असेल.

५.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अधिकृत दस्तऐवजात वर्ग आणि त्याच्या सर्व पद्धतींबद्दल सर्व काही वाचू शकता a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">Oracle वेबसाइटवर.

उदाहरणार्थ, आपण Arrays.mismatch()आणि Arrays.compare()पद्धतींबद्दल वाचू शकता. कदाचित तुम्हाला ते कसे तरी उपयुक्त वाटतील.

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