1.Arrays.fill()

Когато работят с масиви, Java програмистите много често трябва да запълнят масива с една и съща стойност. Можете, разбира се, да напишете цикъл и просто да присвоите няHowва стойност на всяка клетка от масива в цикъла:

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

Или можете просто да извикате Arrays.fill()метода, който прави абсолютно същото: запълва подавания масив с подадената стойност. Ето How изглежда:

Arrays.fill(name, value)

И codeът в примера по-горе може да бъде напequals малко по-компактен и по-ясен:

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

Можете също така да използвате Arrays.fill()метода, за да запълните не целия масив, а част от него с няHowва стойност:

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()работи само с едномерни масиви. Ако подадете двумерен масив към метода, той ще бъде третиран като едномерен с всички произтичащи от това последствия.

2.Arrays.copyOf()

Както вече знаете, не можете да промените размера на масив, след като е бил създаден.

Java university

Но Howво, ако наистина искате?

Е, ако наистина искате, тогава можете!

  • Създайте нов масив с желаната дължина
  • Копирайте всички елементи от първия масив в него.

Между другото, точно това Arrays.copyOf()прави методът. Ето How изглежда извикването:

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

Този метод не променя съществуващия масив , а instead of това създава нов масив и копира елементите на стария масив в него.

Ако елементите не пасват ( дължината е по-малка от дължината на съществуващия масив ), тогава допълнителните стойности се игнорират.

Ако дължината на новия масив е по-голяма от дължината на стария, клетките се запълват с нули.

Пример:

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

3.Arrays.copyOfRange()

И Howво, ако искате да получите масив с дължина 5 от масив с дължина 10, но трябва да съдържа последните 5 елемента, а не първите 5?

В този случай друг метод на Arraysкласа ще бъде полезен - Arrays.copyOfRange(). Ето How изглежда, когато го извикаме:

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

Този метод също създава нов масив, но го запълва с елементи от произволно място в оригиналния масив. Където first и last са индексите на първия и последния елемент, които трябва да бъдат поставени в новия масив.

В съответствие с добрата стара традиция на Java, не забравяйте, че последният елемент не е включен в диапазона.

Пример:

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

4.Arrays.sort()

Ах, най-вкусното лакомство: сортиране . Масивите се сортират доста често в програмирането. Трите най-често срещани действия при работа с масиви са:

  • Сортиране на масив
  • Намиране на минималния (or максималния) елемент на масив
  • Определяне на индекса на елемент в масив (намиране на елемент в масив)

Точно затова създателите на Java са включor sort()метода в Arraysкласа. Ето How изглежда извикването:

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

Отлично, нали? Извикахте един метод и сега имате сортиран масив. Красив.

Между другото, можете да използвате този метод, за да сортирате не само целия масив, но само част от него. Ето How изглежда извикването:

Arrays.sort(name, first, last);

Където първи и последен са индексите на първата и последната клетка, които сортирането трябва да докосне.

В съответствие с добрата стара традиция на Java, не забравяйте, че последният елемент не е включен в диапазона.

Пример:

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 елемента ще включва около 3000 сравнения на елементи на масива. Сортирането на масив от един мorон елемента ще включва около 6 мorона сравнения.

5.Arrays.binarySearch()

Е, и последният от най-интересните методи на Arraysкласа е в състояние да търси дадена стойност в масив. Това не е обикновено търсене - това е любимото двоично търсене . Всичко се свежда до това:

  • Първо, масивът се сортира.
  • След това средният елемент на масива се сравнява с този, който търсим.
  • Ако елементът е по-голям от средния елемент, тогава търсенето продължава в дясната половина на масива.
  • Ако елементът, който търсим, е по-малък от средния елемент, тогава търсенето продължава в лявата половина на масива.

Тъй като масивът е сортиран, е възможно да се елиминира половината от него в едно сравнение. След това в следващата стъпка изхвърляме друга половина и т.н.

Този подход прави двоичното търсене много бързо. В масив от един мorон (!) елемента, той може да намери индекса на желания елемент само в 20 сравнения. Недостатъкът на подхода е, че масивът първо трябва да бъде сортиран, а сортирането също отнема време.

Ето How изглежда извикването:

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

Ако масивът съдържа множество екземпляри на елемента, който се търси, тогава алгоритъмът просто ще върне индекса на един от тях (няма гаранция, че ще бъде, да речем, първият or обратното - последният от тези дублирани елементи)."

Ако елементът не е намерен в масива, тогава индексът ще бъде отрицателен.

6. Връзка към documentацията на Oracle за Arraysкласа

Ако проявявате голям интерес, можете да прочетете всичко за Arraysкласа и всичките му методи в официалната documentация a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">на уебсайта на Oracle.

Например, можете да прочетете за методите Arrays.mismatch()и Arrays.compare(). Може би ще ги намерите за полезни по няHowъв начин.

И не се бъркайте от броя на методите. Всеки метод има 5-10 варианта, които се различават само по типовете параметри.