๐ ์๋์ ๋ด์ฉ์ ์ ์ ๋ฐฐ์ด์ ๋ํด์ ๋ค๋ฃจ๋ฉฐ, ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ธ
์ปฌ๋ ์ ์์ ๋์ ๋ฐฐ์ด์ ๋ค๋ฃฌ๋ค.
์ฌ๋ฌ๊ฐ์ ๊ฐ์ ํ๋ฒ์ ์ ์ฅํ ๋ ์ฌ์ฉํ ์ ์๋ค. ์ ์ธ ๋ฐ ์์ฑ ์ ๊ธธ์ด๋ฅผ ์ง์ ํด ์ฃผ์ด์ผ ํ๋ค. import java.util.Arrays; ํด์ฃผ๊ธฐint [ ] arr; )int arr [ ]; )int array [] = new int [8] )๐ก new๋ฅผ ํตํด ์์ฑํ๋ฉฐ,
์ฌ์ด์ฆ๋ฅผ ์ง์ ํด ์ฃผ์ด์ผํ๋ค. ๋ํ, ์์ฑ ์์๋ํ์ ๋ณ ์ด๊ธฐ ๊ฐ์ผ๋ก ์ด๊ธฐํ๋์ด ์ฑ์์ง๋ค.
โ์์ ์์๋ intํ ๊ฐ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ ๋ฐฐ์ด์ ์์ฑํ๋ค๋ ์๋ฏธ์ด๊ณ ,
๋ฐฐ์ดํ ๋ณ์์๋ ๊ฐ์ ํ์ ๋ง ๋ด์ ์ ์๋ค.
int [ ] arr = {1, 2, 3, 4, ... }
int[] Arr = {1, 2, 3, 4, 5}; for (int i = 0; i < Arr.length; i++) { intArray[i] = i; }๐ก
๋ณ์๋ช .length: ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์๋ ค์ค๋ค.
๐ก
Arrays.fill (๋ฐฐ์ด ๋ณ์๋ช , ๋ฃ์ ๊ฐ): ๋ชจ๋ ๊ฐ์ ๋์ผํ๊ฒ ์ฑ์์ค๋ค.
๐ ๋ฐฐ์ด๊ณผ ๊ฐ์ ์ฐธ์กฐํ ๋ณ์๋ค์ ์ค์ ๊ฐ์ด ์๋
์ฃผ์๊ฐ์ ๊ฐ์ง๊ฒ๋๋ค.
์์ ๋ณต์ฌ๋ ๋์
์ฐ์ฐ์ =์ ์ด์ฉํ์ฌ ๋ณต์ฌํ ํด ์ค์ ๊ฐ์ด 1๊ฐ๋ก ์ ์ง๋๋ ๊ฒ์ ์๋ฏธํ๋ค.
int[] a = { 1, 2, 3, 4 }; int[] b = a; b[0] = 3; System.out.println(a[0]);โ
int[] b = a;๋ฐฉ์์ผ๋ก ์์ ๋ณต์ฌ๋ฅผ ํ ๊ฒฝ์ฐ b๋ฅผ ์์ ํ ๋ ์๋ณธ๊ฐ (a)์ ์ํฅ์ ๋ผ์น ์ ์๋ค.
ย ย ย ย ๋ฐ๋ผ์, ์์ ์ฝ๋ ๊ฒฐ๊ณผ์์ ์์ ๋ณต์ฌ๋ก ์ธํด ์๋ณธ ๊ฐ(a)๋ ๋ณํํ๊ฒ ๋๋ค.
int a [] = {1, 2, 3}; int b [] = new int[a.length]; for (int i = 0; i < a.length; i++) { b[i] = a[i]; }์์ ๊ฐ์ด ๋ณต์ฌํ ๊ฒฝ์ฐ ์๋ณธ๊ฐ (a)์ ์ํฅ์ ๋ผ์น์ง ์๋๋ค.
int a [] = {1, 2, 3}; int b [] = a.clone();โ ๋จ,
2์ฐจ์ ๋ฐฐ์ด ์ด์์ผ ๊ฒฝ์ฐ์๋ ์์ ๋ณต์ฌ๊ฐ ๋๋ค.
int a [] = {1, 2, 3}; int b [] = Array.copyOf(a, a.length);๐ก
2์ฐจ์ ๋ฐฐ์ด ์ด์์ธ ๊ฒฝ์ฐ์๋ ๊น์ ๋ณต์ฌ๊ฐ ๋๋ค.
๋ณ์. length๋ String ์ฆ, ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ์๋ ค์ฃผ๋ ๊ธฐ๋ฅ์ด๋ค.
String str = "ABCD";
int b = str.length;
๐ก length์ ๊ฒฝ์ฐ
intํ์ ๋ฐํํ๋ค.
๋ณ์.charAt (index)๋ String ์ธ๋ฑ์ค์ ๋ฌธ์์ ๊ฐ์ง๊ณ ์ฌ ๋ ์ฌ์ฉํ๋ค.
String str = "ABCD";
char b = str.charAt (2);
๐ก charAt์ ๊ฒฝ์ฐ
charํ์ ๋ฐํํ๋ค.์์ ์์์์์b๋ 'C'๋ผ๋ ๋ฌธ์๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค.
๋ณ์.substring (from index, to index)๋ String์์ from ~ to์ ํด๋นํ๋ ์ธ๋ฑ์ค์ ๋ฌธ์์ด ์ป์ ๋ ์ฌ์ฉํ๋ ๊ธฐ๋ฅ์ด๋ค.
String str = "ABCD";
String b = str.substring(0, 3);
๐ก substring์ ๊ฒฝ์ฐ
Stringํ์ ๋ฐํํ๋ค.์์ ์์์์์b๋ 'D'๋ผ๋ ๋ฌธ์๋ฅผ ์ ์ธํ 'ABC' ๋ฌธ์์ด์ด ๋๋ค.
๐ก ์๋์ ๊ฐ์ด (0, 1)์ ํ๊ฒ๋๋ฉด "A"๋ง ์ป์ ์ ์๋ค.
String str = "ABCD"; String b = str.substring(0, 1); // "A"String str = "ABCD"; String b = str.substring(2, 3); // "C"
๋ณ์.equals (String ๋น๊ตํ ๊ฐ)๋ ๋ณ์์ ๋น๊ตํ ๊ฐ์ด ๊ฐ์์ง ํ์ธํ๊ณ , ๊ฐ๋ค๋ฉด true ๋ค๋ฅด๋ฉด false๋ฅผ ๋ฐํํ๋ค.
String str = "ABCD";
String newStr = "ABCD";
boolean result = newStr.equals (str);
๐ก equals์ ๊ฒฝ์ฐ
booleanํ์ ๋ฐํํ๋ค.์์ ์์์์์str๊ณผ newStr์ ๋์ผํ ๋ฌธ์์ด์ด๊ธฐ ๋๋ฌธ์ true๊ฐ ๋ฐํ๋๋ค. ๋ฐ๋ผ์ result๋ true๊ฐ ๋๋ค.
๐ Scanner๋ฅผ ํตํด ์ ๋ ฅํ ๊ฐ์ด ๋ด๊ฐ ์ง์ ํ ๋ฌธ์์ด๊ณผ ๊ฐ์์ง ํ์ธํ ๊ฒฝ์ฐ ์๋์ ๊ฐ์ด ์ฝ๋๋ฅผ ๊ตฌํํ ์ ์๋ค.
Scanner sc = new Scanner(System.in); while("๋".equals(sc.next())) { }
๋ณ์.toCharArray ()๋ ๋ฌธ์์ด์ char [ ] (๋ฌธ์ ๋ฐฐ์ด)๋ก ๋ณํํด์ค๋ค.
String str = "ABCD";
char arr [] = str.toCharArray();
๐ก toCharArray์ ๊ฒฝ์ฐ
๋ฌธ์ ๋ฐฐ์ด์ ๋ฐํํ๋ค.
new String( char [ ] )๋ char [ ] (๋ฌธ์ ๋ฐฐ์ด)์ ๋ฌธ์์ด ๋ก ๋ณํํด์ค๋ค.
char[] charArray = {'A', 'B', 'C'};
String charArrayString = new String(charArray);
๐ก new String์ ๊ฒฝ์ฐ
String์ ๋ฐํํ๋ค.
int [ ] [ ] arr; )int arr [ ] [ ]; )int [ ] arr [ ]; )int array [ ] [ ]= new int [2] [3] )๐ก ๋ค์ฐจ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ์ฒซ๋ฒ์งธ [ ]๊ฐ
๋ฆฌ์คํธ์ ๊ฐ์, ๋๋ฒ์งธ [ ]๊ฐ๋ฆฌ์คํธ ๋ด์ ๋ฐ์ดํฐ ๊ฐ์๋ฅผ ์๋ฏธํ๋ค๊ณ ย ย ย ย ย ์๊ฐํ๋ฉด ํธํ๋ค.
ย ย ย ย ย ์์ ๊ฐ์ด[2] [3]์ธ ๊ฒฝ์ฐ์๋ [ [๊ฐ1, ๊ฐ2, ๊ฐ3] , [๊ฐ1, ๊ฐ2, ๊ฐ3] ] ํํ์ด๋ค.
๐ 2์ฐจ์ ์ด์์ ๋ฐฐ์ด์
๋๋ฒ์งธ [ ]๋ฅผ ์๋ต์๊ธธ์ด๊ฐ ์ ํด์ง์ง ์์ ๊ฐ๊ฐ ๋ค๋ฅด๊ฒ ๋ฐ์ดํฐ ๊ฐ์๋ฅผ ์ ์ ํ ์ ์๋ค. ์ด๋ฅผ ๊ฐ๋ณ ๋ฐฐ์ด์ด๋ผ๊ณ ํ๋ค.int [][] arr = new int [3][]; arr[0] = new int[2]; arr[1] = new int[4]; arr[2] = new int[1];โ์ ์ธ ๋ฐ ์์ฑํ arr์
0๋ฒ์งธ ๋ฆฌ์คํธ์ ๋ฐ์ดํฐ ๊ฐ์๋ 2๊ฐ,1๋ฒ์งธ ๋ฆฌ์คํธ์ ๋ฐ์ดํฐ ๊ฐ์๋ 4๊ฐ,3๋ฒ์งธ ๋ฆฌ์คํธ์ ๋ฐ์ดํฐ์ ๊ฐ์๋ 1๊ฐ๋ก ์ ์ ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
int [ ] arr = { {1, 2} , {3, 4, 5} ... }
โ
๊ฐ๋ณ ๋ฐฐ์ด์ ์์ ๊ฐ์ด ์ค๊ดํธ๋ก ์ด๊ธฐํ ํ ๋ ์ง์ ํด๋ ๋๋ค.
int[] [] Arr = new int [2][3]; for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { arr[i][j] = 0; } }