๋ชฉ์ฐจ
Java๋ ์ซ์ ๊ณ์ฐ, ๋์ ์์ฑ, ๋ฐฐ์ด ์กฐ์ ๋ฑ ๋ค์ํ ์ํฉ์์ ์ฌ์ฉํ ์ ์๋ ์ ํธ๋ฆฌํฐ ํด๋์ค๋ฅผ ์ ๊ณตํฉ๋๋ค.
๊ทธ์ค์์๋ ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉํ๋ ํด๋์ค๊ฐ ๋ฐ๋ก Math, Random, Arrays์ ๋๋ค.
์ด๋ฒ ๊ธ์์๋ ์ด ์ธ ๊ฐ์ง ์ ํธ ํด๋์ค์ ์ฃผ์ ๊ธฐ๋ฅ๊ณผ ์ฌ์ฉ๋ฒ์ ํ๋์ ์ ๋ฆฌํด ๋ณด๊ฒ ์ต๋๋ค.
๐ Math ํด๋์ค
Math ํด๋์ค๋ ์ํ ๊ด๋ จ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ์ ์ (static) ์ ํธ๋ฆฌํฐ ํด๋์ค์ ๋๋ค.
๋ชจ๋ ๋ฉ์๋๋ ์ธ์คํด์ค๋ฅผ ์์ฑํ์ง ์๊ณ ๋ฐ๋ก ์ฌ์ฉํ ์ ์์ด์.
int max = Math.max(10, 20);
double sqrt = Math.sqrt(16);
double pow = Math.pow(2, 3);
์ฃผ์ ๋ฉ์๋
๋ฉ์๋ | ์ค๋ช | ์์ |
Math.abs(x) | ์ ๋๊ฐ | Math.abs(-5) → 5 |
Math.max(a, b) | ์ต๋๊ฐ | Math.max(10, 20) → 20 |
Math.min(a, b) | ์ต์๊ฐ | Math.min(3, 7) → 3 |
Math.pow(a, b) | ๊ฑฐ๋ญ์ ๊ณฑ | Math.pow(2, 4) → 16.0 |
Math.sqrt(x) | ์ ๊ณฑ๊ทผ | Math.sqrt(9) → 3.0 |
Math.round(x) | ๋ฐ์ฌ๋ฆผ | Math.round(3.6) → 4 |
Math.floor(x) | ๋ด๋ฆผ | Math.floor(3.6) → 3.0 |
Math.ceil(x) | ์ฌ๋ฆผ | Math.ceil(3.1) → 4.0 |
Math.random() | 0.0 ์ด์ 1.0 ๋ฏธ๋ง ๋์ | Math.random() → 0.3674… |
๐ก Math.random()์ ๊ฐ๋จํ ๋์๊ฐ ํ์ํ ๋ ์ ์ฉํ์ง๋ง, ์ ๊ตํ ์ ์ด๋ Random ํด๋์ค๋ฅผ ์ถ์ฒํฉ๋๋ค.
๐ฒ Random ํด๋์ค
Random ํด๋์ค๋ ๋ณด๋ค ์ ๋ฐํ๊ณ ๋ค์ํ ๋์ ์์ฑ์ ์ง์ํฉ๋๋ค.
nextInt(), nextDouble(), nextBoolean() ๋ฑ ๋ค์ํ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ฉฐ, ์๋(seed) ์ค์ ๋ ๊ฐ๋ฅํด ๋์ ์ํ์ค๋ฅผ ์ฌํํ ์ ์์ต๋๋ค.
import java.util.Random;
Random rand = new Random();
int i = rand.nextInt(); // ์ ์ฒด ๋ฒ์ ์ ์
int i2 = rand.nextInt(10); // 0 ~ 9
double d = rand.nextDouble(); // 0.0 ์ด์ 1.0 ๋ฏธ๋ง
boolean b = rand.nextBoolean(); // true ๋๋ false
์๋ ์ค์
Random rand = new Random(42); // ํญ์ ๋์ผํ ๋์ ์ํ์ค๋ฅผ ์์ฑ
๋์ผํ ์๋๋ก ์์ฑํ๋ฉด ํญ์ ๊ฐ์ ๋์์ด์ ์ป์ ์ ์์ด, ํ ์คํธ๋ ์๋ฎฌ๋ ์ด์ ์ ์ ์ฉํฉ๋๋ค.
๐ Arrays ํด๋์ค
Arrays ํด๋์ค๋ ๋ฐฐ์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ๋ค์ํ ์ ์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.
์ ๋ ฌ, ์ถ๋ ฅ, ๋ณต์ฌ, ๋น๊ต, ํ์ ๋ฑ ๋ฐฐ์ด ์กฐ์์ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ด์.
์ฃผ์ ๋ฉ์๋
๋ฉ์๋ | ์ค๋ช | ์์ |
Arrays.toString(arr) | ๋ฐฐ์ด์ ๋ฌธ์์ด๋ก ๋ณํ | Arrays.toString(new int[]{1,2}) → [1, 2] |
Arrays.sort(arr) | ์ค๋ฆ์ฐจ์ ์ ๋ ฌ | Arrays.sort(arr) |
Arrays.copyOf(arr, n) | ๋ฐฐ์ด ๋ณต์ฌ (ํฌ๊ธฐ ์ง์ ) | Arrays.copyOf(arr, 5) |
Arrays.equals(a, b) | ๋ ๋ฐฐ์ด ๋น๊ต | Arrays.equals(arr1, arr2) |
Arrays.fill(arr, val) | ๋ฐฐ์ด ์ ์ฒด ๊ฐ ์ฑ์ฐ๊ธฐ | Arrays.fill(arr, 0) |
Arrays.binarySearch(arr, key) | ์ด์ง ํ์ (์ ๋ ฌ ํ์) | Arrays.binarySearch(arr, 3) |
์์ ์ฝ๋
import java.util.Arrays;
int[] nums = {5, 3, 1, 4, 2};
// ์ ๋ ฌ
Arrays.sort(nums);
// ์ถ๋ ฅ
System.out.println(Arrays.toString(nums)); // [1, 2, 3, 4, 5]
// ๋ณต์ฌ
int[] copy = Arrays.copyOf(nums, 3); // [1, 2, 3]
// ๊ฐ ์ฑ์ฐ๊ธฐ
Arrays.fill(copy, 9); // [9, 9, 9]
// ๊ฒ์ (์ ๋ ฌ๋ ๋ฐฐ์ด๋ง ์ฌ์ฉ)
int index = Arrays.binarySearch(nums, 3); // 2
๐ ๋ง๋ฌด๋ฆฌ
์ด๋ฒ ๊ธ์์๋ Java์ ์ฃผ์ ์ ํธ๋ฆฌํฐ ํด๋์ค์ธ Math, Random, Arrays์ ๋ํด ์์๋ณด์์ต๋๋ค.
Math, Random, Arrays๋ ์๋ฐ ๊ฐ๋ฐ์์ ๊ฐ์ฅ ์์ฃผ ์ฐ์ด๋ ์ ํธ ํด๋์ค์ ๋๋ค.
์ด๋ฐ ์ ํธ๋ฆฌํฐ ํด๋์ค๋ค์ ์ ํ์ฉํ๋ฉด ๋ณต์กํ ๋ก์ง์ ์ง์ ๊ตฌํํ ํ์ ์์ด ๊ฐ๋จํ๊ณ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
ํนํ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํด๊ฒฐ์ด๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์์ ์์ ๋งค์ฐ ์ ์ฉํ์ฃ .
๊ฐ ํด๋์ค์ ์ฃผ์ ํน์ง์ ๋ค์ ์ ๋ฆฌํ๋ฉด
- Math: ์ ๋๊ฐ, ์ ๊ณฑ, ์ ๊ณฑ๊ทผ, ๋ฐ์ฌ๋ฆผ ๋ฑ ์ํ ๊ณ์ฐ์ ๊ฐ๋จํ ์ฒ๋ฆฌ
- Random: ๋ค์ํ ๋์ ํ์ ์ง์ + ์๋ ์ค์ ์ผ๋ก ์ฌํ ๊ฐ๋ฅ
- Arrays: ๋ฐฐ์ด ์ ๋ ฌ/์ถ๋ ฅ/๋ณต์ฌ/๊ฒ์ ๋ฑ ํต์ฌ ์ ํธ ๊ธฐ๋ฅ ์ ๊ณต
๋ค์ ๊ธ์์๋ ์๋ฐ์ ์ปฌ๋ ์ ํ๋ ์์ํฌ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
๊ถ๊ธํ ๋ด์ฉ์ด๋ ์ถ๊ฐ๋ก ์๊ณ ์ถ์ ๊ฐ๋ ์ด ์๋ค๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์ ๐