๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ์ฒ์์ ์ ๊ทผํ ๋ฐฉ์1. my_string์ toCharArray()๋ก char ํ์
์ ๋ฐฐ์ด๋ก ๋ณํ2. for ๋ฌธ์ผ๋ก ๋ฐฐ์ด ์์๋ฅผ ์ํํ๋ฉด์ `Character.isDigit(c)` ๋ฉ์๋๋ก ์์๊ฐ ์ซ์์ด๋ฉด count++3. 2์์ ๋์จ count ํฌ๊ธฐ๋งํผ์ int ๋ฐฐ์ด์ ์ ์ธํ๋ค. 4. for each๋ฌธ์ผ๋ก ๋ค์ ํ ๋ฒ ๋ฐฐ์ด์ ์ํํ๋ฉด์ `Integer.parseInt(String.valueOf(c));` ๋ก ์ซ์๋ง int ๋ฐฐ์ด์ ์ถ๊ฐ5. ์ค๋ฆ์ฐจ์ ์ ๋ ฌ โญ`Character.isDigit()`๋ ์ฃผ์ด์ง ๋ฌธ์๊ฐ ์ซ์(0~9)์ธ์ง ํ์ธํ๋ ์๋ฐ ๋ฉ์๋ํน์ ๋ฌธ์๊ฐ ์ซ์์ธ์ง ์๋์ง๋ฅผ ํ๋จํ์ฌ, ์ซ์์ด๋ฉด true๋ฅผ ๋ฐํํ๊ณ , ์ซ์๊ฐ ์๋๋ฉด false๋ฅผ ๋ฐํํ๋ค.โญ `Inte..

My Tech Blog (์ ๋ ฌ)
์ค๋์ ๋ช
์ธ

์ ๋ ฌ(Sort)๊ฐ์๋ฐ์ดํฐ๋ฅผ ์ค๋ฆ์ฐจ์ ๋๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์ดํ๊ฑฐ๋ ๋ฆฌ์คํธ์ ์์๋ฅผ ์ ๋ ฌํ๋ ๊ณผ์ ์ด๋ค. ์ ๋ ฌ์ ํ์ฉํ ์ฝ๋ฉํ
์คํธ ๋ฌธ์ ๋ ๋งค์ฐ ๋ค์ํ๋ค. ์ ๋ ฌ ๋ฌธ์ ๋ ๋ฌธ์ ๋ฅผ ํ ๋๋ ์ ๋ ฌ ๊ธฐ์ค์ ์ ํํ ํ์
ํ๊ณ , ๊ทธ์ ๋ง๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ํํ๋ ๊ฒ์ด ์ค์ํ๋ค. ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ, ์ด์ง ํ์, ํฌ ํฌ์ธํฐ, ๋น๋์ ๊ณ์ฐ ๋ฑ ๋ค์ํ ๊ธฐ์ ์ ์กฐํฉํด ํด๊ฒฐํด์ผ ํ๋ ๋ฌธ์ ๋ค์ด ๋ง๋ค. ์ฃผ์ด์ง ์กฐ๊ฑด์ Arrays.sort() ๋ฅผ ์ด์ฉํด์ ์ ๋ ฌํด์ผ ํ๋ ๋ฌธ์ ๋ ์๊ณ , ์ ๋ ฌ ๊ธฐ์ค์ ์ฌ์ฉ์ ์ ์ ๊ฐ์ฒด์ ๋ง๊ฒ ์ง์ ํด์ผ ํ๋ ๊ฒฝ์ฐ, Comparator ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฐ์ฒด๋ฅผ Collections.sort() ๋๋ Arrays.sort()์ ์ ๋ฌํ์ฌ ์ ๋ ฌํ๋ฉด ๋๊ณ , ์ด ๋ Java 8 ์ด์์์๋ Comparator๋ฅผ ๋๋ค ํํ์์ผ๋ก ..

๐พ ๋ฌธ์ ์ ์ฝํ
๋ฌธ์ ํ๋ค๊ฐ ๋ฐ๊ฒฌํ ๋ค๋ฅธ ์ฌ๋ ์ฝ๋์ ๋ด ์ฝ๋์ ์ฐจ์ด์ ๋ด๊ฐ ์ด ์ฝ๋ (ํ์์ ์ฝ๋)Arrays.sort(targets, (o1, o2) -> o1[1] - o2[1]); ๋จ์ด ์ด ์ฝ๋ (๊ณ ์์ ์ฝ๋)Arrays.sort(targets, (a, b) -> Integer.compare(a[1], b[1])); ์ ์ด ๋ถ์ Integer.compare() ๋ฉ์๋๋ฅผ ์ผ์๊น?๐ง ์์ธ`Arrays.sort(targets, (o1, o2) -> o1[1] - o2[1])` ๋ฐฉ์์ ๋ ์ ์์ ๋บ์
๊ฒฐ๊ณผ๋ฅผ ์ ๋ ฌ ๊ธฐ์ค์ผ๋ก ์ฌ์ฉํ๋ค. ํ์ง๋ง ์ด ๋ฐฉ์์ ์ฝ๊ฐ์ ๋ฌธ์ ์ ์ ๊ฐ์ง๊ณ ์๋ค. ์ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด intํ์ ๋บ์
์ฐ์ฐ ๊ณผ์ ์์ ์ค๋ฒํ๋ก์ฐ(overflow)๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ค. ์๋ฅผ ๋ค์ด, o1[..

ํ๊ธ์์ ํ ์์
์ ํ๋ค๋ณด๋ฉด ๊ธ์๋ฅผ ๊น๋ํ๊ฒ ์ ๋ ฌํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ํ ์
๋๋น์ ๋ง๊ฒ ๊ธ์๋ฅผ ์กฐ์ ํ๊ธฐ ์ํด ๋์ด์ฐ๊ธฐ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ๋ ์์ต๋๋ค. ํ ์นธ์ฉ ํ๋ํ๋ ์ค์ ๋ฐ๊ฟ๊ฐ๋ฉด์ ์คํ์ด์ค๋ฐ๋ฅผ ๋๋ฅด๊ฒ ๋ ๊ฒ๋๋ค. ํ์ง๋ง ํ๋งค ํ๋ชฉ์ ๊ฐ์๊ฐ ๋ง๊ฑฐ๋ ํ๊ฐ ๋ง๋ค๋ฉด ์์
์ด ํ๋ค์ด์ง๋๋ค. ์ด๋ด ๋ ๋ฐฐ๋ถ์ ๋ ฌ์ ํ์ฉํ์๋ฉด ์ผ์ด ํธํด์ง๋๋ค. ๋ฐฐ๋ถ ์ ๋ ฌ ํ๋ ๋ฒ(1) ์ฐ์ ๊ธ์๋ฅผ ์ ๋ ฌํ๊ธฐ ์ํด ์ํ๋ ์
์ ๋ธ๋ก ์ง์ ํ๊ธฐ(2) ๊ทธ๋ฆฌ๊ณ ํ๊ธ ์์
์ฐฝ ์์ชฝ์ ์์ ํญ ํด๋ฆญ(3) ๋ฌธ๋จ๋ฉ๋ด์ ์๋ ๋ฐฐ๋ถ์ ๋ ฌ ์์ด์ฝ์ ํด๋ฆญ ๋ธ๋ก์ง์ ์์ ํญ > ๋ฐฐ๋ถ์ ๋ ฌ ์์ด์ฝ ์ ํ๋จ์ถํคctrl shift T ์์ํ๋ฉด๋ฐฐ๋ถ์ ๋ ฌ ์ ์ฉ ์ ๋ฐฐ๋ถ์ ๋ ฌ ์ ์ฉ ํ ๐TMI๋ฐฐ๋ถ์ ๋ ฌ๋ ๊ธ์๋ค์ ๊ฐ๊ฒฉ์ด ๋๋ฌด ๋๊ฑฐ๋ ์กป์๋๋ ๋ฌธ๋จ์ฌ๋ฐฑ ๋๋ฆฌ๊ธฐ/์ค์ด๊ธฐ `Ctrl + F..

์ผ๋ฐ์ ์ผ๋ก ๋ฐฐ์ด ์ ๋ ฌํ ๋ ์ฐ๋ ๋ฉ์๋ `Arrays.sort()` ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋๋ค. ํ์ง๋ง ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ์ ๋ `Arrays.sort()`์ `Comparator` ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ๋ฐ์์ ๋ง์ถคํ ์ ๋ ฌ์ ์ํํ ์ ์๋ค. ๊ธฐ๋ณธ `Arrays.sort()`์ฌ์ฉimport java.util.Arrays;public class Main { public static void main(String[] args) { Integer[] arr = {5, 2, 9, 1, 3}; // ๊ธฐ๋ณธ ์ ๋ ฌ (์ค๋ฆ์ฐจ์) Arrays.sort(arr); System.out.println(Arrays.toString(arr));..

๊ฐ์์๊น ์นด๋ ๋ง์ถ๊ธฐ ๋ฉ๋ชจ๋ฆฌ ๊ฒ์์ด๋ผ๊ณ ๋ ํ๊ณ ใ
ใ
ใ
๊ธฐ์ต๋ ฅ ์นด๋๊ฒ์์ด๋ผ๊ณ ๋ ํ๋๋ฐ.... ์์๋ง ๋ฃ์ผ๋ฉด ์ฌ์ฌํ๋๊น ๊ณผ์ผ์ด๋ชจ์ง๋ ํจ ๊ฐ์ด ๋ฃ์ด๋ณด๊ฒ ์ต๋๋ค ์๋ฐ ์คํฌ๋ฆฝํธ ์ฐ์ต ๊ฒธ ์๊ฐ ๋ ๋ ํด ๋ณด์ ใ
ใ
ใ
ใ
โ๋
ธ๊ฐ๋ค ๋ฐฉ์ง ํํ โ ์นด๋๋ 12์ฅ(6์)๋ง ๋ง๋ค์ 1. ์์๋draw.io๋ก ์์ฑํ๊ณ , svg ํ์ผ๋ก ๋ด๋ณด๋ด๊ธฐ ํจ. PNG๋ JPEG๋ ํด์๋ ์ค์ ์ํ๋ฉด ๊นจ์ง๋ ์ฃผ์ 2. ์
ํ ํ ์นด๋ ์์ฑํ๊ธฐ ์๋ฐ์คํฌ๋ฆฝํธ๊ฐ ์๋, CSS๋ก ๋ค์ง๊ธฐ๋ฅผ ํด ์ค๊ฒ์
๋๋ค.... 2-1. CSSํด๋์ค์ด๋ฆ์ญํ CSScard์นด๋ ์ ์ฒด๋ฅผ ๊ฐ์ธ๋ ์ปจํ
์ด๋์นด๋ ํฌ๊ธฐ, 3D ์์ ์ค์ card-inner์นด๋ ์์ ์์์ ์นด๋ ์,๋ท๋ฉด ๊ฐ์ธ๋ ๋ด๋ถ ์ปจํ
์ด๋์นด๋ ๋ค์ง์ ๋ transform: rotateY() ํ์ ์ถ card-front์นด๋..

1. ์ ๋ค๋ฆญ์ค(Generics) ์ ๋ค๋ฆญ์ค๋?์ ๋ค๋ฆญ์ค(generics)๋ ์๋ฐ J2SE 5.0 ๋ฒ์ ์ดํ์ ๋์
๋ ๊ฐ๋
์ผ๋ก, ์๋ฃํ์ ์์ ํ๊ฒ ์ฌ์ฉํ ์ ์๋๋ก ๋ง๋ค์ด ์ฃผ๋ ๊ธฐ๋ฅ์ด๋ค. ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ฃํ์ ๊ฐ์ ๋ก ๋ฐ๊ฟ ๋ ์๊ธธ ์ ์๋ ์บ์คํ
(Casting) ์ค๋ฅ๋ฅผ ์ค์ผ ์ ์๋ค. ArrayList๋ ์๋ฐ์ **์ ๋ค๋ฆญ์ค(Generics)**๋ฅผ ํ์ฉํ๋ ๋ํ์ ์ธ ์ปฌ๋ ์
ํด๋์ค์ด๋ค. ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ๋ฉด ArrayList์ ์ ์ฅํ ์์์ ํ์
์ ์ง์ ํ ์ ์๊ณ , ๋๋ถ์ ํ ๋ณํ ์์ด ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค. (ํ์
์์ ์ฑ ๋ณด์ฅ) ArrayList๋ ArrayList ํํ๋ก ์ ์ํ๋๋ฐ, ์ฌ๊ธฐ์ E๋ ์ ์ฅํ ์์์ ํ์
์ ๋ํ๋ด๋ ํ์
๋งค๊ฐ๋ณ์์ด๋ค. ArrayList,ArrayList์ฒ๋ผ ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ..