1.Arrays.fill()

๋ฐฐ์—ด๋กœ ์ž‘์—…ํ•  ๋•Œ Java ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๋ฐฐ์—ด์„ ๋™์ผํ•œ ๊ฐ’์œผ๋กœ ์ฑ„์›Œ์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งค์šฐ ๋งŽ์Šต๋‹ˆ๋‹ค. ๋ฌผ๋ก  ๋ฃจํ”„๋ฅผ ์ž‘์„ฑํ•˜๊ณ  ๋ฃจํ”„์— ์žˆ๋Š” ๋ฐฐ์—ด์˜ ๊ฐ ์…€์— ๊ฐ’์„ ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

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)

์—ฌ๊ธฐ์„œ ์ฒซ ๋ฒˆ์งธ์™€ ๋งˆ์ง€๋ง‰์€ ์ฑ„์šธ ์ฒซ ๋ฒˆ์งธ ์…€๊ณผ ๋งˆ์ง€๋ง‰ ์…€์˜ ์ธ๋ฑ์Šค์ž…๋‹ˆ๋‹ค.

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. ๋ฐฐ์—ด์˜ ์…€์€ 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์—ฌ ๋ฒˆํ˜ธ๊ฐ€ ๋งค๊ฒจ์ง‘๋‹ˆ๋‹ค!

๋ณ€์ˆ˜ str์—๋Š” ๋‹ค์Œ ๊ฐ’์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค.
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

์ด Arrays.fill()๋ฐฉ๋ฒ•์€ 1์ฐจ์› ๋ฐฐ์—ด์—์„œ๋งŒ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ๋ฉ”์„œ๋“œ์— 2์ฐจ์› ๋ฐฐ์—ด์„ ์ „๋‹ฌํ•˜๋ฉด ๋ชจ๋“  ํ›„์† ๊ฒฐ๊ณผ์™€ ํ•จ๊ป˜ 1์ฐจ์›์œผ๋กœ ์ฒ˜๋ฆฌ๋ฉ๋‹ˆ๋‹ค.



2.Arrays.copyOf()

์ด๋ฏธ ์•Œ๊ณ  ์žˆ๋“ฏ์ด ๋ฐฐ์—ด์ด ์ƒ์„ฑ๋œ ํ›„์—๋Š” ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ์กฐ์ •ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ ์ •๋ง๋กœ ์›ํ•œ๋‹ค๋ฉด ์–ด๋–จ๊นŒ์š”?

๊ธ€์Ž„, ๋‹น์‹ ์ด ์ •๋ง๋กœ ์›ํ•œ๋‹ค๋ฉด ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค!

  • ์›ํ•˜๋Š” ๊ธธ์ด์˜ ์ƒˆ ๋ฐฐ์—ด์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.
  • ์ฒซ ๋ฒˆ์งธ ๋ฐฐ์—ด์˜ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹์—ฌ๊ธฐ์— ๋ณต์‚ฌํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๊ฑด ๊ทธ๋ ‡๊ณ , ์ด๊ฒƒ์ด ๋ฐ”๋กœ ์ด Arrays.copyOf()๋ฐฉ๋ฒ•์ด ํ•˜๋Š” ์ผ์ž…๋‹ˆ๋‹ค. ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ˜ธ์ถœํ•ฉ๋‹ˆ๋‹ค.

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

์ด ๋ฐฉ๋ฒ•์€ ๊ธฐ์กด ๋ฐฐ์—ด์„ ๋ณ€๊ฒฝํ•˜์ง€ ์•Š๊ณ  ๋Œ€์‹  ์ƒˆ ๋ฐฐ์—ด์„ ๋งŒ๋“ค๊ณ  ์ด์ „ ๋ฐฐ์—ด์˜ ์š”์†Œ๋ฅผ ๋ณต์‚ฌํ•ฉ๋‹ˆ๋‹ค.

์š”์†Œ๊ฐ€ ๋งž์ง€ ์•Š์œผ๋ฉด( ๊ธธ์ด๊ฐ€ ๊ธฐ์กด ๋ฐฐ์—ด ์˜ ๊ธธ์ด๋ณด๋‹ค ์ž‘์Œ ) ์ถ”๊ฐ€ ๊ฐ’์ด ๋ฌด์‹œ๋ฉ๋‹ˆ๋‹ค.

์ƒˆ ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ์ด์ „ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ณด๋‹ค ํฌ๋ฉด ์…€์ด 0์œผ๋กœ ์ฑ„์›Œ์ง‘๋‹ˆ๋‹ค.

์˜ˆ:

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

์‚ผ.Arrays.copyOfRange()

๊ธธ์ด๊ฐ€ 10์ธ ๋ฐฐ์—ด์—์„œ ๊ธธ์ด๊ฐ€ 5์ธ ๋ฐฐ์—ด์„ ๊ฐ€์ ธ์˜ค๊ณ  ์‹ถ์ง€๋งŒ ์ฒ˜์Œ 5๊ฐœ๊ฐ€ ์•„๋‹Œ ๋งˆ์ง€๋ง‰ 5๊ฐœ์˜ ์š”์†Œ๋ฅผ ํฌํ•จํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ์—๋Š” ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ•ฉ๋‹ˆ๊นŒ?

์ด ๊ฒฝ์šฐ Arraysํด๋ž˜์Šค์˜ ๋‹ค๋ฅธ ๋ฉ”์„œ๋“œ์ธ Arrays.copyOfRange(). ํ˜ธ์ถœํ•  ๋•Œ์˜ ๋ชจ์Šต์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

Type[] name2 = Arrays.copyOfRange(name, 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()

์•„, ๊ฐ€์žฅ ๋ง›์žˆ๋Š” ๋Œ€์ ‘: ๋ถ„๋ฅ˜ . ๋ฐฐ์—ด์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ๋งค์šฐ ์ž์ฃผ ์ •๋ ฌ๋ฉ๋‹ˆ๋‹ค. ์–ด๋ ˆ์ด๋กœ ์ž‘์—…ํ•  ๋•Œ ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ์„ธ โ€‹โ€‹๊ฐ€์ง€ ์ž‘์—…์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

  • ๋ฐฐ์—ด ์ •๋ ฌ
  • ๋ฐฐ์—ด์˜ ์ตœ์†Œ(๋˜๋Š” ์ตœ๋Œ€) ์š”์†Œ ์ฐพ๊ธฐ
  • ๋ฐฐ์—ด์—์„œ ์š”์†Œ์˜ ์ธ๋ฑ์Šค ๊ฒฐ์ •(๋ฐฐ์—ด์—์„œ ์š”์†Œ ์ฐพ๊ธฐ)

์ด๊ฒƒ์ด ๋ฐ”๋กœ 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);



๋ณ€์ˆ˜ str์—๋Š” ๋‹ค์Œ ๊ฐ’์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค.
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

ํ›Œ๋ฅญํ•˜์ฃ ? ํ•˜๋‚˜์˜ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ–ˆ๊ณ  ์ด์ œ ์ •๋ ฌ๋œ ๋ฐฐ์—ด์„ ๊ฐ–๊ฒŒ ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์•„๋ฆ„๋‹ค์šด.

๊ทธ๋Ÿฐ๋ฐ ์ด ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜์—ฌ ์ „์ฒด ๋ฐฐ์—ด๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ์ผ๋ถ€๋งŒ ์ •๋ ฌํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ˜ธ์ถœํ•ฉ๋‹ˆ๋‹ค.

Arrays.sort(name, first, last);

์—ฌ๊ธฐ์„œ 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๊ฐœ ์š”์†Œ์˜ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•˜๋ ค๋ฉด ์•ฝ 3,000๋ฒˆ์˜ ๋ฐฐ์—ด ์š”์†Œ ๋น„๊ต๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค. 100๋งŒ ์š”์†Œ์˜ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•˜๋ ค๋ฉด ์•ฝ 600๋งŒ ๋ฒˆ์˜ ๋น„๊ต๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.



5.Arrays.binarySearch()

์Œ, ํด๋ž˜์Šค์˜ ๊ฐ€์žฅ ํฅ๋ฏธ๋กœ์šด ๋งˆ์ง€๋ง‰ ๋ฉ”์„œ๋“œ๋Š” Arrays๋ฐฐ์—ด์—์„œ ์ฃผ์–ด์ง„ ๊ฐ’์„ ๊ฒ€์ƒ‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ์ผ๋ฐ˜์ ์ธ ๊ฒ€์ƒ‰์ด ์•„๋‹™๋‹ˆ๋‹ค. ์‚ฌ๋ž‘๋ฐ›๋Š” ์ด์ง„ ๊ฒ€์ƒ‰ ์ž…๋‹ˆ๋‹ค . ์š”์•ฝํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

  • ๋จผ์ € ๋ฐฐ์—ด์ด ์ •๋ ฌ๋ฉ๋‹ˆ๋‹ค.
  • ๊ทธ๋Ÿฐ ๋‹ค์Œ ๋ฐฐ์—ด์˜ ์ค‘๊ฐ„ ์š”์†Œ๋ฅผ ์ฐพ๊ณ  ์žˆ๋Š” ์š”์†Œ์™€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ์š”์†Œ๊ฐ€ ์ค‘๊ฐ„ ์š”์†Œ๋ณด๋‹ค ํฌ๋ฉด ๋ฐฐ์—ด์˜ ์˜ค๋ฅธ์ชฝ ์ ˆ๋ฐ˜์—์„œ ๊ฒ€์ƒ‰์ด ๊ณ„์†๋ฉ๋‹ˆ๋‹ค.
  • ์ฐพ๊ณ  ์žˆ๋Š” ์š”์†Œ๊ฐ€ ์ค‘๊ฐ„ ์š”์†Œ๋ณด๋‹ค ์ž‘์œผ๋ฉด ๋ฐฐ์—ด์˜ ์™ผ์ชฝ ์ ˆ๋ฐ˜์—์„œ ๊ฒ€์ƒ‰์ด ๊ณ„์†๋ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด์ด ์ •๋ ฌ๋˜์–ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ํ•œ ๋ฒˆ์˜ ๋น„๊ต๋กœ ์ ˆ๋ฐ˜์„ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ๋‹ค์Œ ๋‹จ๊ณ„์—์„œ ๋‚˜๋จธ์ง€ ์ ˆ๋ฐ˜์„ ๋ฒ„๋ฆฝ๋‹ˆ๋‹ค.

์ด ์ ‘๊ทผ ๋ฐฉ์‹์€ ์ด์ง„ ๊ฒ€์ƒ‰์„ ๋งค์šฐ ๋น ๋ฅด๊ฒŒ ๋งŒ๋“ญ๋‹ˆ๋‹ค. 100๋งŒ(!) ์š”์†Œ์˜ ๋ฐฐ์—ด์—์„œ ๋‹จ 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);
x์ด๋‹ค:
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(์ธ๋ฑ์Šค 0๋ฐ 2ํ—ˆ์šฉ ๊ฐ€๋Šฅ)
8
-7

๋ฐฐ์—ด์ด ๊ฒ€์ƒ‰ ์ค‘์ธ ์š”์†Œ์˜ ์—ฌ๋Ÿฌ ์ธ์Šคํ„ด์Šค๋ฅผ ํฌํ•จํ•˜๋Š” ๊ฒฝ์šฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ๋‹จ์ˆœํžˆ ๊ทธ ์ค‘ ํ•˜๋‚˜์˜ ์ธ๋ฑ์Šค๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค . ์ค‘๋ณต ์š”์†Œ)."

์š”์†Œ๊ฐ€ ๋ฐฐ์—ด์—์„œ ๋ฐœ๊ฒฌ๋˜์ง€ ์•Š์œผ๋ฉด ์ธ๋ฑ์Šค๋Š” ์Œ์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.



Arrays6. ํด๋ž˜์Šค ์— ๋Œ€ํ•œ Oracle ์„ค๋ช…์„œ ๋งํฌ

Arrays๋งค์šฐ ๊ด€์‹ฌ์ด ์žˆ๋Š” ๊ฒฝ์šฐ ๊ณต์‹ ๋ฌธ์„œ a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base์—์„œ ํด๋ž˜์Šค ๋ฐ ํ•ด๋‹น ๋ฉ”์„œ๋“œ ์— ๋Œ€ํ•œ ๋ชจ๋“  ๋‚ด์šฉ์„ ์ฝ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. /java/util/Arrays.html">์˜ค๋ผํด ์›น ์‚ฌ์ดํŠธ.

Arrays.mismatch()์˜ˆ๋ฅผ ๋“ค์–ด ๋ฐ ๋ฉ”์„œ๋“œ ์— ๋Œ€ํ•ด ์ฝ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค Arrays.compare(). ์–ด์ฉŒ๋ฉด ๋‹น์‹ ์€ ๊ทธ๊ฒƒ๋“ค์ด ์–ด๋–ป๊ฒŒ๋“  ์œ ์šฉํ•˜๋‹ค๋Š” ๊ฒƒ์„ ์•Œ๊ฒŒ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ๋ฐฉ๋ฒ•์˜ ์ˆ˜์— ํ˜ผ๋™ํ•˜์ง€ ๋งˆ์‹ญ์‹œ์˜ค. ๊ฐ ๋ฐฉ๋ฒ•์—๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜ ์œ ํ˜•๋งŒ ๋‹ค๋ฅธ โ€‹โ€‹5-10๊ฐœ์˜ ๋ณ€ํ˜•์ด ์žˆ์Šต๋‹ˆ๋‹ค.