Arrays — isang klase ng katulong

1. Arraysklase

Tulad ng nabanggit namin dati, ang mga array ay isang napaka-kapaki-pakinabang at madalas na ginagamit sa programming.

Mabilis na napansin ng mga tagalikha ng Java na ang mga programmer ng Java ay madalas na sumusulat ng parehong code kapag nagtatrabaho sa mga array. Halimbawa, kopyahin ang bahagi ng isang array sa isa pang array, code upang punan ang bawat cell ng isang array na may parehong halaga, ipakita ang mga nilalaman ng isang array sa isang maginhawang format, atbp.

Iyon ang dahilan kung bakit nilikha nila ang espesyal Arraysna klase (ang buong pangalan nito ay java.util.Arrays), na inilalagay dito ang pinakasikat na mga aksyon na nauugnay sa array.

Marami itong pamamaraan para sa bawat okasyon, ngunit isasaalang-alang muna natin ang 10 sa mga ito — ang pinakasimple at madalas na ginagamit.

2.Arrays.toString()

Ang unang paraan na titingnan natin ay tinatawag na Arrays.toString(). Ngunit una, isang maliit na background.

Ang bawat array sa Java ay may toString()pamamaraan, na nagbabalik ng 'tekstuwal na representasyon ng array'. Maaari kang makakuha ng isang textual na representasyon ng isang array gamit ang sumusunod na pahayag:

String str = name.toString();

Nasaan nameang pangalan ng array variable, at strang pangalan ng variable na mag-iimbak ng string na representasyon ng array.

Ngunit kung susubukan mong i-print ang array sa screen gamit ang pamamaraan, malamang na makakita ka ng ganito:System.out.println(name)

I@37afeb11

Ang unang titik Iay nangangahulugan na ito ay isang intarray, at ang mga simbolo pagkatapos @ay ang address ng array sa memorya. Sa isang banda, ito mismo ang impormasyong nakaimbak sa array variable, ngunit sa kabilang banda, iba ang inaasahan namin, tama ba?

Nais naming makita ang mga halaga sa array! At iyon mismo ang dahilan kung bakit sila nakaisip ng Arrays.toString()paraan — upang ipakita ang mga halaga ng isang array. Tinatawag namin itong ganito:

String str = Arrays.toString(name);

Mga halimbawa:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Ngunit kung susubukan mong i-convert ang isang two-dimensional array sa isang string (upang ipakita ito) using the Arrays.toString()na paraan, makakakita ka ng pamilyar na bagay:

[I@37afeb11, I@37afeb21, I@37afeb31]

Ito ay lahat dahil ang mga cell ng isang dalawang-dimensional na array ay nag-iimbak ng mga sanggunian sa isang-dimensional na mga array. At paano na-convert ang mga one-dimensional array sa isang string? Eksaktong tulad ng nakikita mo sa itaas.

Ano ang maaaring gawin? Paano natin maipapakita nang tama ang isang two-dimensional na array?

Sa layuning ito, ang Arraysklase ay may isa pang espesyal na pamamaraan — deepToString(). Ang pagtawag ay ganito ang hitsura:

String str = Arrays.deepToString(name);

Ang pamamaraang ito ay maaaring magpasa ng mga array na two-dimensional, one-dimensional, three-dimensional o, sa pangkalahatan, anumang dimensyon, at palaging ipapakita nito ang mga elemento ng array.
Tandaan:Arrays.deepToString() hindi gumagana ang pamamaraan sa mga one-dimensional na array ng mga primitive (halimbawa, int[]).

Mga halimbawa:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

Naisip namin kung paano magpakita ng mga arrays sa screen, ngunit paano naman ang paghahambing ng mga arrays?

Upang ihambing ang mga string, mayroon kami equalsat equalsIgnoreCasemga pamamaraan, ngunit anong mga pamamaraan ang mayroon ang mga array?

Ang mabuting balita ay ang mga arrays ay may equalspamamaraan. Ang masamang balita ay hindi nito ikinukumpara ang mga nilalaman ng mga array. Ang equalsparaan ng mga array ay ginagawa ang parehong bagay tulad ng ==operator - ito ay naghahambing ng mga sanggunian. Mga halimbawa:

Mga halimbawa:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

Ano ang maaaring gawin? Paano natin inihahambing ang mga array batay sa mga nilalaman nito?

At muli ang Arraysdumating upang iligtas tayo, o mas partikular, ang Arrays.equals()pamamaraan nito. Ganito ang tawag namin dito:

Arrays.equals(name1, name2)

Ang pamamaraan ay babalik truekung ang mga array ay may pantay na haba at ang kanilang mga elemento ay pantay. Kung hindi, ito ay babalik false.

Mga halimbawa:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

At, tulad ng nahulaan mo na, Arrays.equalshindi gagana nang tama ang pamamaraan para sa mga two-dimensional na array: tinatrato nito ang mga two-dimensional array na parang isang one-dimensional na array na ang mga elemento ay mga address ng isang-dimensional na array.

Kaya, upang maihambing nang tama ang mga multidimensional na arrays ( n = 1, 2, 3,...), nakaisip sila ng Arrays.deepEquals()pamamaraan. Ang pagtawag ay ganito ang hitsura:

Arrays.deepEquals(name1, name2)

Ang pamamaraan ay nagbabaliktruekung ang mga arrays ay may pantay na haba at ang kanilang mga elemento ay pantay. Kung hindi, ito ay babalikfalse. Kung ang mga elemento sa loob ng array ay mga array din, kung gayon ang Arrays.deepEquals()paraan ay ginagamit upang ihambing ang mga ito, at iba pa.

Mga halimbawa:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);