1๏ธโฃ ์ ํ ์๋ฃ๊ตฌ์กฐ - ๋ฐฐ์ด.
์๋ฃ๊ตฌ์กฐ ๊ด์ ์์ ๋ฐฐ์ด์ ์ดํดํ๊ณ ์ฌ๋ฌ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํ ๊ฐ๋ฅ
1๏ธโฃ ๋ฐฐ์ด(Array).
์๋ฃ๊ตฌ์กฐ ๊ด์ ์์ ๋ฐฐ์ด(Array)์ ๋์ผํ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅํ๋ ์ ํ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
๋ฐฐ์ด์ ์กฐ์ ๋ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์์์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์๋ ํน์ง์ด ์์ต๋๋ค.
๋ฐฐ์ด์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ด๊ณ ๋๋ฆฌ ์ฌ์ฉ๋๋ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ ๋๋ค.
ํน์ง.
-
๊ณ ์ ๋ ํฌ๊ธฐ(Fixed Size)
- ๋ฐฐ์ด์ ์ ์ธ ์ ํฌ๊ธฐ๊ฐ ๊ฒฐ์ ๋๋ฉฐ, ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ์ด ํฌ๊ธฐ๋ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๋์ ๊ณ ์ ๋์ด ์์ต๋๋ค.
- ์: โ
int[] numbers = new int[10];
โ(ํฌ๊ธฐ๊ฐ 10์ธ ์ ์ํ ๋ฐฐ์ด)
-
์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ(Contiguous Memory Allocation)
- ๋ฐฐ์ด์ ์์๋ค์ ๋ฉ๋ชจ๋ฆฌ์์ ์ฐ์์ ์ผ๋ก ๋ฐฐ์น๋ฉ๋๋ค. ์ด๋ ์ธ๋ฑ์ค๋ฅผ ํตํ ๋น ๋ฅธ ์ ๊ทผ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
- ์ฒซ ๋ฒ์งธ ์์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์์์ ์ฃผ์๋ฅผ ๊ณ์ฐํ ์ ์์ต๋๋ค.
-
์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ(Indexing)
- ๋ฐฐ์ด์ ๊ฐ ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผํ ์ ์์ต๋๋ค. ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํ์ฌ ๋ฐฐ์ด์ ํฌ๊ธฐ -1๊น์ง์ ๊ฐ์ ๊ฐ์ง๋๋ค.
- ์: โ
numbers[0]
โ,โnumbers[1]
โ,โฆ,โnumbers[9]
โ
-
๋์ผํ ๋ฐ์ดํฐ ํ์
(Homogeneous Data Type)
- ๋ฐฐ์ด์ ๋์ผํ ๋ฐ์ดํฐ ํ์ ์ ์์๋ค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ์ฆ, ๋ฐฐ์ด ๋ด ๋ชจ๋ ์์๋ ๊ฐ์ ๋ฐ์ดํฐ ํ์ ์ด์ด์ผ ํฉ๋๋ค.
- ์: ์ ์ํ ๋ฐฐ์ด, ๋ฌธ์์ด ๋ฐฐ์ด ๋ฑ.
์ฅ์ .
-
๋น ๋ฅธ ์ ๊ทผ ์๋(Fast Access) :
- ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ O(1) ์๊ฐ ๋ณต์ก๋๋ก ๋ฐฐ์ด์ ์์์ ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค. ์ด๋ ๋ฐฐ์ด์ ์ฃผ์ ์ฅ์ ์ค ํ๋์ ๋๋ค.
-
๊ฐ๋จํ ๊ตฌํ(Simple Implementation) :
- ๋ฐฐ์ด์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๊ฐ ๊ฐ๋จํ์ฌ ๊ตฌํ์ด ์ฉ์ดํฉ๋๋ค. ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ก, ๋ค๋ฅธ ๋ณต์กํ ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ด๊ฐ ๋ฉ๋๋ค.
๋จ์ .
-
๊ณ ์ ๋ ํฌ๊ธฐ(Fixed Size) :
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ์ ์ธ ์ ๊ฒฐ์ ๋๋ฉฐ, ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ์ด๋ ํฌ๊ธฐ๋ฅผ ์ฌ์ ์ ์ ํํ ์์ธกํ๊ธฐ ์ด๋ ค์ด ๊ฒฝ์ฐ ๋นํจ์จ์ ์ผ ์ ์์ต๋๋ค.
-
์ฝ์
๋ฐ ์ญ์ ์ ๋นํจ์จ์ฑ(Inefficient Insertions and Deletions) :
- ๋ฐฐ์ด์ ์ค๊ฐ์ ์์๋ฅผ ์ฝ์ ํ๊ฑฐ๋ ์ญ์ ํ ๊ฒฝ์ฐ, ์์๋ค์ ์ด๋์์ผ์ผ ํ๊ธฐ ๋๋ฌธ์ O(n) ์๊ฐ์ด ์์๋ฉ๋๋ค. ์ด๋ ํฐ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ์ฑ๋ฅ ์ ํ๋ฅผ ์ด๋ํ ์ ์์ต๋๋ค.
-
๋ฉ๋ชจ๋ฆฌ ๋ญ๋น(Memory Waste) :
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋๋ฌด ํฌ๊ฒ ์ค์ ํ๋ฉด ์ฌ์ฉ๋์ง ์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ญ๋น๋ ์ ์๊ณ , ๋๋ฌด ์๊ฒ ์ค์ ํ๋ฉด ์ถฉ๋ถํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค.
๋ฐฐ์ด์ ์ฌ์ฉ ์์.
-
์ ์ํ ๋ฐฐ์ด ์ ์ธ ๋ฐ ์ด๊ธฐํ
int[] numbers = new int[5]; numbers[0] = 10; numbers[1] = 20; numbers[2] = 30; numbers[3] = 40; numbers[4] = 50;
-
๋ฐฐ์ด์ ์์ ์ ๊ทผ
int firstElement = numbers[0]; // 10 int lastElement = numbers[4]; // 50
-
๋ฐฐ์ด์ ์ํ
for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); }
๋ง๋ฌด๋ฆฌ.
๋ฐฐ์ด์ ๋ค์ํ ์ํฉ์์ ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ ์ ์ฅ๊ณผ ์ ๊ทผ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ฉฐ, ํน์ ์๊ตฌ์ฌํญ์ ๋ง์ถฐ ๋ค๋ฅธ ์๋ฃ๊ตฌ์กฐ์ ํจ๊ป ์ฌ์ฉ๋๊ธฐ๋ ํฉ๋๋ค.
๋ฐฐ์ด์ ๋น ๋ฅธ ์ ๊ทผ ์๋์ ๊ฐ๋จํ ๊ตฌ์กฐ ๋๋ถ์, ๋ง์ ์๊ณ ๋ฆฌ์ฆ๊ณผ ํ๋ก๊ทธ๋จ์์ ํต์ฌ์ ์ธ ์ญํ ์ ํฉ๋๋ค.
2๏ธโฃ ๋ฐฐ์ด ์ง์ ๊ตฌํ.
// CustomArray ํด๋์ค
public class CustomArray {
private int[] data;
private int size;
// ํน์ ์ฉ๋์ผ๋ก ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ ์์ฑ์
public CustomArray(int capacity) {
data = new int[capacity];
size = 0;
}
// ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฉ์๋
public int size() {
return size;
}
// ๋ฐฐ์ด์ด ๋น์ด ์๋์ง ํ์ธํ๋ ๋ฉ์๋
public boolean isEmpty() {
return size == 0;
}
// ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฉ์๋
public int get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of bounds");
}
return data[index];
}
// ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ค์ ํ๋ ๋ฉ์๋
public void set(int index, int value) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of bounds");
}
data[index] = value;
}
// ๋ฐฐ์ด์ ์์๋ฅผ ์ถ๊ฐํ๋ ๋ฉ์๋
public void add(int value) {
if (size == data.length) {
throw new IllegalStateException("Array is full");
}
data[size] = value;
size++;
}
// ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ญ์ ํ๋ ๋ฉ์๋
public void remove(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of bounds");
}
for (int i = index; i < size - 1; i++) {
data[i] = data[i + 1];
}
size--;
}
// ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํ๋ ๋ฉ์๋
public void print() {
for (int i = 0; i < size; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
์ค๋ช .
-
ํ๋:
- โdataโ : ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฐ์ด.
- โsizeโ : ํ์ฌ ๋ฐฐ์ด์ ์ ์ฅ๋ ์์์ ๊ฐ์.
-
์์ฑ์:
- โCustomArray(int capacity)โ : ์ด๊ธฐ ์ฉ๋์ ์ค์ ํ์ฌ ๋ฐฐ์ด์ ์ด๊ธฐํ ํฉ๋๋ค.
-
๋ฉ์๋:
- โsize()โ : ํ์ฌ ๋ฐฐ์ด์ ์ ์ฅ๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํฉ๋๋ค.
- โisEmpty()โ : ๋ฐฐ์ด์ด ๋น์ด์๋์ง ํ์ธํฉ๋๋ค.
- โget(int index)โ : ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ๋ฐํํฉ๋๋ค.
- โset(int index, int value)โ : ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ค์ ํฉ๋๋ค.
- โadd(int value)โ : ๋ฐฐ์ด์ ๋ง์ง๋ง์ ์์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
- โremove(int index)โ : ํน์ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ ๊ฑฐํ๊ณ , ์ดํ์ ์์๋ค์ ์์ผ๋ก ์ด๋์ํต๋๋ค.
- โprint()โ : ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.