Arrays դաս, մաս 2

1. Arrays.fill() մեթոդը

Շատ հաճախ Java ծրագրավորողների ապրելակերպում առկա է մի խնդիր՝ զանգվածը լրացնել նույն արժեքներով։ Իհարկե, կարելի է գրել կրկնություն և կրկնության ընթացքում յուրաքանչյուր բջիջին որոշակի արժեք վերագրել:

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

Կամ կարելի է պարզապես կանչել Arrays.fill() մեթոդը, որը անում է նույնը՝ լրացնում է փոխանցված զանգվածը փոխանցված արժեքով։ Հենց այդպես է գալիս՝

Arrays.fill(անունը, արժեքը)

Եվ վերը նշված օրինակը կարող է ավելի հակիրճ և հասկանալի դարձնել՝

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

Դրանից բացի, Arrays.fill() մեթոդով հնարավոր է լրացնել որոշակի արժեքով ոչ բոլոր զանգվածը, այլ նրա մի մասը՝

Arrays.fill(անունը, առաջինը, վերջինը, արժեքը)

Որտեղ առաջինն ու վերջինը՝ դա առաջին և վերջին բջիջների համարներն են, որոնք պետք է լրացնել:

Օրինակ՝

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() մեթոդը։ Ահա թե ինչպես կարող է տեսք ունենալ նրա կանչ՝

տիպ[] անունը2 = Arrays.copyOf(անունը, երկարություն);

Այս մեթոդը չի փոխում գոյություն ունեցող զանգվածը, այլ ստեղծում է նոր զանգված և տալիս է դրան հին զանգվածի տարրերը։

Եթե տարրերը չեն տեղավորվում (երկարությունը փոքր է գոյություն ունեցող զանգվածի երկարությունից), ապա ավելցուկային արժեքները անտեսվում են։

Եթե նոր զանգվածի երկարությունը ավելի շատ է հինից, բջիջները լրացվում են զրոներով։

Օրինակ՝

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() մեթոդը

Իսկ ինչ անել, եթե ցանկանում եք ստանալ 5 չափանիշ ունեցող զանգված 10 չափանիշ ունեցող զանգվածից, բայց այն պետք է պարունակի ոչ առաջին 5 տարրերը, այլ վերջին 5 թվականները?

Հենց այս դեպքում օգտակար կլինի Arrays դասի մեկ այլ մեթոդ՝ Arrays.copyOfRange() մեթոդը։ Ահա թե ինչպես է տեսք ունենում նրա կանչը՝

տիպ[] անունը2 = Arrays.copyOfRange(անունը, առաջինը, վերջինը);

Այս մեթոդը նույնպես ստեղծում է նոր զանգված, բայց այն լրացնում է տվյալներով, որոնք գտնվում են սկսածի փոխանակման տեղում։ Որտեղ առաջինն ու վերջինը՝ դա առաջին և վերջին բջիջների համարներն են, որոնք պետք է լինեն նոր զանգվածում:

Օրինակ՝

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-ի մշակողները Arrays դասում ներառել են sort() մեթոդը։ Ահա թե ինչպես է նրա կանչը՝

Arrays.sort(անունը);

Այս մեթոդը դասակարգում է փոխանցված զանգվածը աճումով։

Օրինակ՝

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(անունը, առաջինը, վերջինը);

Որտեղ առաջինը և վերջինը — դա առաջին և վերջին բջիջների համարներն են, որոնք պետք է դասակարգել։

Օրինակ՝

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 միլիոն համեմատություններ։

5. Arrays.binarySearch() մեթոդը

Եվ ամենահետաքրքիրներից մեկը՝ Arrays դասի մեթոդներից վերջինը, կարող է որոնել որոշակի արժեք զանգվածում: Սա ոչ թե սովորական որոնում է, այլ կրճատված որոնում, որը կոչվում է բինարային որոնում: Այս մեթոդի իմաստը հետևյալում է՝

• Նախապես զանգվածը դասակարգվում է
• Այնուհետև զանգվածի միջին տարրը համեմատվում է որոնող տարրի հետ (որն մենք փնտրում ենք):
• Եթե որոնող տարրը մեծ է միջինից, որոնումը շարունակվում է զանգվածի աջ կեսում:
• Եթե որոնող տարրը փոքր է միջինից, որոնումը շարունակվում է զանգվածի ձախ կեսում:

Հաշված այս հանգամանքը, որ զանգվածը դասակարգված է, կարող եք մեկ համեմատությունից դուրս նետել կես զանգվածը։ Այնուհետև հաջորդ քայլում դուրս նետել էլի կեսը և այսպես շարունակ։

Այս մեթոդը դարձնում է բինարային որոնումը շատ արագ։ Միլիոն տարր ունեցող զանգվածում որոնելու համար անհրաժեշտ տարրի ինդեքսը գտնելու համար հարկավոր է ընդամենը 20 համեմատություն։ Նման մոտեցման բացասական կողմը այն է, որ զանգվածը նախքան պետք է դասակարգել, իսկ դասակարգումը նույնպես ժամանակ է պահանջում։

Ահա թե ինչպես է նրա կանչը՝

int index = Arrays.binarySearch(անունը, արժեքը);

Որտեղ անունը՝ դա այն զանգվածի անունն է, որ արդեն պետք է փոխանցվի դասակարգված (օրինակ՝ Arrays.sort() ֆունկցիայի միջոցով)։ արժեքը՝ դա այն տարրն է, որ փնտրում ենք զանգվածում։ Մեթոդը վերադարձնում է արդյունք՝ զանգվածում որոնվող տարրի ինդեքսը (զանգվածի բջիջի համարը):

Օրինակները՝

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}

Եթե զանգվածում որոնվող տարրերը մի քանիսն են, պարզապես վերադարձվում է դրանցից մի մասի համարը (չկան երաշխիքներ, որ դա կլինի, օրինակ, ամենաառաջինը կամ հակառակը՝ ամենավերջինները):

Եթե տարրը զանգվածում չհայտնաբերվել, ինդեքսը կլինի բացասական։

6. Հղում Oracle-ի Arrays դասի փաստաթղթմանը

Եթե ձեզ շատ հետաքրքիր է, լրիվ տեղեկատվությունը Arrays դասի և նրա բոլոր մեթոդների մասին կարող եք կարդալ Oracle կայքում պաշտոնական փաստաթղթից՝

https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/Arrays.html

Կարող եք կարդալ, օրինակ, Arrays.mismatch() և Arrays.compare() մեթոդների մասին։ Միգուցե կգտնեք դրանցում ձեր համար մի բան օգտակար։

Եվ թող ձեզ չշփոթի մեթոդների քանակությունը – յուրաքանչյուր մեթոդների մոտ կա 5-10 օրինակ, որոնք միայն հաշվի տեսակներով տարբերվում են։