๋ฐฐ์ด์ด๋?
๋ฐฐ์ด์ ๊ฐ์ ํ์ ์ ์ฌ๋ฌ ๋ณ์๋ฅผ ํ๋์ ๋ฌถ์์ผ๋ก ๋ค๋ฃจ๋ ๊ฒ
๋ฐฐ์ด์ ์ ์ธ๊ณผ ์์ฑ
๋ฐฐ์ด์ ์ ์ธ - ๋ฐฐ์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ์ฐธ์กฐ๋ณ์์ ์ ์ธ
์ ์ธ๋ฐฉ๋ฒ | ์ ์ธ ์ |
ํ์ [ ] ๋ณ์์ด๋ฆ; | int[ ] score; String[ ] name; |
ํ์ ๋ณ์์ด๋ฆ [ ]; | int score[ ]; String name[ ]; |
ํ์ [ ] ๋ณ์์ด๋ฆ; // ๋ฐฐ์ด์ ์ ์ธ ( ๋ฐฐ์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ์ฐธ์กฐ๋ณ์ ์ ์ธ)
๋ณ์์ด๋ฆ = new ํ์ [ ๊ธธ์ด ] ; // ๋ฐฐ์ด์ ์์ฑ ( ์ค์ ์ ์ฅ๊ณต๊ฐ์ ์์ฑ )
int[] score; // intํ์
์ ๋ฐฐ์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ์ฐธ์กฐ๋ณ์ score์ ์ธ
score = new int[5]; // intํ์
์ ๊ฐ 5๊ฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๋ฐฐ์ด ์์ฑ
๋ฐฐ์ด์ ์ธ๋ฑ์ค
๋ฐฐ์ด์ ์ธ๋ฑ์ค - ๊ฐ ์์์ ์๋์ผ๋ก ๋ถ๋ ๋ฒํธ
์ธ๋ฑ์ค(index)์ ๋ฒ์๋ 0๋ถํฐ '๋ฐฐ์ด๊ธธ์ด-1' ๊น์ง
๋ฐฐ์ด์ ๊ธธ์ด
๋ฐฐ์ด์ด๋ฆ.length - ๋ฐฐ์ด์ ๊ธธ์ด(intํ ์์)
๋ฐฐ์ด์ ํ๋ฒ ์์ฑํ๋ฉด ๊ทธ ๊ธธ์ด๋ฅผ ๋ฐ๊ฟ ์ ์๋ค.
๋ฐฐ์ด์ ๋ค๋ฃฐ๋ index๋ฒ์๋ฅผ ๋ฒ์ด๋ Error๊ฐ ์์ฃผ ๋ฐ์ํ๋ค.
๋ฐฐ์ด์ ์ด๊ธฐํ
๋ฐฐ์ด์ ๊ฐ ์์์ ์ฒ์์ผ๋ก ๊ฐ์ ์ ์ฅํ๋ ๊ฒ
int[] score = new int[5];
score[0] = 50;
score[1] = 60;
score[2] = 70;
score[3] = 80;
score[4] = 90;
์ด๋ ๊ฒ ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ฉด ์ฝ๋๊ฐ ๊ธธ์ด์ง๋ฉฐ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ด๊ธฐํ ํ ์๋ ์๋ค.
int[] score = new int[5];
for(int i=0; i < score.length; i++)
score[i] = i * 10 + 50;
๋ฐฐ์ด์ ์์๊ฐ ์์ฃผ ๋ง์ ๊ฒฝ์ฐ์๋ for๋ฌธ์ ์ฌ์ฉํด์ค์๋ ์๋ค.
๊ทธ๋ฆฌ๊ณ for๋ฌธ์ ์ฌ์ฉ์ ๊ท์น์ด ์๊ธฐ๊ธฐ ๋๋ฌธ์ ์ ์ฝ์ด ์๊ธด๋ค.
int[] score = { 50 , 60 , 70 , 80 , 90 } // new int[]๋ฅผ ์๋ตํ ์ ์๋ค.
์ด๋ ๊ฒ ๋ฐฐ์ด์ ์์ฑํ๋๊ฒ ๊ฐ์ฅ ๋ณดํธ์ ์ด๊ณ ํธ๋ฆฌํ๋ค.
ํ์ง๋ง ์ ์ธ๊ณผ ์ด๊ธฐํ๋ฅผ ๋๋ ์ ๋ฐ๋ก ํ๋ ๊ฒฝ์ฐ๋ผ๋ฉด new int[]๋ฅผ ํ๊ธฐํด์ผํ๋ค.
int[] score;
score = { 50,60,70,80,90 }; // Error new int[]๋ฅผ ์๋ตํ ์ ์๋ค.
score = new int[]{ 50,60,70,80,90 }; // ์คํ๋๋ค.
๋ฐฐ์ด์ ์ถ๋ ฅ
int[] iArr = { 100 , 95 , 80 , 70 , 60 }
๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ๋ณ์ iArr์ ๊ฐ์ ์ถ๋ ฅํ๋ค.
System.out.println(iArr);
[I@14318bb์ ๊ฐ์ ํ์์ ๋ฌธ์์ด์ด ์ถ๋ ฅ๋๋ค.
intํ์์ ๋ฐฐ์ด์ ์ถ๋ ฅ์ ํ๋ฉด ํด๋น ๋ฐฐ์ด์ ์ฃผ์๊ฐ์ด ์ถ๋ ฅ๋๋ค.
์์ธ์ ์ผ๋ก charํ์์ผ ๊ฒฝ์ฐ, ๋ฐฐ์ด์ ๋ด์ฉ์ด ์ถ๋ ฅ๋๋ค.
char[] chArr = { 'a'.'b'.'c'.'d' };
System.out.println(chArr);
abcd๊ฐ ์ถ๋ ฅ๋๋ค.
char์ ์ ์ธํ ๋ค๋ฅธ ํ์ ์ ๋ฐฐ์ด์ ๋ด์ฉ์ด ์ถ๋ ฅ๋์ง ์๋๋ค.
๋ฐฐ์ด์ ๋ด์ฉ์ ์ถ๋ ฅํด์ผํ๋ค๋ฉด , for๋ฌธ์ ์ฌ์ฉํด์ผํ๋ค.
for(int i = 0 , i < iArr.length; i++ ){
System.out.println(iArr[i]);
} ๋ฐฐ์ด์ ์์๋ฅผ ์์๋๋ก ํ๋์ฉ ์ถ๋ ฅ
์ด์ธ, Arrays Class๋ฅผ ์ด์ฉํ๋ฉด ์ข ๋ ๊ฐํธํ๊ฒ ์ถ๋ ฅ์ด ๊ฐ๋ฅํ๋ค.
System.out.println(Arrays.toString(iArr));
Arrays class ์ด์ฉ์ Arrays๋ฅผ importํด์ผํ๋ค.
ctrl + shift + o ๋จ์ถํค๋ฅผ ์ด์ฉํด ์ฝ๊ฒ importํ ์์๋ค.
String๋ฐฐ์ด์ ์ ์ธ๊ณผ ์์ฑ
String[] name = new String[3];
3๊ฐ์ ๋ฌธ์์ด์ ๋ด์ ์ ์๋ ๋ฐฐ์ด์ ์์ฑํ๋ค
2์ฐจ์ ๋ฐฐ์ด
ํ ์ด๋ธ ํํ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๋ฐฐ์ด
int[][] score = new int[4][3];
4ํ 3์ด์ 2์ฐจ์ ๋ฐฐ์ด์ ์์ฑํ๋ค.
ํ index ( 0 ~ ํ์ ๊ธธ์ด -1 ) , ์ด index( 0 ~ ์ด์ ๊ธธ์ด -1) ์ด๋ ๊ฒ ์์ฑ์ด ๋๋ค.
1ํ 1์ด์ 100์ ๊ฐ์ ํ ๋นํ๋ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
score[0][0] = 100; → ๋ฐฐ์ด score์ 1ํ 1์ด์ 100์ ์ ์ฅ
System.out.println(score[0][0]); → ๋ฐฐ์ด score์ 1ํ 1์ด์ ๊ฐ์ ์ถ๋ ฅ
100์ด ์ถ๋ ฅ๋๋ค.
2์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ
int[][] arr = {{1,2,3},{4,5,6}}; → new int[][]๊ฐ ์๋ต๋จ
์์ ๊ฐ์ด ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ฉด ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง์ ์๋ค.
int[][] arr = {
{1,2,3},
{4,5,6}
};
์ข ๋ ์ง๊ด์ ์ผ๋ก ํ์ธํ ์ ์๊ฒ ๋๋ค.
๊ฒฐ๊ตญ , 2์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด์ ๋ฐฐ์ด ์ด๋ผ๊ณ ๋ณผ์ ์๋ค.
Stringํด๋์ค
1. Stringํด๋์ค๋ char[]์ ๋ฉ์๋(๊ธฐ๋ฅ)๋ฅผ ๊ฒฐํฉํ ๊ฒ
Stringํด๋์ค = char[] + ๋ฉ์๋(๊ธฐ๋ฅ)
2. Stringํด๋์ค๋ ๋ด์ฉ์ ๋ณ๊ฒฝํ ์ ์๋ค.(read only)
Stringํด๋์ค์ ์ฃผ์ ๋ฉ์๋
๋ฉ์๋ | ์ค๋ช |
char charAt(int index) | ๋ฌธ์์ด์์ ํด๋น ์์น(intdex)์ ์๋ ๋ฌธ์๋ฅผ ๋ฐํํ๋ค. |
int length() | ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋ฐํํ๋ค. |
String substring(int from,int to) | ๋ฌธ์์ด์์ ํด๋น ๋ฒ์(from~to)์ ๋ฌธ์์ด์ ๋ฐํํ๋ค.(to๋ ํฌํจ ์๋จ) |
boolean equals(Object obj) | ๋ฌธ์์ด์ ๋ด์ฉ์ด ๊ฐ์์ง ํ์ธํ๋ค. ๊ฐ์ผ๋ฉด ๊ฒฐ๊ณผ๋ true, ๋ค๋ฅด๋ฉด false |
char[ ] toCharArray() | ๋ฌธ์์ด์ ๋ฌธ์๋ฐฐ์ด(char[ ])๋ก ๋ณํํด์ ๋ฐํํ๋ค. |
Arrays๋ก ๋ฐฐ์ด ๋ค๋ฃจ๊ธฐ
๋ฐฐ์ด์ ๋น๊ต์ ์ถ๋ ฅ - equals(), toString()
int[] arr = {0.1.2.3.4};
int[][] arr2D = {{11,12},{21,22}};
System.out.println(Arrays.toString(arr)); → [0,1,2,3,4]
System.out.println(Arrays.deeptoString(arr2D)); → [[11,12],[21,22]]
1์ฐจ์ ๋ฐฐ์ด์ ์ถ๋ ฅํ ๋๋ Arrays.toString()์ ์ฌ์ฉ, 2์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ์ถ๋ ฅํ ๋๋ deeptoString()์ ์ฌ์ฉํ๋ค.
String[][] str2D = {{"aaa","bbb"},{"AAA","BBB"}};
String[][] str2D2 = {{"aaa","bbb"},{"AAA","BBB"}};
System.out.println(Arrays.equals(str2D,str2D2)); → false
System.out.println(Arrays.deepEquals(str2D,str2D2)); → true
1์ฐจ์ ๋ฐฐ์ด์ ๋น๊ตํ ๋๋ Arrays.equals()๋ฅผ ์ฌ์ฉ , 2์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ๋น๊ตํ ๋๋ deepEquals()์ ์ฌ์ฉํ๋ค.
๋ฐฐ์ด์ ๋ณต์ฌ - copyOf() , copyOfRange()
int arr = {0,1,2,3,4};
int[] arr2 = Arrays.copyOf(arr,arr.length); → arr2=[0,1,2,3,4]
int[] arr3 = Arrays.copyOf(arr,3); → arr3=[0,1,2]
int[] arr4 = Arrays.copyOf(arr,7); → arr4=[0,1,2,3,4,0,0]
int[] arr5 = Arrays.copyOfRange(arr, 2, 4); → arr5=[2,3] (4๋ ๋ถํฌํจ)
int[] arr6 = Arrays.copyOfRange(arr, 0, 7); → arr6=[0,1,2,3,4,0,0]
๋ฐฐ์ด์ ์ ๋ ฌ - sort()
int[] arr = { 3,2,0,1,4 };
Arrays.sort(arr); → ๋ฐฐ์ด arr์ ์ ๋ ฌํ๋ค.
System.out.println(Arrays.toString(arr)); → [0,1,2,3,4]
'๐จ๏ธ Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java]๊ฐ์ฒด์งํฅ (2) - ์์,์ฐธ์กฐ๋ณ์, ์ค๋ฒ๋ผ์ด๋ฉ, ํจํค์ง (1) | 2022.09.01 |
---|---|
[Java]๊ฐ์ฒด์งํฅ (1) - ๊ฐ์ฒด,ํด๋์ค,๋ฉ์๋,static (0) | 2022.08.27 |
[Java]์กฐ๊ฑด๋ฌธ(if,switch)๊ณผ ๋ฐ๋ณต๋ฌธ(for,while) (0) | 2022.08.23 |
[Java]์ฐ์ฐ์(Operator) (0) | 2022.08.22 |
[Java]์ ์ํ์ ์ค๋ฒํ๋ก์ฐ(Overflow) (0) | 2022.08.20 |