Language
99

Parcel ์ด์ฉ ๋ฐฉ๋ฒ.
์น ๋ธ๋ผ์ฐ์ ์ ๋์ธ ์ ์๋ ์ธ์ด๋ HTML, CSS, JS ์ด ์ธ ๊ฐ ๋ฟ์ด๋ค. TS(typescript)๋ JS๋ฅผ ๋ ์ฝ๊ฒ ์ฐ๊ธฐ ์ํ์ฌ ๋์จ ์ธ์ด ์ด์ง๋ง ์ด ์ฝ๋๋ ์น ๋ธ๋ผ์ฐ์ ์ ๋์ธ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณํ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํ๋ค. ์ด ๋ณํ ๊ณผ์ ์ ์๋์ผ๋ก ํด์ฃผ๋ Module์ด ๋ฐ๋ก Parcel์ด๋ค. Parcel์ ๋ ๋ค๋ฅธ ์ฅ์ ์ ๋น๋๊ฐ ๋น ๋ฅด๊ณ ์ฝ๋ค๋ ๊ฒ์ด๋ค. ๋ํ ์ฐ๋ฆฌ๋ JS์์์ ์ค์ ํ์ผ์ธ package.json์ ์ด์ฉํด, test ์ํฉ๊ณผ ๋ฐฐํฌ ์ํฉ ๊ฐ๊ฐ ๋น๋๋ฅผ ๋ค๋ฅด๊ฒ ํด์ฃผ๋ ํ๊ฒฝ์ ๋ง๋ค ๊ฒ์ด๋ค. 1. package.json ์์ ๋ด์ฉ ์์ "scripts": { "dev": "parcel ./index.html", "build": "parcel build ./index.html" } package.j..
2023.03.22
Language/JS

NPM ์์
1. ํ๋๊ทธ๋? --version , -v, --save-dev ์ด๋ฐ -(middle hyphen) ์ฌ์ฉํ ๋ช
๋ น์ด๋ค์ ํ๋๊ทธ๋ผ๊ณ ํ๋ค. 2. NPM ์์ ์ด์ ์ฐ๋ฆฌ๊ฐ ์ธ ๋ชจ๋๋ค์ ์ค์นํด์ฃผ๊ณ , ๊ด๋ฆฌํด์ฃผ๋ NPM์ ๊น์ ๋ณด๊ฒ ๋ค. ์ฐ๋ฆฌ๊ฐ NPM์ ๊น๋ ค๋ ํ์ผ์ ์ ํํ๊ณ , ๊ทธ ํ์ผ ๋ฐ์ ํฐ๋ฏธ๋์์ ํด๋น ๋ช
๋ น์ด๋ฅผ ์น๋ฉด ๋๋ค. ๋ช
๋ น์ด npm init, npm init -y npm init ๋ง ์น๊ฒ ๋๋ค๋ฉด, ๊ทธ ํ ์ฐ๋ฆฌ๋ ์ฐ๋ฆฌ๊ฐ ์ค์นํ NPM์ ๋ฉํ ๋ฐ์ดํฐ ์ ๋ณด๋ฅผ ๋ฐ๋ก ์ ์ด์ค์ผ ํ๋ค. ์ด๋ฌํ ๊ณผ์ ์ด ์ซ๋ค๋ฉด, npm init -y๋ฅผ ์น๋ฉด ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฉํ ๋ฐ์ดํฐ ์ ๋ณด ์ ๋ ๊ณผ์ ์ ์๋ตํ๋ค. 3. NPM์ ๋ด๋ถ๊ตฌ์กฐ (1)์ ์ฒด ๊ตฌ์กฐ ์ฐ๋ฆฌ๊ฐ NPM์ ๊น๋ฉด ๋ฐ๊ณผ ๊ฐ์ ๊ตฌ์กฐ๊ฐ ๋๋ค. ์ฌ๊ธฐ์ package-lock.jso..
2023.03.22
Language/JS
NPM์ด๋?
Package๋ Module์ด๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ฉฐ, ํ๋ก๊ทธ๋จ๋ณด๋ค๋ ๊ท๋ชจ๊ฐ ์์ ๊ธฐ๋ฅ๋ค์ ์๋ฏธํ๋ค. NPM์ด๋ Node Package Manager์ ์ฝ์๋ก, ์น์์ Packager๋ค์ ๋ค์ด๋ฐ์์ ์ค์น ํด์ฃผ๊ณ , ๊ด๋ฆฌ ํด์ฃผ๋ ํด์ ๋งํ๋ค. ์ฐ๋ฆฌ๋ ์ง์ ์ง๊ณ ์ถ๋ค. ํ์ง๋ง ๋๋ฌด ํ์์ ๋๋งน์ด, ์ฒ ๋ง ์๋ค๊ณ ํด์ ์ง์ ์ง์ ์ ์๋ค. ์ง์ ์ง๊ธฐ ์ํด ํ์ํ ๊ตด์ญ๊ธฐ, ์ง๊ฒ์ฐจ, ๋ง์น, ํฑ ๊ฐ์ ๊ฒ์ด ์์ด์ผ ํ๋ค. Module์ ์ด๋ฌํ ๊ตด์ญ๊ธฐ, ์ง๊ฒ์ฐจ, ๋ง์น, ํฑ ๊ฐ์ ๊ฒ์ด๊ณ , NPM์ ์ด๋ฐ ๊ฒ๋ค์ ๋ฐ์๋ค ๊ด๋ฆฌํด์ฃผ๋ ์น๊ตฌ๋ผ ์๊ฐํ๋ฉด ํธํ๋ค.
2023.03.22
Language/JS
Runnable
runnable๋ Thread์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ณ๋ ฌ ์ํ์ ํ๊ธฐ ์ํ ๊ฒ์ด๋ค. ๋์ ์ฐจ์ด๋ ๋ค์๊ณผ ๊ฐ๋ค. Thread๋ ํด๋์ค์ด๊ณ runnable์ ์ธํฐํ์ด์ค๋ ๊ฒ์ด๋ค. ๋จ์ผ ์์ ์์น์ ๋ฐ๋ผ Thread๋ฅผ ์์ํ ์์ ํด๋์ค๋ ๋ค๋ฅธ ๋ถ๋ชจ ํด๋์ค๋ฅผ ์์ํ์ง ๋ชปํ์ง๋ง, runnable๋ฅผ ๊ตฌํํ ํด๋์ค๋ ๋ณ๋ ฌ์ฒ๋ฆฌ ๊ธฐ๋ฅ์ ์ฐ๋ฉด์ ๋ค๋ฅธ ํด๋์ค๋ ์ธํฐํ์ด์ค๋ฅผ ์ฅ์ฐฉํ ์ ์๋ค. 1. ์ฝ๋ ๋ฆฌ๋ทฐ import Chap_12.clean.CleanRunnable; public class _02_Runnable { public static void main(String[] args) { // ์ฐ๋ ๋๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ 2๊ฐ์ง // 1. Thread ๋ผ๋ ํด๋์ค ์์ํด์ ๋ง๋ค๊ธฐ // 2, Runnable ์ด๋ผ๋ ์ธํฐํ์ด์ค ๊ตฌํํด์ ๋ง..
2023.03.11
Language/Java

Thread
1. ์ฉ์ด์ ๋ฆฌ (1) ํ๋ก๊ทธ๋จ์ด๋? ํน์ ์์
์ ์ํํ๊ธฐ ์ํด ๋ง๋ค์ด์ง ๊ธฐ๊ณ. (๊ฐ๋ ์ํ๋ ์ํ, ์ฃฝ์ ์ํ) (2) ํ๋ก์ธ์๋? ์๋ํ๋ ์ํ์ ํ๋ก๊ทธ๋จ์ ์ผ์ปซ๋ ๋ง (๊ฐ๋ ์ค์ธ ์ํ, ์ด์์๋ ์ํ) (3) ์ฐ๋ ๋๋? ํ๋ก์ธ์๋ฅผ ์๋์ํค๊ณ ์๋ ๋
์์ผ๋ก, ํน์ ์์
์ ์ํ์ค (๊ธฐ๊ณ๋ฅผ ๋๋ฆฌ๊ณ ์๋ ์ธ๋ถ) (4) ํ๋ก์ธ์ค๋? ํ๋ก๊ทธ๋จ์ด ๋ค์ด์ ์์
์ ์ฒ๋ฆฌํ๋ ๊ณต๊ฐ. ๋ณดํต ์ค์ ์ํ๋ฉด, ํ๋์ ํ๋ก์ธ์ค์ ํ๋์ ์ฐ๋ ๋๋ง ์กด์ฌํ๋ค. ํ๋ก์ธ์ค์ ์ฌ๋ฌ ๊ฐ์ ์ฐ๋ ๋๋ฅผ ๋๋ ค์ ํ๋ก๊ทธ๋จ๋ค์ด ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋๋๋ก ํ ์ ์๋ค. (ํ์ง๋ง ์ด๊ฒ ์ง์ง๋ก ์ผ์ด ๋์์ ์งํ๋๋ ๊ฒ์ด ์๋๋ผ, ๋ ๊ฐ์ง ์ผ์ด ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌ๋๊ณ ์์ง๋ง, ๊ทธ ๋์ด ์ค์์นญ ํ๋ ๊ฒ ๋๋
ธ๋ฏธํฐ ์ด๋ก ์ด๋ฃจ์ด์ ธ์, ์ฌ๋๋ค ๋์๋ ๊ทธ๊ฒ ๋ณ๋ ฌ ์ฒ๋ฆฌ ํ๋ ๊ฒ์ฒ๋ผ ..
2023.03.09
Language/Java
Throws (์์ธ ์ฒ๋ฆฌ ๋ฏธ๋ฃจ๊ธฐ)
Throws ํด๋น ๋งค์๋์์ ์ผ์ด๋ ์ ์๋ ์์ธ๋ฅผ ์์ฒด์ ์ผ๋ก ํด๊ฒฐ ์ํ๊ณ , ๋ ๋ชฐ๋ผ๋ผ ํ๊ณ ๋ฐ์ผ๋ก ๋์ง๋ ๋ช
๋ น์ด ๋งค์๋๋ฅผ ํธ์ถํ ์ชฝ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผ ํ๋ค. ์ฑ
์์ ๊ฐํ๋ ๋ช
๋ น์ด ๋งค์๋๋ฅผ ํธ์ถํ ์ชฝ์์ ๋ throws ์ฐ๋ฉด, ๊ทธ๋ฅ ํ๋ก๊ทธ๋จ ํผ์ ธ๋ ์ฑ
์ ์ ์ง๊ฒ ๋ค๋ ์๋ฆฌ์. import java.io.FileWriter; import java.io.IOException; public class _07_Throws { public static void main(String[] args) { // ํธ์ถํ ๋ฉ์ธ ๋งค์๋์์ ํด๊ฒฐํ๊ฑฐ๋, ์ฌ๊ธฐ์๋ throws๋ก ๋๋ชฐ๋ผ๋ผ ํ๊ฑฐ๋ // ๋ฉ์ธ ๋ฉ์๋์์๋ throws๋ก ๋์ง๋ฉด ๊ทธ๋ฅ ๋ฌธ์ ์๊ธฐ๋ ๊ฑฐ ๊ฐ์ํ๊ณ ๋๋ฆฌ๊ฒ ๋จ ์๋ฆฌ์. try { writeFile(); } catc..
2023.03.02
Language/Java
์ฌ์ฉ์ ์ ์ ์์ธ
์์ธ๋ฅผ ํญ์ throw new Exception(" ์์ธ ๋ฐ์ ์ ํ๊ณ ์ถ์ ๋ง"); ๋ก ํ๋ค๋ฉด, ๋ง์ง๋ง catch ๊ตฌ๋ฌธ์์ ํ ์ผ์ด ๋๋ฌด ๋ง๋ค. Exception์ด๋ ํน์ ์ ์ด์ง ์๊ณ ๋ชจ๋ ๊ฑธ ํฌ๊ดํ๋ ์์ธ์ ๋์ก๊ธฐ ๋๋ฌธ์, ()์์ ๋ง์ด ์๋๋ฉด ๋ฌด์จ ์ด์ ๋์ ์์ธ๊ฐ ์ผ์ด๋ฌ๋์ง ์๊ธฐ๋ ์ฝ์ง ์๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ๊ฐ ์ง์ ํน์ ์๊ฐ์๋ง ์๋ํ๋ ์์ธ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ๊ทธ ์์ธ ๊ฐ์ฒด๋ฅผ ์ด์ฉํ์ฌ ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ ๋ ค๊ณ ํ๋ค. public class _06_CustomException { public static void main(String[] args) { // ์ฌ์ฉ์ ์ ์ ์์ธ int age = 17; try { if(age < 19){ // System.out.println("๋ง 19์ธ ๋ฏธ๋ง์๊ฒ๋ ํ๋งคํ์ง ์์ต..
2023.03.02
Language/Java
Try with Resources
1. ์ค๋ช
AutoClosable์ด๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ try๊ตฌ๋ฌธ ()์์์ ์์ฑ ํ์ ๋๋ฅผ ๊ฐ์ ํ๋ค. ํด๋น ๊ฐ์ฒด๊ฐ try catch ๊ตฌ๋ฌธ์ ๋ค ์ง๋๊ฐ์ผ๋ฉด, try ๊ตฌ๋ฌธ์ด ์๋์ผ๋ก close ๋งค์๋๋ฅผ ํธ์ถํ์ฌ close์ ๊ธฐ๋ฅ์ ์ํํ๊ฒ ํ๋ค. ํด๋น ์คํฌ์ ํด๋์ค๊ฐ AutoClosable์ด๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํ ํด์ผ๋ง ์ธ ์ ์๋ค. 2. ์ฝ๋ ๋ฆฌ๋ทฐ import java.io.BufferedWriter; public class _05_TryWithResources { public static void main(String[] args) { // close ๊ตฌ๋ฌธ๋ ์์ธ์ฒ๋ฆฌ๊ฐ ํ์ํด์ // try-catch-finally ๊ตฌ๋ฌธ ์์ ๋ try catch ๊ตฌ๋ฌธ์ด ๋ค์ด๊ฐ ๊ฑธ ๋ณผ ์ ์๋ค. MyF..
2023.02.28
Language/Java
Finally ๊ตฌ๋ฌธ
1. ์ค๋ช
์์ธ ๊ตฌ๋ฌธ์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๊ฑด ๋ง๊ฑด ์์ธ์ฒ๋ฆฌ ํ ๋ฌด์กฐ๊ฑด ์คํํด์ผํ๋ ์ฝ๋๋ฅผ ์ ์ด ๋๋ ๊ตฌ๋ฌธ 2. ์ฝ๋๋ฆฌ๋ทฐ public class _04_Finally { public static void main(String[] args) { try{ System.out.println("ํ์์ ๋ฌธ์ ์ฐ๋ค."); throw new Exception("ํด๋ฌด ํ์"); // System.out.println("ํ์์ ํ์นํ๋ค."); // ์์ธ๋ฅผ ๋์ง๋ ๋ฌธ์ฅ ์ฃผ์ ์ฒ๋ฆฌ ํ๊ณ ํ์๋ฅผ ํ์นํ๋ค๋ ์ ์ ์ถ๋ ฅ๋ฌธ์ด ๋์๋ finally ๊ตฌ๋ฌธ ์คํ } catch (Exception e) { System.out.println("!! ๋ฌธ์ ๋ฐ์: " + e.getMessage()); } finally { System.out.pri..
2023.02.28
Language/Java

Throw
1. ์ ์ ์ผ๋ถ๋ฌ ์์ธ๋ฅผ ๋ฐ์ ์ํค๋ Keyword (1)ํํ // ๋ด๊ฐ Catch ์ชฝ์ผ๋ก ๋์ง ์๋ก์ด ์์ธ ๊ฐ์ฒด ์์ฑ throw new Exception("๋ฌด์จ ์๋ฌ์ธ์ง ์ค๋ช
"); // throw์์ ๋์ง ์์ธ ๊ฐ์ฒด๋ Catch์์ ๋ฐ์์ ์ฒ๋ฆฌํ๋ค. 2. ์ฝ๋ ๋ฆฌ๋ทฐ public static void main(String[] args) { //๋์ด๊ฐ 19์ธ ๋ฏธ๋ง์ผ ๊ฒฝ์ฐ ์์ธ ์ฒ๋ฆฌ. int age = 17; try { if(age < 19){ throw new Exception("๋ง 19์ธ ๋ฏธ๋ง์๊ฒ๋ ํ๋งคํ์ง ์์ต๋๋ค."); } else { System.out.println("์ฃผ๋ฌธํ์ ์ํ ์ฌ๊ธฐ ์์ต๋๋ค."); } }catch (Exception e){ //์ค๋ฅ๊ฐ ๋ฌด์์ธ์ง ๋ณด์ฌ์ฃผ๋ ์์ธ ๊ฐ์ฒด ๋งค์๋ e.p..
2023.02.24
Language/Java
์ค๋ฅ์ ๋ฐ๋ฅธ ๋ง์ถค ์์ธ ์ฒ๋ฆฌ
1. ๊ฐ๋ณ ์์ธ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ Exception ํด๋์ค๋ ๋ชจ๋ ์์ธ๋ค์ ์กฐ์ ํด๋์ค ์ด๋ค. ๊ทธ๋์ ๋ชจ๋ ์์ธ๋ฅผ ๋คํ์ฑ์ ์๋ฆฌ์ ์ํด ๋ค ๋ฐ์ ์ ์์๋ ๊ฒ์ด๋ค. catch์ () ์์ ์์ธ๋ณ๋ก ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ฃผ๋ฉด, ํด๋น ์์ธ๊ฐ ๋ฐ์ ํ์ ์์๋ง ๋ฐ๋ํ๋ ์์ธ ์ฒ๋ฆฌ ๊ตฌ๋ฌธ์ ๋ง๋ค ์ ์๋ค. // ๋ฐฐ์ด ์ธ๋ฑ์ค๋ฅผ ๋ฒ์ด๋ ๊ณณ์ ๋ํ ์์ค ์คํ์ ํ ๊ฒฝ์ฐ์ ์์ธ์ฒ๋ฆฌ๋ฌธ, // ์๋ชป๋ ํ๋ณํ์ด ์ผ์ด๋ฌ์ ๊ฒฝ์ฐ์ ์์ธ์ฒ๋ฆฌ๋ฌธ์ ๋ฐ๋ก ๋์๋ค. // ๋งจ ๋ง์ง๋ง์ ๋๋จธ์ง ์์ธ๋ค์ ๋ํ ์ผ๊ด ์ฒ๋ฆฌ์ด๋ค. catch (ArrayIndexOutOfBoundsException e){ System.out.println("์ธ๋ฑ์ค๋ฅผ ์๋ชป ์ค์ ํ์ด์."); } catch (ClassCastException e) { System.out.println(..
2023.02.23
Language/Java

Run-Time(๋ฐํ์) ์ค๋ฅ์ ์์ธ ์ฒ๋ฆฌ
1. ๋ฐํ์ ์ค๋ฅ๋? (1)๋ฐํ์์ค๋ฅ์ ์ปดํ์ผ ์ค๋ฅ ๋น๊ต ์ข
๋ฅ ์ปดํ์ผ ์๋ฌ ๋ฐํ์ ์๋ฌ ๋ป ์์ค์ฝ๋๋ฅผ ๊ธฐ๊ณ์ด๋ก ๋ฐ๊ฟ ๋ (์ปดํ์ผ ์) ์ผ์ด๋๋ ์๋ฌ. ๋๊ฒ ๋ฌธ๋ฒ์ ์ค๋ฅ๋ก ์ธํด ์ผ์ด๋๋ค. ์ฝ๋ ์คํ ๋์ค์ ์ผ์ด๋๋ ์๋ฌ ์ฝ๋๊ฐ ๋ฌธ๋ฒ์ ์ผ๋ก ๋ง์ ๋์ง๋ง, ๋
ผ๋ฆฌ์ ์ผ๋ก ๋ง์ด ์๋ ๋ ์ผ์ด๋๋ค. Run ํ์ ์ ์ ์ด์ ๋ฌธ๋ฒ์ ์ผ๋ก ํ๋ ค์ Run ์กฐ์ฐจ ์๋๋ค. ๋ฐํ์ ์ค๋ฅ ์์ ์ ํ๋ก๊ทธ๋จ์ ์ฝ๋๋ฅผ ๋๊น์ง ์คํํ์ง ๋ชปํ๊ณ ์ข
๋ฃ๋๋ค. (๋ฐํ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ง์ ์์ ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋๋ค.) ์์ int i = "๋ฌธ์์ด"; (์ ์ด์ ๋ง์ด ์๋๋ ๊ตฌ์กฐ) int[] arr = new int[3]; arr[5] = 100; ํด๋น ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 3์ด๋ฏ๋ก, 5์ ๊ฐ์ ์ง์ด ๋ฃ์ ์ ์๊ธฐ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค. ์ฝ๋ ํ ์ค ํ ์ค์ ๋ฌธ๋ฒ..
2023.02.23
Language/Java
[JAVA] Stream ์ค์ต
1. ์ฝ๋๋ฆฌ๋ทฐ // "python", "java", "javascript","c","c++","c#" // C๋ก ์์ํ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ถ์ถ /*.startsWith()๋ String ํด๋์ค์ ๋งค์๋๋ก์ ()์์ ๊ฐ์ด ๋ฌธ์์ด์ ์๋์ง๋ฅผ boolean์ผ๋ก ๋ฐํ .filter()๋ ()์์ ์กฐ๊ฑด์ ๋ง๋ ์์๋ง ๊ณจ๋ผ์ ๋ง๋ ์ ์คํธ๋ฆผ์ ๋ฐํ */ Arrays.stream(langs).filter(x-> x.startsWith("c")).forEach(System.out::println); System.out.println("-----------------------------------------"); // java ๋ผ๋ ๊ธ์๋ฅผ ํฌํจํ๋ ์ธ์ด Arrays.stream(langs).filter(x-> x.co..
2023.02.19
Language/Java
[JAVA] Stream
1. Stream ์ด๋? (0) ๋ป ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์
ํ๋ ์์ํฌ ์์ ์ ์ฅ๋ ์์๋ค์ ํ๋์ฉ ์ํ ํ๋ฉด์ ์ฝ๋๋ฅผ ์คํํ ์ ์๋ ๊ธฐ๋ฅ์ ๋งํจ. ๋ด๋ถ์ ๋ฐ๋ณต์๊ฐ ๋ฐ๋ก ์กด์ฌํจ. Java 8๋ถํฐ ์ถ๊ฐ ๋์๊ณ , ๊ทธ ์ด์ ์์ ์๋ ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์
์ ๋ํ ์ํ ์ฐ์ฐ์ ํ ๋๋ for, foreach๋ฅผ ์จ์ผ ํ๊ฑฐ๋ Iterator ์จ์ผํด์ ์ฝ๋ ์๊ฐ ๋ง์์ง๊ณ ์ง์ ๋ถ ํ์. ํ์ง๋ง Stream ๋์ ์ฝ๋๊ฐ ๊ฐํธํด์ง๊ณ ๊ฐ๋
์ฑ์ด ์ข์์ง. (1) ์์ฑ a. ๊ธฐ๋ณธ ์๋ฃํ ๋ฐฐ์ด์ ๋ํ Stream ์์ฑ **์ฐธ๊ณ : ๋ฐฐ์ด(a,b)๋ ๋ฐฐ์ด์ ๋ํ ๋ค์ํ ๋งค์๋๊ฐ ์ ์ฅ๋์ด ์๋ Arrays ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ Stream ์์ฑ // int ๋ฐฐ์ด ์์ฑ int[] scores = {100, 95,90,85,80}; // Arrays.stre..
2023.02.18
Language/Java

[JAVA] ๋๋ค์๊ณผ ํจ์ํ ์ธํฐํ์ด์ค
1. ๋๋ค์ (1) ์ ์ ์ต๋ช
ํจ์ (์ด๋ฆ์ด ์๋ ํจ์) == ์ ๊ทผ์ ์ด์, ๋ฐํํ, ํจ์์ด๋ฆ, ํ๋ผ๋ฏธํฐ์ ์๋ฃํ ๋ค ํ์ ์์. ๋๋ค์๋ ์ผ๊ธ ๊ฐ์ฒด์ด๋ค. **์ผ๊ธ ๊ฐ์ฒด๋? ๋ฐ์ดํฐ๋ ๋ณ์๋ฅผ ๋ฐ์ ์ ์๋ ๊ฐ์ฒด, ์ด๋ค ๋งค์๋์ ํ๋ผ๋ฏธํฐ๋ก ๋ค์ด๊ฐ ์ ์๋ ๊ฐ์ฒด, ์ด๋ค ๋งค์๋์ ๋ฐํ ๊ฐ์ด ๋ ์ ์๋ ๊ฐ์ฒด ์ด๋ค. (2) ํํ (์ ๋ฌ๊ฐ 1, ์ ๋ฌ๊ฐ2, ...) -> { ์คํ์ฝ๋ } 2. ํจ์ํ ์ธํฐํ์ด์ค (1) ๋ป ์ถ์ ๋งค์๋๊ฐ ์ค์ง ํ๋ ๋ฟ์ธ ์ธํฐํ์ด์ค (2)๋๋ค์๊ณผ์ ๊ด๊ณ ๋๋ค์์ ์ค์ง ํจ์ํ ์ธํฐํ์ด์ค๋ก๋ง ์ ๊ทผ ๊ฐ๋ฅ. ** why? ์ธํฐํ์ด์ค์ ์ถ์ ๋งค์๋๊ฐ ๋ ๊ฐ์ด๋ฉด, ๋๋ค์๊ณผ ๋งค์นญ๋๋ ์ถ์ ๋งค์๋๊ฐ ๋ฌด์์ธ์ง ๋ชจํธํด์ง๋ค. ๋ฐ๋ผ์ ์ถ์ ๋งค์๋๊ฐ ์ค์ง ํ๋์ธ ํจ์ํ ์ธํฐํ์ด์ค๋ง์ด ๋๋ค์๊ณผ ๋งค์นญ์ด ๊ฐ๋ฅํ์ฌ ์ธ ์..
2023.02.16
Language/Java

[JAVA] ์ต๋ช
ํด๋์ค
1.์ ์ ์ต๋ช
ํด๋์ค== ์ด๋ฆ ๋ชฐ๋ผ๋ ๋๋ ํด๋์ค == ๋ค์ ๋ถ๋ ค์ ์ฐ์ผ ์ผ์ด ์๋ ํด๋์ค == 1ํ์ฉ ํด๋์ค ๊ฐ์ฒด ๋ง๋ค ๋, ๊ทธ ๊ฐ์ฒด์ ํ์ํ ๋งค์๋ ์ฌ์ ์, ์ถ์ํ ํจ์ ์ค์ฒดํ๋ฅผ ๊ฐ์ด ํด๋ฒ๋ฆผ. (์ด๊ฑด ํด๋น ๋ด์ฉ์ผ๋ก ๋ค์ ์ฐ์ผ ์ผ์ด ์์ ๋ ์ ์ฉํ๋ค. ๋ง์ฝ ์ฌ์ฌ์ฉ์ด ํ์ํ๋ค๋ฉด ์์ ํด๋์ค๋ก ๋ง๋ค์ด๋๊ณ ์จ์ผํจ.) 2. ์ผ๋ฐ ํด๋์ค์ ๋ํ ์์ ์์ด ๋ค๋ฅธ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๊ฒฝ์ฐ (1) ์ฐ๋ฆฌ๊ฐ ์ธ ํด๋์ค class Coffee{ public void order(String coffee){ System.out.println("์ฃผ๋ฌธํ์ " + coffee + "๋์์ต๋๋ค. "); } public void returnTray(){ System.out.println("์ปคํผ ๋ฐ๋ฉ์ด ์๋ฃ๋์์ต๋๋ค."); }..
2023.02.15
Language/Java

[JAVA] Iterator
1. ๋ป ๋ฐฐ์ด, ์ปฌ๋ ์
ํ๋ ์ ์ํฌ๋ฑ์ ์ํํ ๋, ์ง๊ธ ์์น๊ฐ ์ด๋์ง ์๋ ค์ฃผ๋ '์ฑ
๊ฐํผ ๊ฐ์ ์กด์ฌ' Iterator๋ฅผ ์ํ๋ ์์น๋ก ์ด๋ ์์ผ์ ์ํ๋ ์์
(์กฐํ, ์ถ๊ฐ, ์ญ์ )์ ์ํจ๋ค. (1)Iterator์ ์ด๊ธฐ ์์น (2) ๋ฐ๋ณต์ ์ ์ ๋ Tip ๋ฐ๋ณต์ ์ ์ธ๋ฌธ์ ์ค๋ฅธ์ชฝ ํธ๋ง ๋ค ์ ์ด๋๊ณ , iterator(); ์ ctrl + alt + V ๋๋ฅด๋ฉด ์ผ์ชฝ์ด ์๋ ์์ฑ๋จ. Mudo.entrySet().iterator(); //ctrl + alt + v Iterator itEn3 = Mudo.entrySet().iterator(); 2. ์ฝ๋๋ฆฌ๋ทฐ package Chap_09; import java.util.*; public class _08_Iterator { public static void main..
2023.02.15
Language/Java
[JAVA] HashMap
1. HashMap ํน์ง (1) HashSet๊ณผ ๋๊ฐ์ด ์์ ๋ณด์ฅ x, ์ค๋ณต ํ์ฉ x ์ด๋ค. (Key๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ณต ์ฌ๋ถ check ํ๊ณ , ์ค๋ณต๋ Key๊ฐ์ด ๋ค์ด์ฌ ์, ๊ฐ์ฅ ์ต๊ทผ์ ์
๋ฐ์ดํธ ๋ Value๊ฐ์ ์ ์ฅํ๋ค. ) (2) HashMap์ (Key, Value) ํ ์์ผ๋ก ์ด๋ฃจ์ด์ ธ์๋ค. Key๊ฐ ์ฌ๋ฌผํจ ์ด์ , Value๊ฐ ์ฌ๋ฌผํจ์ ๋ค์ด์๋ ๊ฐ์ด๋ผ ์๊ฐํ๋ฉด ๋๊ฒ ๋ค. Key ํ๋๋น Value๋ ๋ฌด์กฐ๊ฑด ํ ๊ฐ์ด๋ค. (3) Key์ Value๋ ์๋ฃํ์ด ์๋ก ๋ค๋ฅผ ์ ์๋ค. (์๋ฃํ์ Wrapper ํด๋์ค๋ง ๊ฐ๋ฅ) 2. ์ฝ๋ ๋ฆฌ๋ทฐ import java.util.HashMap; public class _07_HashMap { public static void main(String[] args) { //..
2023.02.13
Language/Java

[JAVA]HashSet
1. HashSet์ด๋? Collection FrameWork์ ์ข
๋ฅ ์ค ํ๋ (์ปฌ๋ ์
ํ๋ ์ ์ํฌ์๋ List,Set,Map ์ด ์๋ค.) *์ปฌ๋ ์
ํ๋ ์ ์ํฌ๋? ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๋ ์ฝ๊ณ ,ํธ๋ฆฌํ๊ฒ, ๋ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์๋๋ก ์๋ฐ์์ ์ ๊ณตํ๋ ํด๋์ค์ ๋ชจ์. HashSet ๋ด๋ถ ๋งค์๋ ๋ค์ List์ ๋งค์๋์ ๊ฑฐ์ ๊ฐ๋ค. (์ถ๊ฐ == .add, ์ญ์ == .remove ๋ฑ๋ฑ) (1)HashSet์ ํน์ง Hashset์ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค. ๋ง์ฝ ์ค๋ณตํด์ ์ ์ด๋ ์๋์ผ๋ก ์ค๋ณต์ด ์ ๊ฑฐ ๋๋ค. Hashset์ ์์๋ฅผ ๋ณด์ฅํ์ง ์๋๋ค. ๊ฐ์ ๋ฃ์ ์์์ ์๊ด์์ด ์ ์ฅ๋๋ค. *๋ง์ฝ ๊ฐ์ ๋ฃ์ ์์๋๋ก ์ ์ฅ๋๊ธฐ ์ํ๋ค๋ฉด? LinkedHashSet์ ์ด์ฉํ๋ฉด ๋๋ค. 2. ์ฝ๋ ๋ฆฌ๋ทฐ package Cha..
2023.02.09
Language/Java

[JAVA] Linked List
1. Linked List๋? ํฌ์ธํฐ๊ฐ ๋ค์ ๋
ธ๋ ๊ฐ๋ฆฌํค๊ฒ ํด์ ์ด์ด์ ธ ์๋ ์๋ฃ๊ตฌ์กฐ. ์ค๊ฐ ์ค๊ฐ ์ฝ์
์ด ์ฌ์. (์ฌ๋๋ค์ด ์๋ก ์ ์ก๊ณ ์ผ๋ ฌ๋ก ์์๋๋ค๊ณ ์๊ฐํด๋ณด์. ์ค๊ฐ์ ์ฌ๋์ ๋ฃ์ ์ ๋ ์ฌ๋์ด ๊น์ง๋ฅผ ๋ผ๊ณ ๊ทธ ์ฌ์ด์ ๋ฃ์ผ๋ฉด ๋๋ค.) List ํํ(ArrayList, LinkedList)๋ ๋ชจ๋ ์ค๊ฐ ์ฝ์
์ด ๋๋ค. ๋ํ List ํํ๋ ๋ชจ๋ ์ค๋ณต๋ ๊ฐ ์ฝ์
์ ํ์ฉํ๋ค. 2. ์ฝ๋ ๋ฆฌ๋ทฐ import java.util.Collections; import java.util.LinkedList; public class _05_LinkedList { public static void main(String[] args) { //๋งํฌ๋ ๋ฆฌ์คํธ LinkedList list = new LinkedList(); /..
2023.02.08
Language/Java
[JAVA] ArrayList
1. ๋ฐฐ์ด vs ์ปฌ๋ ์
ํ๋ ์์ํฌ (1) ๋ฐฐ์ด ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์์. ๋ฐ๋ผ์ ๋ฐฐ์ด์ด ๊ฝ ์ฐผ๋๋ฐ, ๊ฐ์ ๋ ์ถ๊ฐํด์ผ ํ๋ ๊ฒฝ์ฐ, ๋๋ํ ํฌ๊ธฐ๋ก ๋ฐฐ์ด์ ์๋ก ๋ง๋ค์ด์ผํจ. ๊ฑฐ๊ธฐ๋ค๊ฐ ๊ธฐ์กด์ ๊ฐ๋ค ์ ์ฅ + ์๋ก์ด ๊ฐ๋ค ์ ์ฅ ์์ผ์ผํจ. ๋ฐฐ์ด์ ํน์ ์ธ๋ฑ์ค์ ์์ ๊ฐ์ ์ญ์ ํ๋ฉด, ๊ฑฐ๊ธฐ๊ฐ ๊ทธ๋ฅ ๋น์ด์๋ ์ฒด๋ก ์์. (ํฌ๊ธฐ๊ฐ ๋์ ์ผ๋ก ๋ณํํ์ง ์๊ธฐ ๋๋ฌธ) (2) ์ปฌ๋ ์
ํ๋ ์์ํฌ ์ ์ ์ธ ๋ฐฐ์ด์ ๊ฐ์ ์ ์ฅํ๋ ๊ฒ์ ๋ฐ์ดํฐ๋ค์ ๊ด๋ฆฌํ๋๋ฐ ๋ฒ๊ฑฐ๋ก์ด ์ ์ด ์์. ์ปฌ๋ ์
ํ๋ ์์ํฌ๋ ๋ง์ ์์ ๋ฐ์ดํฐ๋ค์ ๋ ์ฝ๊ณ , ํธ๋ฆฌํ๊ฒ, ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์๋๋ก JAVA์์ ์ ๊ณตํ๋ ํด๋์ค์ ๋ชจ์์ด๋ค. ์ปฌ๋ ์
ํ๋ ์์ ์๋ฐ์ ๋ฌ๋ฆฌ ํฌ๊ธฐ๊ฐ ๋์ ์ผ๋ก ๋ณํด์, ์ํ๋ ๋งํผ ๋ฐ์ดํฐ ์ถ๊ฐ, ์ญ์ ๊ฐ ๊ฐ๋ฅํ๋ค. ์ํ๋ ๊ฐ ํ์, ํน์ ๊ฐ ๋ณ๊ฒฝ,..
2023.02.07
Language/Java