1. ๋ฐฐ์ด
: ์ฌ๋ฌ ๋ณ์๋ฅผ ๋ชจ์์ ์ ์ฅํ๊ณ ์ถ์ ๋ "๋ฐฐ์ด"์ด๋ผ๋ ๋ถ๋ฅํต(๋ณ์)์ ์ ์ฅํ๋ค. ์ฌ๋ฌ๊ฐ์ ๊ฐ, ๋จ์ผ ๊ฐ ๋ชจ๋ ์ ์ฅํ๊ณ ํ๋์ฉ ๊บผ๋ด๊ฑฐ๋ ํ๊บผ๋ฒ์ ๊บผ๋ผ ์ ์๋ค.
์ฐธ๊ณ ๋ก ๋ฐฐ์ด์ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ด๋ค.
์๋ฅผ ๋ค์ด, int - ; ์ด๊ฒ์ ํ๋์ ์ ์๋ง ์ ์ฅํ ์ ์๋ค๋ฉด int [] - ; ์ด ๋ฐฐ์ด์ ์ฌ๋ฌ๊ฐ์ ์ ์๋ฅผ ์ ์ฅํ ์ ์๋ค. ๋ฐฐ์ด์๋ ๊ฐ์ ์๋ฃํ๋ง ๋ด์ ์ ์๋ค. [1, 'a', "hello"] ์๋จ. ํ๋ฒ์ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ฑฐ๋ ๊ณ์ฐํ ๋ ์ฌ์ฉ๋ผ์ for๋ฌธ๊ณผ ๊ฐ์ ๋ฐ๋ณต๋ฌธ๊ณผ ํจ๊ป ์ฐ์ด๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
1-1. Array ๋ฐฐ์ด ์ ์ธ
int [] intArray ; ์ด๋ ๊ฒ ์ ์ธํด์ ์ฌ์ฉํ๋ฉด ๋๋ค.
String [] StringArray ;
1-2. Array ๋ฐฐ์ด ์์ฑ
- new ๋ช ๋ น์ ํตํด ์์ฑํ๊ณ [ ] (๋๊ดํธ)๋ฅผ ์ฌ์ฉํ๋ค. ์ฐธ์กฐํ ๋ณ์์ ๋น์ทํ๋ค.
int [] intArray = new int[3]; //๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋ฐ๋์ ์๋ ค์ฃผ์ด์ผ ํ๋ค. ๋ช๊ฐ๋ฅผ ๋ด์์ง!
//์ด๋ ๊ฒ ๋๋ฉด ํฌ๊ธฐ๊ฐ 3์ธ ๋ฐฐ์ด์ด ์์ฑ๋๊ณ intํ ๋ฐฐ์ด์ด๊ธฐ ๋๋ฌธ์ ๊ฐ์ ๋ค 0์ผ๋ก ์ด๊ธฐํ๋๋ค!
# ๋ฐฐ์ด์ ์์
- index๋ผ๋ ๊ฐ๋ ์ด ์๊ณ , ์๋ฒ์ 0๋ฒ๋ถํฐ ์์ํ๋ค. ๋ง์ฝ ํฌ๊ธฐ๊ฐ 5์ธ ๋ฐฐ์ด์ด ์๋ค๋ฉด ๊ฐ ๋ณ์์ ์๋ฒ์ 0~4๋ฒ์ด ๋๋ค.
1-3. ๋ฐฐ์ด ์ํ
- ๋ฐฐ์ด ์์ ์๋ ๋ณ์๋ฅผ ํ๋์ฉ ๊บผ๋ด์ ์ฌ์ฉํ๋ ๊ฒ์ ์ํ ๋ผ๊ณ ํ๋ค.
- ๋ฐฐ์ด ์ํ๋ฅผ ํ๋ ๋ฐฉ๋ฒ์ '๋ฐ๋ณต๋ฌธ'์ด ๊ฐ์ฅ ์ผ๋ฐ์ ์ด๋ค!
int [] intArray = new intArray[3];
for(int i =0; i<intArray.length ; i++){ //.length ๋ฉ์๋: ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๊ฐ์ ธ์จ๋ค
System.out.println(intArray[i]);
} //์ถ๋ ฅ 0 0 0
1-4. ๋ฐฐ์ด ์ด๊ธฐํ (์์ฑ๋ ๋ฐฐ์ด์ ๋ณ์ ์ฌ๋ฌ๊ฐ๋ฅผ ๋ฃ์ด์ฃผ๋ ๊ฒ)
- 1. {} ์ค๊ดํธ๋ฅผ ์ฌ์ฉ 2. ๋ฐ๋ณต๋ฌธ for๋ฌธ ์ฌ์ฉ 3. Arrays.fill(๋ฐฐ์ด ๋ด๋ถ์ ๊ฐ์ ๋ค ๊ฐ์ ๊ฐ์ผ๋ก ์ด๊ธฐํํด์ค๋ค.)
int [] intArray = {1, 2, 3, 4} //1. ์ค๊ดํธ์ ์ด๊ธฐํ
for(int i=0l i<intArray.length; i++){ //2.๋ฐ๋ณต๋ฌธ์ผ๋ก ์ด๊ธฐํ
intArray[i] = i;
}
1-5. ๋ณต์ฌ
- ์์ ๋ณต์ฌ: int [] a = {1, 2, 3}, int [] b = a; ์ด ๋ฐฉ์์ด ์์ ๋ณต์ฌ์ด๋ฉฐ ๋ณ๋์ ๋ฐฐ์ด์ด ์๋ ์ฃผ์๊ฐ๋ง ๊ฐ์ง๊ณ ์ค๋ ํํ๊ฐ ๋๋ค. ๋ฐ๋ผ์ ๋ฐฐ์ด b์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด a๋ฐฐ์ด ๋ด๋ถ ๊ฐ์ด ๋ฐ๋๋ค.
- ๊น์ ๋ณต์ฌ (for๋ฌธ ์ฌ์ฉ.)
int [] a = {1, 3, 5};
int [] b = new int[a.length];
for(int i; i < a.length; i++){
b [i] = a [i];
}
##. String ๋ฐฐ์ด (์ฐธ์กฐํ ๋ณ์ ๋ฐฐ์ด)
- ์์ฃผ ๋ง์ด ์ฌ์ฉํ๊ฒ ๋ ๋ฌธ์์ด ๋ฐฐ์ด
- ์ ์ธ, ์์ฑ ๋ฐฉ๋ฒ์ int์ ๋์ผํ๋ค.
String [] StringArray = {1, 2, 3} //์ด๋ ๊ฒ ์ ์ธ, ์์ฑ, ์ด๊ธฐํ ๋ชจ๋ ๊ฐ๋ฅ
# ๊ธฐ๋ณธํ ๋ณ์๋ ์๋ฌธ์๋ก ์์ํ๊ณ ์ฐธ์กฐํ์ ๋๋ฌธ์๋ก ์์ํ๋ค! ๋ํ ๊ธฐ๋ณธํ์ ๊ฐ ์์ฒด๋ฅผ ์ ์ฅํ๊ณ ์ฐธ์กฐํ์ ์ค์ ๊ฐ์ ๋ณ๋์ ๊ณต๊ฐ ๊ทธ๋ฆฌ๊ณ ๋ณ๋์ ๊ณต๊ฐ ์ฃผ์๋ฅผ ์ ์ฅํ๋ค!
2. ๋ค์ฐจ์ ๋ฐฐ์ด (๋ง์น ํ๋ ฌ์ ๋ชจ์๊ฐ๋ค.)
- ์์ฃผ ์ฝ๊ฒ ์ ์๋ฉด ๊ทธ๋ฅ ๋ฐฐ์ด์ 1์ค, ๋ค์ฐจ์ ๋ฐฐ์ด์ 2์ค์ด๋ผ๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค. 3์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ๊ฑฐ์ ์ฐ์ด์ง ์๋๋ค.
2-1. ์ ์ธ, ์์ฑ, ์ด๊ธฐํ
- [] ๋๊ดํธ ํ๋๋ง ๋ ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ค!
int [][] intArray = new int [2][3];
for(int i=0; i<array.length; i++){
for(int j=0; j<array[i].length; j++) //๋ฐ๊นฅ ๋ฐ๋ณต๋ฌธ์ 2๋ฒ, ์์ชฝ ๋ฐ๋ณต๋ฌธ์ 3๋ฒ ์คํ๋๋ค.
arr[i][j] = 0;
}
2-2. ๊ฐ๋ณ ๋ฐฐ์ด
- 2์ฐจ์ ๋ฐฐ์ด์์ ์ด์ ๊ธธ์ด๋ฅผ ์๋ตํ์ฌ ํ๋ง๋ค ๋ค๋ฅธ ๊ธธ์ด์ ๋ฐฐ์ด์ ์์ฑํ ์ ์๋ค.
int [][] array = new int [3][];
array[0] = new int[2];
array[1] = new int[3];
array[2] = new int[1]; //์ฒ์์ ํ์ ๊ธธ์ด๋ง ์ด๊ธฐํํ๊ณ ์ด๋ ๊ฒ ๋์ค์ ๊ธธ์ด๋ฅผ ์ง์ ํด์ค ์ ์๋ค.
# ์ต๋๊ฐ ๊ตฌํด๋ณด๊ธฐ
int[] arr = {1, 3, 4, 5, 0};
int max = arr[0];
for(int num : arr){ //ํฅ์๋ for๋ฌธ ์ฌ์ฉ. num ์ด๋ผ๋ ๋ณ์๊ฐ ๋ฐฐ์ด์ 0๋ฒ์งธ๋ถํฐ arr ๊ธธ์ด๊ฐ ๋ ๋๊น์ง ๋ฐ๋ณต
if(num>max){
max=num; //ํด๋น ์์๊ฐ ์ฒ์์ ์ค์ ํ max ๋ณด๋ค ํฌ๋ค๋ฉด ๊ทธ ๊ฐ์ max์ ์ ์ฅ.
//๋ฐฐ์ด์ ๊ธธ์ด ๋ฒ์งธ๊น์ง ํด๋น ๋ฐ๋ณต๋ฌธ์ ๊ณ์ ์ํํ๋ฉด์ ๊ฐ์ ๋ฐ๊ฟ์ค๋ค.
}
} System.out.println("์ต๋๊ฐ์?"+max);
TIL ์์ฑ ๋ฐฉ์์ ์กฐ๊ธ ๋ณ๊ฒฝํด๋ด์ผ๊ฒ ๋ค..
๋ญ๊ฐ ๋พฐ์กฑํ ์๊ฐ ํ์ํด!!
'JavaStudy' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
TIL JAVA #3-1 (0) | 2023.11.30 |
---|---|
TIL JAVA #2-4 (1) | 2023.10.20 |
TIL JAVA #2-2 (3) | 2023.10.19 |
TIL JAVA #2-1 (0) | 2023.10.18 |
TIL JAVA #1 (1) | 2023.10.17 |