๐ก๐ข๋ฐฐ์ด๐ด๐
๋ฐฐ์ด์ ๊ฐ๋
์ฌ๋ฌ๊ฐ์ ๋ณ์๋ฅผ ํ๊ณณ์ ๋ชจ์์ ์ ์ฅ ํ๊ณ ์ถ์ ๋ "๋ฐฐ์ด"์ด๋ผ๋ ๋ณ์์ ์ ์ฅํ๋ค๊ณ ํํ!
๋ฐฐ์ด์ ์ ์ธ
int ์ ๊ฐ์ ๊ธฐ๋ณธํ ๋ณ์์๋ 1๊ฐ์ ๊ฐ๋ง ์ ์ฅํ ์ ์๋ค๋ฉด int[]์ ๊ฐ์ ๋ฐฐ์ดํ ๋ณ์๋ ์ฌ๋ฌ๊ฐ๋ฅผ ์ ์ฅํ ์ ์์
โป ๋จ! ํ๋์ ๋ฐฐ์ดํ ๋ณ์์๋ ๊ฐ์ ํ์ ๋ณ์๋ง ๋ด์ ์ ์์!
๋ฐฐ์ด์ Array๋ผ ๋ถ๋ฅด๋ฉฐ
ํ์ [] ๋ณ์;
ex) int[] intArray;
ํ์ ๋ณ์ [] ;
ex) int intArray[];
//๋ฐฐ์ด ์ ์ธ ์์
int[] intArray; //์ ์๋ฐฐ์ด
long[] longArray;
double[] doubleArray; //์ค์๋ฐฐ์ด
char[] charArray; //๋ฌธ์๋ฐฐ์ด
String[] stringArray; //๋ฌธ์์ด ๋ฐฐ์ด
// ์๋๋ ๊ฐ์ ํํ์ด๋ค
int intArray[]; //์ ์๋ฐฐ์ด
long longArray[];
double doubleArray[]; //์ค์๋ฐฐ์ด
char charArray[]; // ๋ฌธ์๋ฐฐ์ด
String stringArray[]; //๋ฌธ์์ด๋ฐฐ์ด
โ โ ๋ฐฐ์ด์ ์ฐธ์กฐํ๋ณ์๋ค์ฒ๋ผ new ๋ช ๋ น์ ํตํด์ ์์ฑํด์ ๋๊ดํธ [] ์์ ํฌ๊ธฐ๋ฅผ ์ ํ๋ค!!โ โ
Int array[] = new int[8];
+
๋ฐฐ์ด์ ์์ฑ๋ ๋ ๊ฐ ํ์ ๋ณ๋ก ์ด๊ธฐ๊ฐ์ผ๋ก ์ด๊ธฐํ ๋๋ค
ex int๋ 0 / boolean์ false / String์ null
โญ์ฐธ์กฐํ๋ณ์์ด๊ธฐ ๋๋ฌธ์ ์ค์ ๊ฐ์ ๋ด์ง ์๊ณ ์ค์ ๊ฐ์ ์ฃผ์๊ฐ์ ์ ์ฅ
๋ฐฐ์ด์ ์กฐํ (= ํด๋น ๋ฐฐ์ด๋ณ์ ๋ค์ ์๋ฒ์ ๋๊ดํธ[] ๋ก ๊ฐ์ธ์ ๋ช ์)
int[] intArray = new int[3]; // ๋ฐฐ์ด์ ๋จ๊ฑด์กฐํ
System.out.println(intArray[1]);
int[] intArray = new int[3];
for(int i=0; i<intArray.length; i++){
System.out.println(intArray[i]);
}
๊ธธ์ด๊ฐ 8์ธ ์ ์๋ฐฐ์ด์ ์ ์ธํ๊ณ ์ด๊ธฐํ๋ ๊ฐ ์ถ๋ ฅ
๋ฐฐ์ด์ ์ด๊ธฐํ
import java.utill.Arrays;
public class main{
public static void main(String[] args){
// ๋ฐฐ์ด์ ํน์ ๊ฐ ๋์
ํ์ฌ์ ์ ์ธ
int[] Array = {1,2,3,4,5};
String[] stringArray = {"a", "b", "c", "d"};
}
// for๋ฌธ์ ํตํ ๊ฐ์ ๋์
for(int=0; i<intArray.length; i++){
intArray[i] = i;
}
// ํฅ์๋ for๋ฌธ์ ํตํ ๋ฐฐ์ด ์ถ๋ ฅ
for(int i : intArray){
System.out.print(1);
System.out.println
Arrays.fill(intArray, 1); // ๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ 1๋ก ์ด๊ธฐํ
for(int i : intArray){
System.out.pring(i);
}
}
}
๐ก๐ข์ปฌ๋ ์ ๐ด๐
* ๋ฐฐ์ด์ ๋ ๊ณ ๋ํ ์ํจ๋ค(๋ฐฐ์ด๋ณด๋ค ๋ค์์ ์ฐธ์กฐํ ๋ฐ์ดํฐ๋ฅผ ๋ ์๋น๊ณ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์).
* ์๋ฃ๊ตฌ์กฐ
* ์ปฌ๋ ์ ์ ์ฐธ์กฐํ ๋ณ์๋ง ์ ์ฅํจ
* ์ข ๋ฅ : List, Set, Queue, Map
List : ์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ (โ ๋ฐ์ดํฐ ์ค๋ณต ํ์ฉ) - ๋ฐฐ์ด๊ณผ ๋น์ทํ๋ค๊ณ ๋ณผ์์์
Queue : ๋นจ๋๋ก ๋น์ ํ์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋ฐ๋์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋บ ์ ์๋ ์งํฉ
๐ First In First Out :: ๋จผ์ ๋ค์ด๊ฐ ์์๋๋ก ๊ฐ์ ์กฐํํ ์ ์๋ค.
Set : ์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ (๋ฐ์ดํฐ ์ค๋ณต ํ์ฉ x ) - ์์๊ฐ ์์ผ๋ฉฐ ์ค๋ณต์๋ ๋ฐฐ์ด
Map : ์์๊ฐ ์๋ (key, value) ์์ผ๋ก ์ด๋ค์ง ๋ฐ์ดํฐ์ ์งํฉ (โ key๊ฐ ์ค๋ณต ํ์ฉ ์ํจ)
์์ฃผ์ฐ๋ ์ฐธ์กฐํ ๋ณ์
int ์ ์ฐธ์กฐํ ๋ณ์ = Integer
long ์ ์ฐธ์กฐํ ๋ณ์ = Long
double ์ ์ฐธ์กฐํ ๋ณ์ = Double
String --> ์์ฒด๊ฐ ์ฐธ์กฐํ ๋ณ์
List (= ๋์ ๋ฐฐ์ด : ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ผ๋ก ๋์ด๋จ)
์์๊ฐ ์๋ ๋ฐ์ดํฐ์์งํฉ (๋ฐ์ดํฐ์ ์ค๋ณต์ ํ์ฉ O) (=๋ฐฐ์ด๊ณผ ๋น์ท)
ArrayList
: ๋ฐฐ์ด์ฒ๋ผ ์ผ๋ ฌ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ, ์กฐํ, ์ธ๋ฑ์ค๊ฐ์ ํ๋์ฉ ์กฐํ ๊ฐ๋ฅ
Array ์ ArrayList์ ์ฐจ์ด์
Array๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์๋ ๊ณต๊ฐ์ ์์ฒญํด์ ์ฌ์ด์ฆ๋งํผ ๋ฐ์ '์ค์ ๊ฐ'์ ์ ์ฅํ๋ ๊ธฐ๋ณธํ ๋ณ์๋ก ์ ์ฅ
ArrayList๋ ์์ฑ์์ ์ ์ฐ์๋ ๊ณต๊ฐ์ ์์ฒญ. ์ฐธ์กฐํ ๋ณ์๋ค์ ๋ด์๋๊ณ ๊ฐ์ด ์ถ๊ฐ๋ ๋ ๋ ํฐ ๊ณต๊ฐ์ด ํ์ํ๋ฉด
๋ ํฐ ๊ณต๊ฐ์ ๋ฐ์์ ์ ์ฅ
List ๊ธฐ๋ฅ
ArrayList
ArrayList<Integer> intList = new ArrayList<Integer>();
์์ ์ฝ๋๋ ArrayList ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
intList.add(์ถ๊ฐํ ๊ฐ)
โ ๊ฐ์ ์์ ํ ๋
intList.set(์์ ํ ์๋ฒ , ์์ ํ ๊ฐ)
โ ๊ฐ์ ์ญ์ ํ ๋
intList.remove(์ญ์ ํ ์๋ฒ)
โ ์ ์ฒด์ถ๋ ฅ
intList.toString()
โ ์ ์ฒด์ ๊ฑฐ
intList.clear()
LinkedList
: ๋ฉ๋ชจ๋ฆฌ์ ๋จ๋ ๊ณต๊ฐ์ ์์ฒญํด์ ์ฌ๊ธฐ์ ๊ธฐ ๋๋ ์ ์ค์ ๊ฐ์ ๋ด๊ณ , ์ค์ ๊ฐ์ด ์๋ ์ฃผ์๊ฐ์ผ๋ก ๋ชฉ๋ก์ ๊ตฌ์ฑํ๊ณ ์ ์ฅ
์ผ๋ฐ์ ์ผ๋ก ArrayList์ ๋์ผํ์ง๋ง LinkedListt๋ ๊ฐ์ ๋๋ ์ ๋ด๊ธฐ ๋๋ฌธ์ ์กฐํ์๋๊ฐ ๋๋ฆผ
โป๋จ ๊ฐ์ ์ค๊ฐ์ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ๋๋ ๋น ๋ฆ
LinkedList<Integer> LinkedList = new LinkedList<Integer>();
์์ ์ฝ๋๋ LinkedList ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
LinkedList.add(์ถ๊ฐํ ๊ฐ)
โ ๊ฐ์ ์์ ํ ๋
LinkedList.set(์์ ํ ์๋ฒ , ์์ ํ ๊ฐ)
โ ๊ฐ์ ์ญ์ ํ ๋
LinkedList.remove(์ญ์ ํ ์๋ฒ)
โ ๊ฐ์ ์ค๊ฐ์ ํ ๋
LinkedList.add(์ถ๊ฐํ ์๋ฒ, ์ถ๊ฐํ ๊ฐ)
โ ์ ์ฒด์ถ๋ ฅ
LinkedList.toString()
โ ์ ์ฒด์ ๊ฑฐ
LinkedList.clear()
Stack (= '์์'๋ก ๋ฌ์ฌ)
: ๊ฐ์ ์์ง์ผ๋ก ์์๋๊ณ ๋ฃ์๋ค๊ฐ ๋นผ์ ์กฐํ ํ๋ ํ์์ผ๋ก ๋ฐ์ดํฐ ๊ด๋ฆฌ
์ต๊ทผ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๋์ดํ๊ณ ์ถ๊ฑฐ๋, ๋ฐ์ดํฐ์ ์ค๋ณต ์ฒ๋ฆฌ๋ฅผ ๋ง์ ๋ ์ฌ์ฉ
(Last-In-First-Out) ==> "๋์ค์ ๋ค์ด๊ฐ ๊ฒ์ด ๊ฐ์ฅ ๋จผ์ ๋์จ๋ค"
โ๊ธฐ๋ฅ ์ ๋ฆฌ
push () = add()์ ์ ์ฌ // ์ถ๊ฐ ๊ธฐ๋ฅ
peek () = get() ๊ธฐ๋ฅ๊ณผ ์ ์ฌ // ์กฐํ ๊ธฐ๋ฅ
pop () = ๊บผ๋ด๋ ๊ธฐ๋ฅ
Stack<Integer> intStack = new Stack<Integer>();
์์ ์ฝ๋๋ Stack ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
intStack.push(์ถ๊ฐํ ๊ฐ)
โ ๊ฐ์ ์กฐํํ ๋
(๋งจ์ ๊ฐ์ ์กฐํํจ)
intStack.peek()
โ ๊ฐ์ ๊บผ๋ผ ๋
(๋งจ์ ๊ฐ์ ๊บผ๋ด๊ณ ํ์ ์ญ์ )
intStack.pop()
โ ๊ฐ์ ํฌ๊ธฐ ํ์ธํ ๋
intStack.size()
Queue : FIFO (= First In First Out)
: ๋นจ๋์ฒ๋ผ ํ์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋ฐ๋์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋บ ์ ์๋ ์งํฉ
: ๋จผ์ ๋ค์ด๊ฐ ์์๋๋ก ๊ฐ์ ์กฐํ
: Queue๋ ์์ฑ์๊ฐ ์๋ ์ธํฐํ์ด์ค ๊ทธ๋์ ๋ฐ๋ก ์์ฑ ๋ถ๊ฐ
: ์์ฑ์๊ฐ ์กด์ฌํ๋ ํด๋์ค์ธ LinkedList๋ฅผ ์ฌ์ฉํ์ฌ Queue๋ฅผ ์์ฑํด์ ๋ฐ๋๋ค
Queue<Integer> = new Linked<Integer>();
์์ ์ฝ๋๋ Queue ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
(๊ฐ์ ๋งจ์์ ์ถ๊ฐ)
intQueue.add(์ถ๊ฐํ ๊ฐ)
โ ๊ฐ์ ์กฐํํ ๋
(๋งจ ์๋ ๊ฐ์ ์กฐํํจ)
intQueue.peek()
โ ๊ฐ์ ๊บผ๋ผ ๋
(๋งจ์๋๊ฐ์ ๊บผ๋ด๊ณ ์ญ์ ๋จ)
intQueue.poll()
Set
: ์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ (๋ฐ์ดํฐ ์ค๋ณต ํ์ฉ x) -- ์์์๊ณ ์ค๋ณต์๋ ๋ฐฐ์ด์ด๋ผ ์๊ฐํ์
: Set ๊ทธ๋ฅ ์ฌ์ฉ ๊ฐ๋ฅ. HashSet, TreeSet ๋ฑ์ผ๋ก ์์ฉ ์ฌ์ฉ๊ฐ๋ฅ
: Set๋ Queue ์ฒ๋ผ ์์ฑ์๊ฐ ์๋ ์ธํฐํ์ด์ค๋ผ ๋ฐ๋ก ์์ฑ ๋ถ๊ฐ๋ฅ
: ์์ฑ์๊ฐ ์กด์ฌํ๋ ํด๋์ค์ธ HashSet์ ์ฌ์ฉํด์ Set๋ฅผ ์์ฑ๋ฐ์ ์ ์๋ค.
HashSet : ๊ฐ์ฅ ๋น ๋ฅด๋ค. ์์๋ฅผ ์ ํ ์์ธกํ ์ ์์
TreeSet : ์ ๋ ฌ๋ ์์๋๋ก ๋ณด๊ด. ์ ๋ ฌ๋ฐฉ๋ฒ์ ์ง์ ํ ์ ์์
LinkedHashSet : ์ถ๊ฐ๋ ์์, ํน์ ๊ฐ์ฅ ์ต๊ทผ์ ์ ๊ทผํ ์์๋๋ก ์ ๊ทผ ๊ฐ๋ฅ
๐Tip
๋ณดํต HashSet ์ฌ์ฉํจ
์์๋ณด์ฅ์ด ํ์ํ๋ค ์ถ์ LinkedHashSet์ ์ฌ์ฉ
Set<Integer> intSet = new HashSet<Integer>();
์์ ์ฝ๋๋ Set ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
(๊ฐ์ ๋งจ์์ ์ถ๊ฐ)
intSet.add(์ถ๊ฐํ ๊ฐ)
โ ๊ฐ์ ์กฐํํ ๋
(์๋ฒ์ ์๋ ๊ฐ ์กฐํ)
intSet.get(์กฐํํ ์๋ฒ)
โ ๊ฐ์ ์ญ์ ํ ๋
(์ญ์ ํ ๊ฐ ์ง์ )
intSet.remove(์ญ์ ํ ๊ฐ)
โ ๊ฐ ํฌํจํ์ธํ ๋
(ํด๋น๊ฐ์ด ํฌํจ๋์ด์๋ ์ง๋ boolean๊ฐ์ผ๋ก ์๋ต)
intSet.contains(ํฌํจํ์ธ ํ ๊ฐ)
Map
: key - value ๊ตฌ์กฐ๋ก ๊ตฌ์ฑ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ (key๊ฐ์ ๊ธฐ์ค์ผ๋ก value ์กฐํ ๊ฐ๋ฅ)
: key๊ฐ ๋จ์๋ก ์ค๋ณต์ ํ์ฉํ์ง ์๋ ๊ธฐ๋ฅ์ด ์๋ค. (key ๊ฐ์ ์ค๋ณต๋๋ฉด ์๋จ)
: Map๋ ๊ทธ๋ฅ ์ฌ์ฉ ๊ฐ๋ฅ / HashMap, TreeMap ๋ฑ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
Map<String, Integer> intMap = new HashMap<>();
์์ ์ฝ๋๋ Map์ ์ธ๊ณผ ์์ฑ์ ๋์์ ์งํํ ๊ฒ!
โ ๊ฐ์ ์ถ๊ฐํ ๋
(๊ฐ์ ๋งจ์์ ์ถ๊ฐ)
intMap.put(์ถ๊ฐํ key๊ฐ, ์ถ๊ฐํ value๊ฐ)
โ ๊ฐ์ ์กฐํํ ๋
(key์ ์๋ value ๊ฐ ์กฐํ)
intMap.get(์กฐํํ key๊ฐ)
โ ์ ์ฒด key ์กฐํ
intMap.keySet()
โ ์ ์ฒด value ์กฐํ
intMap.values()
โ ๊ฐ ์ญ์
(key์ ์๋ value ๊ฐ ์ญ์ )
intMap.remove(์ญ์ ํ key๊ฐ)
'์๋ฐ(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๋ฐ ๋คํ์ฑ(polymorphism) ์์ ์ฐธ์กฐ๋ณ์ ์ธ์คํด์ค (0) | 2023.06.08 |
---|---|
์๋ฐ Java ๊ฐ์ฒด์งํฅ์ด๋๋ฌด์์ผ๊น? #2 ๊ฐ์ฒด๋ฐฐ์ด ํด๋์ค ์ธ์คํด์ค๋ณ์ (0) | 2023.06.03 |
[Java ๋ฌธ๋ฒ ์ข ํฉ๋ฐ] ๊ธฐ์ด์ธ์ด 2์ฃผ์ฐจ (2-10) (0) | 2023.05.23 |
[Java ๋ฌธ๋ฒ ์ข ํฉ๋ฐ] ๊ธฐ์ด์ธ์ด 1์ฃผ์ฐจ (0) | 2023.05.23 |
์๋ฐ(java) ์ธ์(argument) / ๋งค๊ฐ๋ณ์(parameter) ์ฐจ์ด (0) | 2023.05.12 |