
์ด๋ฒ์๋ ์๋ฐ๋ก ๋ก๋ ๋ฒํธ ์๋ ์์ฑ๊ธฐ๋ฅผ ๋ง๋ค์ด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์๋ฐ๋ก ํ๋ก๊ทธ๋๋ฐ์ ํ๊ธฐ์ ์ ์ฐ์ ๋ก๋์ ๊ท์น๋ถํฐ ์์์ผ ๊ฒ ์ฃ .
๋ก๋์๋ 1๋ถํฐ 45๊น์ง์ ์ซ์๊ฐ ์กด์ฌํ๊ณ
๋ณด๋์ค ๋ฒํธ๋ฅผ ํฌํจํ์ฌ ์ด 7๊ฐ์ ์ซ์๋ฅผ ๋๋คํ๊ฒ ๋ฝ์ต๋๋ค.
๊ฐ ์ซ์๋ ์ค๋ณต๋์ด ์ ํํ ์ ์์ต๋๋ค.
์ฌ๊ธฐ์ ํค ํฌ์ธํธ ๋จ์ด๋ ๋ฐ๋ก ๋๋ค๊ณผ ์ค๋ณต ์ ๋๋ค.
์๋ฐ์์ ์ค๋ณต์ ์ ๊ฑฐํ๋ ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ Set์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
์, ๊ทธ๋ผ ๋๋คํ๊ฒ ์ซ์๋ฅผ ๊ตฌํ๋ ๊ฒ๋ถํฐ ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์๋ฐ์์ ๋๋คํ ์ซ์๋ฅผ ์ป์ ๋๋ Math.random() ๋ฉ์๋๋ฅผ ์ด์ฉํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ์ด ๋ฉ์๋๋ 0๋ถํฐ 1์ฌ์ด์ double ํํ์ ์์๋ฅผ ๋ฆฌํดํด์ค๋๋ค.
์ค์?? ๊ทธ๋ผ ์ด๋ป๊ฒ 1๋ถํฐ 45๊น์ง์ ์ซ์๋ฅผ ์ป๋๋ค๋ ๊ฑธ๊น์??
์ด์ ๋ถํฐ ํธ๋ฆญ์ ์๋ ค๋๋ฆฌ๊ฒ ์ต๋๋ค.
Math.random()์ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 1๋ณด๋ค ์์ ์ซ์๋ฅผ ๋ฐํํด์ค๋๋ค.
๋ด๊ฐ ์ป๊ณ ์ํ๋ max์ซ์๋ฅผ ๊ณฑํด์ฃผ๋ฉด
0๋ถํฐ max๊ฐ ์ฌ์ด์ double ํํ์ ์ซ์๋ฅผ ์ป์ ์ ์์ต๋๋ค.
๊ทธ๋ผ ์ด ์ซ์๋ฅผ ๋ค์ intํํ๋ก casting์ ํด๋ฒ๋ฆฌ๋ฉด?
0<= ์ํ๋ ์ซ์ < max ์ฌ์ด์ int ๊ฐ์ ์ป์ ์ ์์ต๋๋ค.
์์ ๋ฅผ ํ๋ฒ ๋ณด์ฌ๋๋ฆฌ๋๋ก ํ๊ฒ ์ต๋๋ค.
public static void main(String[] args) {
getRandomNumber();
}
private static void getRandomNumber() {
final int max = 46;
for(int i = 0; i < 10; i++) {
int randomNumber = (int)(Math.random() * max);
System.out.println(randomNumber);
}
}
์ ์ฝ๋๋ฅผ ์คํ์ํค๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
0
12
34
27
5
21
10
24
43
์ ๊ฒฐ๊ณผ์๋ ์ค๋ณต๋ ์ซ์๊ฐ ๋์ค์ง ์์์ง๋ง
๋ช ๋ฒ ์คํํ๋ค๋ณด๋ฉด ๋์ผํ ์ซ์๊ฐ ์ฐ์์ผ๋ก ๋์ค๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ค๋ณต์ ์ ๊ฑฐํด์ฃผ๋ ๊ณผ์ ์ด ํ์ํ๊ฒ ๋ฉ๋๋ค.
์ด๋ ํ์ํ ๊ฒ์ด ๋ฐ๋ก Set์ ๋๋ค.
Set์ ์๋ฐ์์ ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ์ ํ ๋ ์์ฃผ ์ ์ฉํ๊ฒ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
Set์ ๊ตฌํ์ฒด๋ ์ฌ๋ฌ๊ฐ์ง๊ฐ ์๋๋ฐ ์ผ๋ฐ์ ์ผ๋ก ๋ง์ด ์ฐ์ด๋ ๊ฒ์ HashSet์ ๋๋ค.
์๋ ์์ ์ฝ๋๋ฅผ ํ๋ฒ ๋ณด๊ฒ ์ต๋๋ค.
public static void main(String[] args) {
removeDuplicate();
}
private static void removeDuplicate() {
Set<Integer> noDuplicated = new HashSet<>();
noDuplicated.add(30);
noDuplicated.add(30);
noDuplicated.add(31);
System.out.println(noDuplicated);
}
์ ์ฝ๋๋ฅผ ์คํํ๋ฉด ์๋์ ๊ฐ์ด ์ถ๋ ฅ๋ฉ๋๋ค.
[30, 31]
๋ณด์๋ ๋ฐ์ ๊ฐ์ด 30์ ๋ ๋ฒ add ํ๋๋ฐ 1๊ฐ๋ง ์ ์ฅ์ด ๋์์ต๋๋ค.
์ด๊ฒ์ ์ด์ฉํด์ ์ด๋ฏธ ๋ฝ์ ์ซ์๋ ์ ์ฅํ์ง ์๊ณ ์๋ก์ด ๋ฒํธ๋ฅผ ๋ฝ๋๋ก ํ ์ ์์ต๋๋ค.
์๋๋ ์์ฑ๋ ๋ก๋ ๋ฒํธ ์์ฑ๊ธฐ์ ์ํ์ ๋๋ค.
private static void lotto() {
final int min = 1;
final int max = 45;
Set<Integer> selected = new HashSet<>();
while(true) {
int randomNumber = (int)(Math.random() * (max - min +1) + min);
if(selected.add(randomNumber)) {
if(selected.size() == 6) {
break;
}
}
}
System.out.println(selected.stream().sorted().collect(Collectors.toList()));
}
์ ๋ฉ์๋๋ฅผ main ํจ์์์ ์คํ์ํค๋ฉด
1~45๊น์ง์ ์ซ์๋ค ์ค์์ ์ค๋ณต๋์ง ์์ 6๊ฐ์ ์ซ์๋ฅผ ์ถ๋ ฅํด์ค๋๋ค.
๋๋ค ๋ฒํธ ์์ฑํ๋ ๋ถ๋ถ์ด ์กฐ๊ธ ์์ ๋ ๊ฒ์ ๋์น์ฑ์ จ๋์?
์ ์์์ ๋ณด์ฌ๋๋ฆฐ ๋ก์ง์ผ๋ก๋ 0์ด ๋์ฌ ์ ์๊ธฐ ๋๋ฌธ์ ์์ ์ ํ ๊ฒ์ ๋๋ค.
์๋ฐ๋ก ๋๋ค ์ซ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋๋ค ์ซ์ ๊ตฌํ๊ธฐ ์์ ํ์ธํ์ค ์ ์์ต๋๋ค.
์ ๋ฉ์๋๋ฅผ 10๋ฒ ์คํํ ๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์ต๋๋ค.
[5, 17, 18, 25, 29, 33]
[9, 13, 16, 26, 30, 34]
[21, 24, 27, 30, 31, 42]
[9, 15, 17, 34, 36, 42]
[2, 3, 15, 35, 38, 41]
[8, 16, 30, 31, 36, 39]
[1, 5, 11, 40, 43, 44]
[1, 3, 4, 18, 21, 39]
[4, 7, 19, 28, 38, 40]
[7, 9, 14, 18, 30, 41]
์ด์์ผ๋ก ์๋ฐ๋ก ์ฌํํ ๋ก๋ ๋ฒํธ ์๋ ์์ฑ๊ธฐ ๋ง๋ค๊ธฐ ํฌ์คํ ์ ๋ง์น๋๋ก ํ๊ฒ ์ต๋๋ค.
๊ถ๊ธํ ์ ์ด ์์ผ์๋ฉด ๋๊ธ ๋ฌ์์ฃผ์๊ณ ,
ํฌ์คํ ๋ด์ฉ์ด ๋์์ด ๋์ จ๋ค๋ฉด ๊ณต๊ฐ ๊พน ๋ถํํด์ ^-^
'๐ป Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฐ๋ฆฌ ์์ด๋ฅผ ์ํ Java ๊ฐ์ 2์ผ์ฐจ] ๋ฌด์์ ๋ฐ๋ผํ๊ธฐ (0) | 2019.06.22 |
---|---|
[์ฐ๋ฆฌ ์์ด๋ฅผ ์ํ Java ๊ฐ์ 1์ผ์ฐจ] ํ๋ก๊ทธ๋๋ฐ์ด๋ ๋ฌด์์ธ๊ฐ? (0) | 2019.06.18 |
[Java] Reversing String Using StringBuilder (StringBuilder๋ก ์คํธ๋ง์ ๊ฑฐ๊พธ๋ก ๋ค์ง๊ธฐ) (0) | 2019.02.25 |
[Java] ๋๋ค ์ซ์ ๊ตฌํ๊ธฐ (0) | 2019.01.27 |
[Java] ์ซ์ ํ๋ณํ๊ธฐ (0) | 2019.01.27 |