-
[์๋ฐ(JAVA)] ๋ฐฐ์ด(Array), length(), charAt(), substring(), equals(), toCharArray(), ๋ค์ฐจ์ ๋ฐฐ์ดJAVA 2023. 5. 23. 15:48728x90
๐ ๋ฐฐ์ด(Array)
:์ฌ๋ฌ๊ฐ์ ๋ณ์๋ฅผ ํ๋ฒ์ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ ๋ ๋ฐฐ์ด์ด๋ผ๋ ๋ณ์์ ์ ์ฅ(ํํ)ํจ.- ์๋ฐ์ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ด๋ฉฐ, ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ฑฐ๋ ๊ณ์ฐํ ๋ ์ฌ์ฉํจ
- ์ฃผ๋ก for๋ฌธ์ด๋ length๋ฑ๊ณผ ํจ๊ป ์ฌ์ฉํจ
์ ์ธ ํํ:
1. ํ์ [] ๋ณ์ = ๋ณ์์ ์ธ;
ex. int[] intArray;
2. ํ์ ๋ณ์[] = ๋ณ์์ ์ธ;
ex. int intArray[];โ ๋ฐฐ์ด ์ ์ธ์์
// ์ ์ธ๋ฐฉ์(1) int[] intArray; // ์ ์ ๋ฐฐ์ด String[] stringArray; // ๋ฌธ์์ด ๋ฐฐ์ด // ์ ์ธ๋ฐฉ์(2) int intArray[]; // ์ ์ ๋ฐฐ์ด String stringArray[]; // ๋ฌธ์์ด ๋ฐฐ์ด
๐น ์์ฑ(ํ ๋น)๋ฐฉ๋ฒ
- ๋ฐฐ์ด(Array)๋ ์ฐธ์กฐํ ๋ณ์๋ค์ฒ๋ผ new ๋ช ๋ น์ ํตํด์ ์์ฑํ๋ฉฐ, ๋๊ดํธ[] ์์ ํฌ๊ธฐ๋ฅผ ์ง์ ํจ
๋ฐฐ์ด์ ์ธ๋ฑ์ค(index)๊ฐ ์์ด์ ๊ฐ ์นธ๋ง๋ค ์๋ฒ์ผ๋ก ๋๋ ์ง๋ค.
ex) arr[0] -> arr๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ
๋ฐฐ์ด์ ์์ฑ์ ์์ฑ๋ ๋ ๊ฐ ํ์ ๋ณ ์ด๊ธฐ๊ฐ์ผ๋ก ์ด๊ธฐํ ๋จ
<ํ์ ๋ณ ์ด๊ธฐํ ๊ฐ>
- int = 0
- boolean = false
- String = Nullโ ๋ฐฐ์ด ์์ฑ ๋ฐ ์ด๊ธฐํ ์์
// ๋ฐฐ์ด ์์ฑ int[] intArray = new int[3]; // intํ ์ด๊ธฐ๊ฐ {0,0,0} boolean[] boolArray = new boolean[3]; // booleanํ ์ด๊ธฐ๊ฐ {false, false, false} String[] stringArray = new String[3]; // Stringํ ์ด๊ธฐ๊ฐ {"","",""} //๋ฐฐ์ด ์ ์ธ ์ดํ์ ์ด๊ธฐํ ์งํ int[] intArray2; intArray2 = new int[3]; // ์ด๊ธฐ๊ฐ {0,0,0}
โ ๋ฐฐ์ด์ ์ํ ์์
int[] intArray = new int[3]; for(int i=0; i<intArray.length; i++) { // length ๋ ๋ฐฐ์ด์ ๊ธธ์ด System.out.println(intArray[i]); } // ์ถ๋ ฅ (int์ ์ด๊ธฐ๊ฐ) 0 0 0
๐ฌ length()
: ํด๋น ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ํ์ธํจex) intArray.length -> 3
๐น ๋ฐฐ์ด์ ์ด๊ธฐํ
๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฐฉ๋ฒ 3๊ฐ์ง
- ์ค๊ดํธ{} ๋ฅผ ์ฌ์ฉํด์ ์ด๊ธฐํ
- ๋ฐ๋ณต๋ฌธ for๋ฌธ์ ์ฌ์ฉํด์ ์ด๊ธฐํ
- Arrays.fill ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ์ด๊ธฐํ
โ Arrays: ์๋ฐ์ ์ ํธ๋ฆฌํฐ, ์๋ฐ๋ผ๋ ์ธ์ด ์์์ ๋ฐฐ์ด์ ๊ด๋ จ๋ ์์ ์ ํ ์ ์๋ ๋ชจ๋ ๋ฉ์๋์ ์งํฉ
Arrays.fill(intArray, 1);//๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ 1๋ก ์ด๊ธฐํ for (int i : intArray) { System.out.print(i); }
๊ฒฐ๊ณผ : intArray = {1, 1, 1, 1, 1}
๐น ๋ฐฐ์ด ๋ณต์ฌ
<๋ณต์ฌ์ ์ข ๋ฅ>
- ์์ ๋ณต์ฌ
- ๊น์ ๋ณต์ฌ์ผ๋ฐ์์ ๊ฒฝ์ฐ ์๋์ ๊ฐ์ด ๋ณต์ฌ๋ฅผ ์งํํ ์ ์์ผ๋ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ์ด๋ฐ ๋ฐฉ๋ฒ์ ๋ณต์ฌ๋ ์ํํ๋ค.
int a = 4;
int b = a;โ ์์ ๋ณต์ฌ
: ๋ฐฐ์ด ๋ณ์๊ฐ์ ๋์ ์ฐ์ฐ์์ ์ฃผ์๊ฐ๋ง ๋ณต์ฌ๋๊ณ ์ค์ ๊ฐ์ ๋จ์ผ 1๊ฐ๋ก ์ ์ง๋๋๊ฒ์ ๋งํ๋ค.โ ์ฐธ์กฐํ ๋ณ์๋ ๋ณต์กํ๊ธฐ ๋๋ฌธ์ ์ค์ ๊ฐ์ด ์๋๋ผ ์ฃผ์๊ฐ์ ์ ์ฅํ๋ค.
์์ ๋ณต์ฌ๋ก ์งํํ ๊ฒฝ์ฐ a(value)๊ฐ ์๋ a๊ฐ ๋ค์ด์๋ ๋ฐฐ์ด์ ์ฃผ์๊ฐ์ด ๋ณต์ฌ๋จ
์ฆ, arr2[0]์ ๋ณ๊ฒฝํ๊ฒ ๋๋ ๊ฒฝ์ฐ ์ฃผ์๊ฐ์ ์ฐธ์กฐํ๊ธฐ ๋๋ฌธ์
๊ฐ์ ์ฃผ์๊ฐ์ ๋ฐ๋ผ๋ณด๊ฒ ๋๋ฉฐ, arr1[0]์ ๋ฐ์ดํฐ์๋ ์ํฅ์ ์ฃผ๊ฒ ๋๋ค.
โก ๊น์ ๋ณต์ฌ
: ์ค์ ๊ฐ์ ๊ฐ์ง๊ณ ์๋ ๋ฐฐ์ด์ ๊ธฐ๋ณธํ ๊ฐ์ ๊บผ๋ด์ ๋ณต์ฌํ์ฌ ์๋ก์ด ๋ฐฐ์ด์ ๋๊ฐ์ด ์์ฑํ๋๊ฒ๊น์ ๋ณต์ฌ์๋ for๋ฌธ or ์ฌ๋ฌ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
โ for๋ฌธ ๋ณต์ฌ ์์
// ๊น์ ๋ณต์ฌ for๋ฌธ 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; // b[0] (1 -> 3) System.out.println(a[0]); // ์ถ๋ ฅ 1 // ๋ณต์ฌ์ ์ฌ์ฉ๋ a๋ฐฐ์ด์ ๊ฐ์ ๊ทธ๋๋ก ์ ์ง
โ ๋ฉ์๋ ๋ณต์ฌ์์
// ๊น์ ๋ณต์ฌ ๋ฉ์๋ import java.util.Arrays; public class Main { public static void main(String[] args) { // 2. Arrays.copyOf() ๋ฉ์๋ int[] a = { 1, 2, 3, 4 }; int[] b = Arrays.copyOf(a, a.length); // ๋ฐฐ์ด๊ณผ ํจ๊ป length๊ฐ๋ ๊ฐ์ด ๋ฃ์ด์ค๋๋ค. } } // .clone() ๋ฉ์๋๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋, 2์ฐจ์ ์ด์ ๋ฐฐ์ด์์๋ ์์ ๋ณต์ฌ๋ก ๋์ํ๋ค
โญ Arrays.copyOf() : a๋ผ๋ ๋ฐฐ์ด๊ณผ a์ ๊ธธ์ด๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ์๋ก์ด ๋ฐฐ์ด์ ๋ฆฌํดํด์ค
๐ฌ Array.clone() ๋ฉ์๋๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋, 2์ฐจ์ ์ด์ ๋ฐฐ์ด์์๋ ์์ ๋ณต์ฌ๋ก ๋์ํ๋์ ์ฐธ๊ณ
๐น String ๋ฐฐ์ด
- ์ ์ธ, ์์ฑ, ์ด๊ธฐํ
String ๊ธฐ๋ฅ ํ์ฉ ์์
๋ฉ์๋ ์๋ต๊ฐ ํ์ ์ค๋ช length() int ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋ฐํํ๋ค. charAt(int index) char ๋ฌธ์์ด์์ ํด๋น index์ ๋ฌธ์๋ฅผ ๋ฐํํ๋ค. substring(int from, int to) String ๋ฌธ์์ด์์ ํด๋น ๋ฒ์(from~to)์ ์๋ ๋ฌธ์์ด์ ๋ฐํํ๋ค.
(to๋ ๋ฒ์์ ํฌํจ๋์ง ์์)equals(String str) boolean ๋ฌธ์์ด์ ๋ด์ฉ์ด ๊ฐ์์ง ํ์ธํ๋ค. ๊ฐ์ผ๋ฉด ๊ฒฐ๊ณผ๋ true, ๋ค๋ฅด๋ฉด false๊ฐ ๋๋ค. toCharArray() char[] ๋ฌธ์์ด์ ๋ฌธ์๋ฐฐ์ด(char[])๋ก ๋ณํํด์ ๋ฐํํ๋ค. new String(char[] charArr) String ๋ฌธ์๋ฐฐ์ด(char[]) ์ ๋ฐ์์ String์ผ๋ก ๋ณต์ฌํด์ ๋ฐํํ๋ค. โ length(), charAt(), substring(), equals(), toCharArray()
String str = "ABCD"; // 1) length int strLength = str.length(); System.out.println(strLength); // 4์ถ๋ ฅ // 2) charAt() char strChar = str.charAt(1); System.out.println(strChar); // "B" ์ถ๋ ฅ // 3) subDtring( , ) String strSub = str.substring(0, 3); System.out.println(strSub); // ABC ์ถ๋ ฅ // 4) equals (String) String newStr = "ABCD"; boolean strEquals = newStr.equals(str); System.out.println(strEquals); // true // toCharArray() char[] strCharArray = str.toCharArray(); // String ์ char[] ๋ก ๋ณํ // ๋ฐ๋๋ก char[] ๋ฅผ String๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ char[] charArray = {'A', 'B', 'C'}; String charArrayString = new String(charArray); // char[] ๋ฅผ String ์ผ๋ก ๋ณํ
๐น ๋ค์ฐจ์ ๋ฐฐ์ด
ํํ:
int[][] array = new int[][];
int[][][] array = new int[][][];๐๊ธฐ์กด ๋ฐฐ์ด์ ๋๊ดํธ๋ฅผ ์ถ๊ฐํด์ ์์ฑํจ
๐ป 2์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฐฉ๋ฒ 2๊ฐ์ง
โ 1. ์ค๊ดํธ๋ฅผ ์ฌ์ฉํด ์ด๊ธฐํ
int[][] array = { {1, 2, 3}, {4, 5, 6} };
โ 2. ๋ฐ๋ณต๋ฌธ์ ํตํ ์ด๊ธฐํ
int[][] array = 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; } }
๊ฐ๋ณ๋ฐฐ์ด
: Java์์ 2์ฐจ์ ๋ฐฐ์ด์ ์์ฑํ ๋ ์ด์ ๊ธธ์ด๋ฅผ ์๋ตํ์ฌ, ํ๋ง๋ค ๋ค๋ฅธ ๊ธธ์ด์ ๋ฐฐ์ด์ ์์๋ก ์ ์ฅํ ์ ์์โ ๊ฐ๋ณ๋ฐฐ์ด ์ ์ธ ๋ฐ ์ด๊ธฐํ ์์
// ๊ฐ๋ณ ๋ฐฐ์ด // ์ ์ธ ๋ฐ ์ด๊ธฐํ 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} };
โ ๋ฐฐ์ด์ ์ต๋๊ฐ ์ถ๋ ฅ ์์
// ์ต๋๊ฐ ๊ตฌํ๊ธฐ public static void main(String[] args) { int[] arr = { 3, 2, 1, 5, 1 }; int max = arr[0]; // ๋ฐฐ์ด๊ฐ์ค ์์๋ก ํ๋ ์ ํ for(int num:arr) { if(max<num){ // ์ค์ ๋ max๋ณด๋ค num์ผ๋ก ๋ค์ด์จ ๋ฐฐ์ด๊ฐ์ด ๋ ํด๋ max=num; // max๊ฐ์ num์ผ๋ก ๋ฐ๊พผ๋ค } } System.out.println(max); // ์ถ๋ ฅ: 5 }
728x90'JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ