-
01 ์ซ์(number)
- ์ ์
int -2147483648 ~ 2147483647 long -9223372036854775808 ~ 9223372036854775807 long ๋ณ์์ ๊ฐ์ ๋์ ํ ๋ ์ซ์ ๊ฐ์ด 2147483647 ๋ณด๋ค ํด ๊ฒฝ์ฐ L ์ ๋ฏธ์ฌ๋ฅผ ๋ถ์ฌ์ผ ํจ
(์๋ต์ ์ปดํ์ผ ์๋ฌ)
- ์ค์
float −3.4∗1038 ~ 3.4∗1038 double −1.7∗10308 ~ 1.7∗10308 ๋ํดํธ๊ฐ double, float ๋ณ์๋ฅผ ์ฌ์ฉํ๊ณ ์ถ์ผ๋ฉด F์ ๋ฏธ์ฌ๋ฅผ ๋ถ์ฌ์ผ ํจ
e2์ ๊ฐ์ด ์ฐ๋ฉด 10์ ์ ๊ณฑ ์๋ฏธ
- 8์ง์, 16์ง์
0(์ซ์ '0')์ผ๋ก ์์ํ๋ฉด 8์ง์, 0x(์ซ์ '0' + ์ํ๋ฒณ 'x')๋ก ์์ํ๋ฉด 16์ง์
int octal = 023; // ์ญ์ง์: 19 int hex = 0xC; // ์ญ์ง์: 12
์ซ์ ์ฐ์ฐ
- ์ฌ์น์ฐ์ฐ - +,-,*,/
- ๋๋จธ์ง ๋ฐํ - %
- ์ฆ๊ฐ์ฐ์ฐ - ++, --
- i++ : ๊ฐ์ด ์ฐธ์กฐ๋ ํ์ ์ฆ๊ฐ
- ++i : ๊ฐ์ด ์ฐธ์กฐ๋๊ธฐ ์ ์ ์ฆ๊ฐ
02 ๋ถ(boolean)
- ์ฐธ ๋๋ ๊ฑฐ์ง (true or false)
- boolean์ ์์ ๋ถ์ boolean isTall = height>base;
03 ๋ฌธ์(char)
- string๊ณผ ๋ฌ๋ฆฌ ํ ๊ฐ์ ๋ฌธ์๊ฐ์ ๋ํ ์๋ฃํ
- 3๊ฐ์ง ํํ๋ฐฉ์
char a1 = 'a'; // ๋ฌธ์๋ก ํํ char a2 = 97; // ์์คํค์ฝ๋๋ก ํํ char a3 = '\u0061'; // ์ ๋์ฝ๋๋ก ํํ
04 ๋ฌธ์์ด(string)
- literal ํ๊ธฐ(String a = "happy java”) : ๊ฐ์ฒด ์์ฑ์์ด ๊ณ ์ ๋ ๊ฐ์ ๊ทธ๋๋ก ๋์ , ๋ฌธ์์ด์ JVM์ intern pool ์ด๋ผ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ
- ๊ฐ์ฒด์์ฑ ๋ฐฉ์(String b = new String("happy java")) : ํญ์ ์๋ก์ด stirng ๊ฐ์ฒด ์์ฑ
Primitive ์๋ฃํ
- int, long, double, float, boolean, char ์๋ฃํ
- new ํค์๋๋ก ๊ทธ ๊ฐ์ ์์ฑํ ์ ์์
- literal๋ก๋ง ๊ฐ์ ์ง์ ๊ฐ๋ฅ
์์ ์๋ฃํ์ Wrapper ํด๋์ค
์์ ์๋ฃํ์ ๋ค์์ฒ๋ผ ๊ฐ๊ฐ์ ๋์ํ๋ Wrapper ํด๋์ค๋ค์ด ์กด์ฌ
- wrapper class๋?
- ์๋ฐ API ํด๋์ค์ค ํ๋
- ์๋ฐ์ ์๋ฃํ์ primitive type(๊ธฐ๋ณธ ํ์
) ๊ณผ reference type(์ฐธ์กฐ ํ์
)์ด ์กด์ฌ
- ๊ธฐ๋ณธ ํ์ : byte, short, char, int, long, float, double, boolean
- ์ฐธ์กฐ ํ์ : class, interface ..
- 8๊ฐ์ ๊ธฐ๋ณธ ํ์
์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ํํํ๊ธฐ ์ํด ํฌ์ฅํด ์ฃผ๋ ํด๋์ค๊ฐ ๋ฐ๋ก wrapper class(๋ํผ ํด๋์ค)
- ์๋ฅผ ๋ค์ด, ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ๋ก ๊ฐ์ฒด ํ์
๋ง์ด ์๊ตฌ๋ ๊ฒฝ์ฐ
- ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ๋ ์์ง๋ง (AutoBoxing์ ํตํด)
- ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๊ฐ์ฒด๋ก ๋ณํํ ์์ ์ ์ํํด์ผํ๋ค.
- ๊ธฐ๋ณธ ํ์
์ ๊ฐ์ ๊ฐ๋ ๊ฐ์ฒด์ธ ํฌ์ฅ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. (๊ธฐ๋ณธ ํ์
์ ๊ฐ์ ๋ด๋ถ์ ๋๊ณ ํฌ์ฅํ๊ธฐ๋๋ฌธ์ 'ํฌ์ฅ ๊ฐ์ฒด'๋ผ ์นญํ๋ค.)
- wrapper class๋ ๊ฐ ํ์ ์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ๋ฐ์, ํด๋น ๊ฐ์ ๊ฐ์ง๋ ๊ฐ์ฒด๋ก ๋ง๋ค์ด์ค๋ค.
- wrapper class๋ก ๊ฐ์ธ๊ณ ์๋ ๊ธฐ๋ณธ ํ์
๊ฐ์ ์ธ๋ถ์์ ๋ณ๊ฒฝํ ์ ์๋ค.
- ๋ณ๊ฒฝํ๊ธฐ ์ํด์ ์๋ก์ด ํฌ์ฅ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค. - Wrapper Class๋
- ์๋ฅผ ๋ค์ด, ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ๋ก ๊ฐ์ฒด ํ์
๋ง์ด ์๊ตฌ๋ ๊ฒฝ์ฐ
์์์๋ฃํ Wrapper class int Integer long Long double Double float Float boolean Boolean char Char ArrayList, HashMap, HashSet ๋ฑ์ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ ๋ ์์ ์๋ฃํ ๋์ ๊ทธ์ ๋์ํ๋ Wrapper ํด๋์ค๋ฅผ ์ฌ์ฉํด์ผ ํจ
์์ ์๋ฃํ ๋์ Wrapper ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ ๋์ ๊ฐ์ฒด๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์์ด ์ฝ๋๋ฅผ ๊ฐ์ฒด ์ค์ฌ์ ์ผ๋ก ์์ฑํ๋๋ฐ ์ ๋ฆฌํ๋ค. ๋ํ ๋ฉํฐ์ค๋ ๋ฉ ํ๊ฒฝ์์ ๋๊ธฐํ๋ฅผ ์ง์ํ๊ธฐ ์ํด์๋ Wrapper ํด๋์ค๋ ๋ฐ๋์ ํ์ํ๋ค.
๋ฌธ์์ด ๋ฉ์๋
- equals - ๋ฌธ์์ด์ด ๋์ผํ์ง ๋น๊ตํด์ ๊ฐ์ผ๋ฉด true ๋ค๋ฅด๋ฉด false (๋ฌธ์์ด ๋น๊ตํ ๋ == ๋ชป์)
- indexOf - ๋ฌธ์์ด์์ ํน์ ๋ฌธ์์ด์ด ์์๋๋ ์์น(์ธ๋ฑ์ค)๋ฅผ ๋ฆฌํด (์๋ฐ๋ ์ซ์๋ฅผ 0๋ถํฐ ์ )
- contains - ํน์ ๋ฌธ์์ด์ด ํฌํจ๋์ด ์๋์ง์ ์ฌ๋ถ๋ฅผ ๋ฆฌํด(์์ผ๋ฉด true)
- charAt - ๋ฌธ์์ด์์ ํน์ ์์น์ ๋ฌธ์(char)๋ฅผ ๋ฆฌํด
- replaceAll - ๋ฌธ์์ด ์ค ํน์ ๋ฌธ์์ด์ ๋ค๋ฅธ ๋ฌธ์์ด๋ก ๋ฐ๊พธ๊ณ ์ ํ ๋ ex) a.replaceAll(”a”,”b”);
- substring - ๋ฌธ์์ด ์ค ํน์ ๋ถ๋ถ์ ๋ฝ์๋ผ ๋ ex) substring(์์์์น, ๋์์น) → ์์์์น์์ ๋์์น-1 ์ ๋ฌธ์๋ฅผ ๋ฝ์๋
- toUpperCase - ๋ฌธ์์ด์ ๋ชจ๋ ๋๋ฌธ์๋ก ๋ณ๊ฒฝ
- split - ๋ฌธ์์ด์ ํน์ ๊ตฌ๋ถ์๋ก ๋๋์ด ๋ฌธ์์ด array๋ก ๋ฆฌํด ex) a.split(”:”)
๋ฌธ์์ด ํฌ๋งคํ
String.format ๋งค์๋ ์ฌ์ฉ ex) String.format(”i love %s”, “you”)
๋ณ์๋ ๋ ๊ฐ ์ด์์ ๊ฐ๋ ๋์ ๊ฐ๋ฅ
%s ๋ฌธ์์ด(String) %c ๋ฌธ์ 1๊ฐ(character) %d ์ ์(Integer) %f ๋ถ๋์์(floating-point) %o 8์ง์ %x 16์ง์ %% Literal % (๋ฌธ์ % ์์ฒด) %s → ์ด๋ค ํํ์ ๊ฐ์ด๋ (์ ์, ์์..) ์ ๋ฌ๋๋ ํ๋ผ๋ฏธํฐ ๊ฐ์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด ์ฌ์ฉ
%10s → ์ ์ฒด ๊ธธ์ด 10์ธ ๋ฌธ์์ด ๊ณต๊ฐ, ๋์ ๋๋ ๊ฐ์ ์ค๋ฅธ์ชฝ ์ ๋ ฌํ๊ณ ๋๋จธ์ง๋ ๊ณต๋ฐฑ์ผ๋ก
**System.out.printf**
String.format ๊ณผ System.out.printf
์ ์) ๋ฌธ์์ด ๋ฆฌํด, ํ์) ๋ฌธ์์ด ์ถ๋ ฅ
String.format ์์ด ๋ฐ๋ก ํฌ๋งคํ ํด์ ๋ฌธ์์ด ์ถ๋ ฅํ๋ ํจ์
05 StringBuffer
- ๋ฌธ์์ด์ ์ถ๊ฐํ๊ฑฐ๋ ๋ณ๊ฒฝํ ๋ ์ฌ์ฉํ๋ ์๋ฃํ
- toString() ๋ฉ์๋๋ก string ์๋ฃํ์ผ๋ก ๋ณ๊ฒฝ๊ฐ๋ฅ
StringBuffer์ ๋ฉ์๋
- append - ๋ฌธ์์ด ์ถ๊ฐ ๊ทธ๋ฅ stirng ์๋ฃํ์ + ์ฐ์ฐํ๋ ๊ฒ๊ณผ ๋ฌ๋ฆฌ ๊ฐ์ฒด๋ฅผ ํ๋ฒ๋ง ์์ฑ, ์์ ๊ฐ๋ฅ
- insert - ํน์ ์์น์ ๋ฌธ์์ด ์ฝ์
- substring
StringBuilder ์๋ฃํ
StringBuffer์ ์ ์ฌ, ๋ฉํฐ ์ค๋ ๋์๋ buffer๊ฐ ์ ํฉํ๊ณ ์ฑ๋ฅ์ ์๊ฐ ์ข์
06 ๋ฐฐ์ด(Array)
- ์๋ฃํ์ ์งํฉ
- ์๋ฃํ ํ์ ๋ฐ๋ก ์์ [] ๊ธฐํธ๋ฅผ ์ฌ์ฉํ์ฌ ํํ ex) int ์๋ฃํ์ ๋ฐฐ์ด์ int[] ๋ก ํํํ
- ๋ฐฐ์ด์ ๊ธธ์ด๋ ๊ณ ์ ! ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋จผ์ ์ค์ ํ ํ ๊ฐ์ ๋์ค์ ๋์ (์ค์ ํ์ง ์์ผ๋ฉด ์ค๋ฅ)
- ์ธ๋ฑ์ฑ์ ํตํด ๋ฐฐ์ด ๊ฐ์ ์ ๊ทผ
- length๋ฅผ ํตํด ๋ฐฐ์ด์ ๊ธธ์ด ์ป์ ์ o
07 ๋ฆฌ์คํธ(List)
List<์๋ฃํ> ๋ฆฌ์คํธ ๋ช = new ArrayList(or LinkedList)<์๋ฃํ(์๋ต๊ฐ๋ฅ)>();
- ์ธํฐํ์ด์ค์ ์ผ์ข - ArrayList, Vector, LinkedList์ ์ข ๋ฅ๊ฐ ์์
- ArrayList๋ LinkedList๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์๋ java.util ํจํค์ง์ ์๋ ArrayList๋ LinkedList, List๋ฅผ ์ ์ธํด์ผ ํจ (import java.util.ArrayList;)
- array์ ๋ฌ๋ฆฌ ๊ธธ์ด๊ฐ ๋์ ์ผ๋ก ๋ณ๋ ๊ฐ๋ฅ
- <> ์ ๋๋ฆญ์ผ๋ก ๋ช ์ํด์ผ ํจ
ArrayList ๋ฉ์๋
- add - ๋ฆฌ์คํธ์ ์์ ์ฝ์
- get - ํน์ ์ธ๋ฑ์ค ๊ฐ ์ถ์ถ
- size - list์ ๊ฐฏ์ ๋ฆฌํด
- contains - ๋ฆฌ์คํธ ์์ ํ๋ผ๋ฏธํฐ ํญ๋ชฉ์ด ์๋์ง ํ๋ณํด์ boolํ์ ์ผ๋ก ๋ฆฌํด
- remove - ๊ฐ์ฒด๋ฅผ ์ญ์ ํ๊ณ boolํ์ ์ผ๋ก ๋ฆฌํดํ๊ฑฐ๋ ์ธ๋ฑ์ค๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ฃผ๋ฉด ์ธ๋ฑ์ค์ ํด๋นํ๋ ํญ๋ชฉ์ ์ญ์ ํ๊ณ ์ญ์ ๋ ํญ๋ชฉ์ ๋ฆฌํด
- sort - ์ค๋ฆ์ฐจ์ ํน์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฌ import java.util.Comparator; ํ์
- ์ค๋ฆ์ฐจ์(์๋ฐฉํฅ) ์ ๋ ฌ - Comparator.naturalOrder()
- ๋ด๋ฆผ์ฐจ์(์ญ๋ฐฉํฅ) ์ ๋ ฌ - Comparator.reverseOrder()
import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; public class Sample { public static void main(String[] args) { ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142")); pitches.sort(Comparator.naturalOrder()); // ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ System.out.println(pitches); // [129, 138, 142] ์ถ๋ ฅ } }
์ ๋๋ฆญ์ค
- ArrayList()๊ฐ์ ์๋ฃํ ํ์ ์์ ๊ฐ์ ๋ฌธ๊ตฌ
- ๋ ๋ช ํํ ํ์ ์ ๋ช ์ํ ์ ์์.
- ArrayList<String> pitches = **new** **ArrayList**<>(); → arraylist์์ ๋ด์ ์ ์๋ ์๋ฃํ์ stringํ์ ๋ฟ์ด๋ผ๋ ๋ป
- ์ ๋๋ฆญ์ค๋ฅผ ๋ช ์ํ์ง ์์ผ๋ฉด ์ถ๊ฐ๋๋ ๊ฐ์ฒด๋ object ์๋ฃํ์ผ๋ก ์ธ์๋จ → string์ผ๋ก ์ฌ์ฉํ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ํ๋ณํ ํ์
String one = (String) pitches.get(0); // Object ์๋ฃํ์ String ์๋ฃํ์ผ๋ก ์บ์คํ ํ๋ค.
- ์ ๋๋ฆญ์ค๋ก ๋ช ์ํ ์ ํ๋ณํ ๊ณผ์ ์ด ํ์x
**ArrayList ์์ฑ**
- add๋ฉ์๋ ์ฌ์ฉ
- ์ด๋ฏธ ์กด์ฌํ๋ array๋ฅผ ํ์ฉ→ Arrays.asList(array๋ฐ์ดํฐ or string์๋ฃํ ์ฌ๋ฌ๊ฐ)
String.join
String.join("๊ตฌ๋ถ์", ๋ฆฌ์คํธ๊ฐ์ฒด) ํํ
- ๊ฐ ์์ ์ฌ์ด์ ๊ตฌ๋ถ์๋ฅผ ์ฝ์ ํ๊ณ ์ถ์ ๋ ์ฌ์ฉ
- ๋ฆฌ์คํธ๋ฅผ ์ฐ์๋ string์ผ๋ก ๋ง๋ค ๋์๋ ์ฌ์ฉ ex) String.join(””,List)
08 ๋งต(Map)
- associative array, hash๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ ๋์๊ด๊ณ๋ฅผ ํํํด์ฃผ๋ ์๋ฃํ
- list์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ธํฐํ์ด์ค
- ์์ฐจ์ ๋ฐฉ์์ด ์๋ key-value๋ฐฉ์์ผ๋ก ํ๋์ ์์ผ๋ก ์ ์ฅ(ํ์ด์ฌ์ dictionary์ ์ ์ฌ)
- HashMap, LinkedHashMap, TreeMap ๋ฑ์ด ์์
HashMap
- key value ๋ชจ๋ string ํ์
- key์ value๋ฅผ ๋ฌถ์ด ํ๋์ entry๋ก ์ ์ฅ
- ํด์ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ → ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ๊ฒ์
put
key์ value ์์ ์ถ๊ฐ
import java.util.HashMap; public class Sample { public static void main(String[] args) { HashMap<String, String> map = new HashMap<>(); map.put("people", "์ฌ๋"); map.put("baseball", "์ผ๊ตฌ"); } }
get
key์ ํด๋นํ๋ value๊ฐ ์ป์ ๋
key์ ํด๋นํ๋ value๊ฐ ์์ผ๋ฉด null์ด ๋ฆฌํด. ๋ํดํธ ๊ฐ์ ์ป๊ณ ์ถ์ ๋๋ getOrDefault ๋ฉ์๋๋ฅผ ์ฌ์ฉ
containsKey
๋งต์ ํด๋นํ๋ key๊ฐ ์๋์ง ์ ๋ฌด๋ฅผ ์ฐธ ๊ฑฐ์ง์ผ๋ก ๋ฆฌํด
remove
๋งต(Map)์ ํญ๋ชฉ์ ์ญ์ ํ๋ ๋ฉ์๋๋ก key๊ฐ์ ํด๋น๋๋ ์์ดํ (key, value)์ ์ญ์ ํ ํ ๊ทธ value ๊ฐ์ ๋ฆฌํด
****size****
Map์ ์ด key ๊ฐฏ์๋ฅผ ๋ฆฌํด
keySet
keySet์ ๋งต(Map)์ ๋ชจ๋ Key๋ฅผ ๋ชจ์์ ๋ฆฌํด
LinkedHashMap
- HashMap์ key์ ์์๊ฐ ์ ๋ ฅํ๋๋ก ์์ฐจ์ ์ผ๋ก ์ง์ผ์ง์ง ์์
- LinkedHashMap์ ์ ๋ ฅ๋ key์ ์์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ, ์ฌ์ฉ๋ฒ์ HashMap๊ณผ ๋์ผ
TreeMap
- key์ value ์์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ํํ๋ก ์ ์ฅ(key์ ์ค๋ฆ์ฐจ์ ์์)
- ๋ฐ์ดํฐ ์ถ๊ฐ ๋ฐ ์ ๊ฑฐ ์๋ ๋น ๋ฆ
- ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ์ฑ๋ฅ์ ํฅ์์ํจ ๋ ๋-๋ธ๋ ํธ๋ฆฌ๋ก ๊ตฌํ
09 ์งํฉ(set)
HashSet<String> set = **new** **HashSet**<>(Arrays.asList("H", "e", "l", "l", "o"));
- Set ์ธํฐํ์ด์ค
- list์ ๋ฌ๋ฆฌ ์ค๋ณต๊ฐ์ ์ฝ์ ํ ์ ์๊ณ ์์๊ฐ ์์(์ธ๋ฑ์ฑx)
- ์ธํฐํ์ด์ค import ํ HashSet์ ์ฌ์ฉํ์ฌ ์์ฑ
์งํฉ ๋ฉ์๋
- retainAll - ๊ต์งํฉ
- addAll - ํฉ์งํฉ, ์ฌ๋ฌ๊ฐ์ ๊ฐ ํ ๋ฒ์ ์ถ๊ฐํ๊ธฐ(array
- removeAll - ์ฐจ์งํฉ
- add - ์งํฉ์ ๊ฐ ์ถ๊ฐํ๊ธฐ
- remove - ํน์ ๊ฐ ์ ๊ฑฐ set.remove(”์ ๊ฑฐํ๊ณ ์ ํ๋ ๊ฐ”)
Treeset & LinkedHaseSet
- TreeSet - ์ค๋ฆ์ฐจ์์ผ๋ก ๊ฐ์ ์ ๋ ฌํ์ฌ ์ ์ฅ
- LinkedHashSet - ์ ๋ ฅํ ์์๋๋ก ๊ฐ์ ์ ๋ ฌํ์ฌ ์ ์ฅ
10 ์์์งํฉ(Enum)
- ๊ด๋ จ์ด ์๋ ์ฌ๋ฌ ๊ฐ์ ์์ ์งํฉ์ ์ ์ํ ๋ ์ฌ์ฉํ๋ ์๋ฃํ
enum CoffeeType { AMERICANO, ICE_AMERICANO, CAFE_LATTE }; /** * countSellCoffee๋ ํ๋งค๋ ์ปคํผ์ ๊ฐฏ์๋ฅผ ๋ฆฌํดํ๋ ๋ฉ์๋์ด๋ค. * @param type ์ปคํผ์ ์ข ๋ฅ (CoffeType) */ int countSellCoffee(CoffeType type) { ... ์๋ต ... } int americano = countSellCoffee(CoffeType.AMERICANO); // ์๋ฉ๋ฆฌ์นด๋ ธ์ ํ๋งค๊ฐฏ์
- ๋งค์ง ๋๋ฒ๋ฅผ ์ฌ์ฉํ ๋๋ณด๋ค ์ฝ๋๋ฅผ ๋ช ํํ๊ฒ ํจ
- ์๋ชป๋ ๊ฐ์ ์ฌ์ฉํจ์ผ๋ก ์ธํด ๋ฐ์ํ ์ ์๋ ์ํ์ฑ์ด ์ฌ๋ผ์ง
ํ๋ณํ
๋ฌธ์์ด→์ ์ : Wrapper ํด๋์ค๋ฅผ ์ด์ฉ Integer.parseInt(๋ฌธ์์ด)
์ ์→๋ฌธ์์ด : ์ ์ ์์ ๋น ๋ฌธ์์ด ๋ํ๊ธฐ, String.valueOf(์ ์), Integer.toString(์ ์)
๋ฌธ์์ด→์์ : Double.parseDouble ๋๋ Float.parseFloat
์ ์→์ค์ : double ์๋ก์ด์ค์ = ์ ์;
์ค์→์ ์ : int ์๋ก์ด์ ์ = (int) ์ค์; ์บ์คํ (int) ์ ์ด์ฉ
๋ฌธ์์ด→์ค์ : Double.parseDouble() ์ฌ์ฉ
final
๊ฐ์ ์ค์ ํ๋ฉด ๊ทธ ๊ฐ์ ๋ค์ ์ค์ ํ ์ ์๋๋ก ๋ง๋๋ ํค์๋
ํ๋ก๊ทธ๋จ ์ํ ๋์ค ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด ์ ๋ ๋ ์ฌ์ฉ
๋ฆฌ์คํธ → final๋ก ์ ์ธํด๋ add์ removesm๋ ๊ฐ๋ฅ. ์ด๊ฑฐ๊น์ง๋ ๋ถ๊ฐ๋ฅํ๊ฒ ํ๊ณ ์ถ์ผ๋ฉด List.of()๋ฅผ ์ฌ์ฉํด์ผ ํจ
'๐ญ Study > : Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ch5 ์๋ฐ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ OOP (ํด๋์ค, ๋ฉ์๋, ์๋ฐ ๋ณ์) (0) 2023.09.05 [Java] ch4 ์ ์ด๋ฌธ (0) 2023.08.31 [Java] JVM ๋์๋ฐฉ์ & ๊ตฌ์ฑ์์ (0) 2023.08.09 [Java] ch2 ์๋ฐ ์์ค์ฝ๋ ๊ตฌ์กฐ & ์๋ฃํ ์ข ๋ฅ (0) 2023.08.09 [Java] ch1 ์๋ฐ์ ํน์ง, JVM๊ณผ JIT ์ปดํ์ผ๋ฌ (0) 2023.08.09 ๋๊ธ