Buna din nou! :) În lecția de astăzi, vom vorbi despre clasa Arrays în Java. În ultima lecție, am cunoscut o astfel de structură de date numită matrice. Am învățat cum să le creăm și să le umplem cu date. Și ne-am uitat la modul în care sunt stocate în memorie. Astăzi vom analiza câteva sarcini și exemple de lucru cu matrice pe care le veți vedea adesea în munca reală. De exemplu, imaginați-vă această situație: avem o matrice de 10 numere aleatorii.
Sarcina noastră este să sortăm această matrice în ordine crescătoare: de la cel mai mic la cel mai mare. În cele din urmă, ar trebui să arate așa: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Cum facem asta? Această sarcină nu este banală. Nu am mai făcut asta până acum :/ Aveți idei? Încercați să ghiciți. Iată o soluție:
Treceți prin toate elementele matricei. Comparați fiecare element cu următorul ([0] cu [1], [1] cu [2], [2] cu [3] etc.). Dacă elementul curent este mai mare decât următorul, le schimbăm și apoi trecem la următorul element. Dacă nu, lăsați-le așa cum sunt și mergeți mai departe
Astfel, după prima trecere prin elemente, cea mai mare valoare (167) este garantată a fi în ultima celulă.
Acum vom parcurge din nou toate elementele, dar de data aceasta vom începe cu indexul [0] până la penultimul element (cel mai mare număr este deja la locul său) și vom face aceleași comparații și schimburi. După această trecere, în penultima celulă, vom avea a doua cea mai mare valoare (99).
Repetați acest proces de câte ori avem elemente de matrice.
Avem ideea. Acum trebuie doar să scriem codul. Arata cam asa:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Uh... Pare puțin complicat -_- Chiar dacă principiul general este de înțeles, tot trebuie să scriem destul de mult cod pentru a rezolva o sarcină atât de simplă. Bine, poate ne-am supraestimat? Sarcina pe care am abordat-o este probabil încă prea complicată pentru noi. Să încercăm ceva mai simplu. De exemplu, luați aceeași matrice de numere.
Sarcina noastră este să copiam conținutul său într-o altă matrice.
int [] numbersCopy = new int[10];
Gândește-te cum ai face asta folosind ceea ce știi deja despre matrice? De exemplu, puteți parcurge matricea numere într-o buclă și puteți scrie secvențial elementele sale în numereCopie :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
Ei bine, uh, aici am făcut-o! Se pare că am rezolvat problema. Cu toate acestea, dacă trebuie să faceți acest lucru des, codul dvs. va avea o grămadă de bucle identice. De fapt, aceste sarcini (și altele) au fost rezolvate de multă vreme de creatorii Java. Nu trebuie să „reinventăm roata” și să ne codificăm propria soluție. Există o clasă statică specială ( Arrays ) pentru a vă ajuta să efectuați sarcini obișnuite atunci când lucrați cu matrice. La această clasă au fost adăugate metode pentru realizarea celor mai frecvente sarcini cu care se confruntă programatorii Java. De exemplu, sarcina de a sorta o matrice, pe care am încercat să o gestionăm, este rezolvată într-o singură linie:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
Metoda Arrays.sort() sortează matricea. Și algoritmul său este mult mai eficient decât codul pe care l-am scris. Ieșire din consolă: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Notă: Pentru a converti matricea într-un șir, am folosit o altă metodă a clasei Arrays : Arrays.toString() . Matricele din Java nu suprascrie singure metoda toString() . Deci, dacă scrii pur și simplu
System.out.println(numbers.toString());
va fi apelat toString() al clasei Object . Pentru o matrice, rezultatul va fi cam așa: [I@4554617c Nu vom intra în detaliu acum despre de ce exact aceasta este ieșirea. Principalul lucru este că clar nu este ceea ce avem nevoie. Dar Arrays.toString() face exact ceea ce vrem. Apropo, copierea este ușor de realizat și cu clasa Arrays :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
Trecem la metoda Arrays.copyOf() matricea noastră originală (din care dorim să copiem valori) și lungimea noului tablou în care copiem datele. În acest caz, am indicat numere.lungime ca lungime, deoarece doriți să copiați întregul tablou. Dacă dorim să copiem doar primele câteva elemente, putem specifica lungimea unui nou tablou mai mic:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
Aici am specificat 4 ca lungime a noii matrice. În consecință, doar primele 4 elemente ale numerelor vor fi copiate în noua matrice. Ieșire din consolă: [167, -2, 16, 99] Apropo, Arrays vă permite, de asemenea, să copiați o parte a unui tablou de la mijloc, mai degrabă decât de la începutul matricei:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Ieșire: [16, 99, 26, 92] Numerele au fost copiate în noua matrice din a doua matrice de la al doilea (inclusiv) până la al șaselea (nu include). De asemenea, ar putea fi nevoie să comparăm două matrice. Ca și în cazul metodei toString() , tablourile în sine nu înlocuiesc metoda equals() . Deci dacă încercăm să le comparăm astfel
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
atunci devenim falși. Acest lucru se datorează faptului că Object.equals() , care compară referințele, va fi apelat. Și, evident, sunt diferite! Dar ceea ce avem nevoie este să comparăm conținutul matricei, nu referințe. Clasa Arrays suprascrie metoda equals() pentru a face exact ceea ce dorim:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
Ieșire: true Apropo, clasa Arrays funcționează nu numai cu matrice obișnuite, ci și cu cele bidimensionale:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Ieșire: sunt aceste matrice bidimensionale egale? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] După cum puteți vedea, metoda Arrays.copyOf() a putut copia o matrice bidimensională. Și clasa are metode speciale pentru compararea și afișarea matricelor bidimensionale: deepEquals și deepToString() . În viitor, veți vedea în mod repetat (și veți bucura de faptul că) că creatorii Java au anticipat o mulțime de situații cu care se confruntă frecvent programatorii și au implementat soluții gata făcute pentru ei în limbaj. Utilizarea acestor soluții este mult mai ușoară și mai convenabilă decât reinventarea roții, nu? :) Asigurați-vă că citiți documentația pentru clasa Arrays de pe site-ul Oracle . Mult succes la studii!
GO TO FULL VERSION