๐ ์ค๋์ ํ์ต ํค์๋
- ๋ฐฐ์ด
- ์ปฌ๋ ์
๐ฅ ๋ฐฐ์ด
1. ๋ฐฐ์ด์ ๋ณต์ฌ
package week02.array;
public class Arr03 {
public static void main(String[] args) {
// int[] a = {1, 2, 3, 4};
// int[] b = a; // ์์ ๋ณต์ฌ
//
// b[0] = 3;
//
// System.out.println(a[0]);
// int[] a = {1, 2, 3, 4};
// int[] b = new int[a.length];
//
// for (int i = 0; i < a.length; i++) {
// b[i] = a[i]; // ๊น์ ๋ณต์ฌ
// }
//
// b[0] = 3;
//
// System.out.println(a[0]); // ๊น์ ๋ณต์๋ฅผ ํ๊ธฐ ๋๋ฌธ์ a ๋ฐฐ์ด์ ๊ทธ๋๋ก.
// ๊น์ ๋ณต์ฌ ๋ฉ์๋
// 1. clone() ๋ฉ์๋
int[] a = {1, 2, 3, 4};
int[] b = a.clone();
// ํ์ง๋ง, clone() ๋ฉ์๋๋ 2์ฐจ์ ์ด์ ๋ฐฐ์ด์์๋ ์์ ๋ณต์ฌ๋ก ๋์ํจ.
// 2. Arrays.copyOf() ๋ฉ์๋
int[] a = {1, 2, 3, 4};
int[] b = Arrays.copyOf(a, a.length); // ๋ฐฐ์ด๊ณผ ํจ๊ณ length๊ฐ๋ ๊ฐ์ด ๋ฃ์ด์ค.
a[3] = 0;
System.out.println(a[3]);
System.out.println(b[3]);
}
}
2. ๊ฐ๋ณ๋ฐฐ์ด
package week02.array;
public class Arr06 {
public static void main(String[] args) {
// ๊ฐ๋ณ๋ฐฐ์ด
int[][] array = new int[3][];
// ๋ฐฐ์ด ์์๋ง๋ค ๊ฐ๊ธฐ ๋ค๋ฅธ ํฌ๊ธฐ๋ก ์ง์
array[0] = new int[2];
array[1] = new int[4];
array[2] = new int[1];
// ์ค๊ดํธ๋ก ์ด๊ธฐํ๋ฅผ ์์ ํด๋ฒ๋ฆด ๋๋ ๊ฐ๋ฅํจ!
int[][] array2 = {
{10, 20},
{10, 20, 30, 40},
{10}
};
}
}
๐ฅ ์ปฌ๋ ์
- List
์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ => Array ( ์ต์ด ๊ธธ์ด๋ฅผ ์์์ผ ํจ )
์ฒ์์ ๊ธธ์ด๋ฅผ ๋ชฐ๋ผ๋ ๋ง๋ค ์ ์์
1) Array -> ์ ์ ๋ฐฐ์ด
2) List(ArrayList) -> ๋์ ๋ฐฐ์ด ( ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ผ๋ก ๋์ด๋๋ค )
- ์์ฑ ์์ ์ ์์ ์ฐ์๋ ๊ณต๊ฐ์ ์์ฒญํด์ ์ฐธ์กฐํ ๋ณ์๋ค์ ๋ด์๋๋๋ค.
- ๊ฐ์ด ์ถ๊ฐ๋ ๋ ๋ ํฐ ๊ณต๊ฐ์ด ํ์ํ๋ฉด ๋ ํฐ ๊ณต๊ฐ์ ๋ฐ์์ ์ ์ฅํ๋๊น. ์๊ด์๋ค!
- linked list
๋ฉ๋ชจ๋ฆฌ์ ๋จ๋ ๊ณต๊ฐ์ ์์ฒญํด์ ์ฌ๊ธฐ์ ๊ธฐ ๋๋์ด์ ์ค์ ๊ฐ์ ๋ด์๋๋๋ค.
์ค์ ๊ฐ์ด ์๋ ์ฃผ์๊ฐ์ผ๋ก ๋ชฉ๋ก์ ๊ตฌ์ฑํ๊ณ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
๊ธฐ๋ณธ์ ๊ธฐ๋ฅ์ -> ArrayList์ ๋์ผํ๋ค.
LinkedList๋ ๊ฐ -> ์ฌ๊ธฐ์ ๊ธฐ ๋๋์ด์ ์กฐํํ๋ ์๋๊ฐ ๋๋ฆฌ๋ค.
๊ฐ์ ์ถ๊ฐํ๊ฑฐ๋, ์ญ์ ํ ๋๋ ๋น ๋ฅด๋ค.
- Stack
์์ง์ผ๋ก ๊ฐ์ ์์๋๊ณ , ๋ฃ์๋ค๊ฐ ๋บ๋ค. FILO ( Basket )
push, peek, pop
์ต๊ทผ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๋์ดํ๊ณ ์ถ๊ฑฐ๋, ๋ฐ์ดํฐ์ ์ค๋ณต ์ฒ๋ฆฌ๋ฅผ ๋ง๊ณ ์ถ์ ๋ ์ฌ์ฉ
- Queue
๋นจ๋์ฒ๋ผ ํ์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋ฐ๋์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๋บ ์ ์๋ ์งํฉ์ ๋๋ค.
FIFO : ๋จผ์ ๋ค์ด๊ฐ ์์๋๋ก ๊ฐ์ ์กฐํํ ์ ์๋ค.
add, peek, poll
์์ฑ์๊ฐ ์๋ ์ธํฐํ์ด์ค
- Set
์์ ์๊ณ , ์ค๋ณต ์์
์์๊ฐ ๋ณด์ฅ๋์ง ์๋ ๋์ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ก ํ๋ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ
Set -> ๊ทธ๋ฅ ์ธ ์๋ ์์ผ๋, HashSet, TreeSet ๋ฑ์ผ๋ก ์์ฉํด์ ๊ฐ์ด ์ฌ์ฉ ๊ฐ๋ฅ
Set์ ์์ฑ์๊ฐ ์๋ ๊ป๋ฐ๊ธฐ๋ผ์ ๋ฐ๋ก ์์ฑํ ์ ์์
์์ฑ์๊ฐ ์กด์ฌํ๋ HashSet์ ์ด์ฉํด์ Set์ ๊ตฌํํด ๋ณผ ์ ์๋ค.
- Map
์ฌํ๊น์ง value ๊ฐ๋ค๋ง ๋ฃ์ด์ ๊ด๋ฆฌํ๋ ๋ถ๋ฅํต(์๋ฃ๊ตฌ์กฐ)์ ๋ฐฐ์ ๋ค๋ฉด Map์ key-value ๊ตฌ์กฐ๋ก ๊ตฌ์ฑ๋
๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค.
Map : key - value pair -> ์ค์!
key๋ผ๋ ๊ฐ์ผ๋ก unique ํ๊ฒ ๋ณด์ฅ์ด ๋ผ์ผ ํจ
Map -> HashMap, TreeMap์ผ๋ก ์์ฉ
๐ ์ค๋์ ํ๊ณ
์ค๋์ ์กฐ๊ธ ์ง์ค์ด ํํธ๋ฌ์ก๋ ๊ฒ ๊ฐ์ต๋๋ค.
๋ด์ผ์ ์กฐ๊ธ ๋ ๋ถ๋ฐํด์ผ์ง..
์ด๋ ต๋ค ์๋ฐ.