이번 글에서는 문자열을 배열로 선언한 후,
==(참조 비교) 와 .equals()(내용 비교) 의 차이를 직접 확인합니다.
특히 new String() 으로 생성된 문자열과 리터럴로 초기화된 문자열은 메모리 구조에서 차이가 나므로
비교 연산자 사용 시 주의가 필요합니다.

📌 예제 코드

public class ArrayReferenceObjectExample {
	public static void main(String[] args) {
		String[] strArray = new String[3];
		strArray[0] = "Java";
		strArray[1] = "Java";
		strArray[2] = new String("Java");

		System.out.println(strArray[0] == strArray[1]);
		System.out.println(strArray[0] == strArray[2]);
		System.out.println(strArray[0].equals(strArray[2]));
	}
}

💬 코드 설명

• strArray[0] = "Java";
  → 문자열 리터럴 "Java"를 저장 (상수 풀에 등록됨)
• strArray[1] = "Java";
  → 동일한 리터럴이므로 strArray[0]과 같은 객체를 참조
• strArray[2] = new String("Java");
  → "Java"와 같은 내용을 가지지만, 새로운 객체를 생성함
• ==
  → 참조가 같은지 비교 (메모리 주소 비교)
• .equals()
  → 문자열의 실제 내용이 같은지 비교

💻 실행 결과

true
false
true

📌 간단 정리

💡 포인트 정리

• "문자열" 리터럴은 상수 풀에 저장, 동일 리터럴은 같은 참조를 공유
• new String("문자열")은 항상 새로운 객체를 생성
• ==는 참조 비교 (주소 비교)
  → 객체가 같은 메모리를 참조하는가
• .equals()는 내용 비교
  → 문자열 값 자체가 같은가

🕘 오전 수업 요약

✅ 배열 생성과 기본값 확인

• new 키워드를 사용해 int[], double[], String[] 배열 생성
• 기본값:
  • int → 0
  • double → 0.0
  • String → null

✅ 배열 값 할당 및 출력

• 인덱스를 이용해 값 저장 및 출력

arr1[0] = 10; arr2[1] = 0.2; array[2] = "3월";

✅ 배열의 길이 활용 (.length)

• 반복문에 배열 길이 활용 (for (int i = 0; i < arr.length; i++))
• 총합과 평균 계산 실습

🕐 오후 수업 요약

✅ 1. 2차원 배열 생성과 값 출력 (MulltidimensionalArrayByValueListExample)

• 중첩 배열 사용: int[][] scores = { {80,90}, {76,88}, ... }
• 반별 점수 출력과 평균 계산
• 전체 학생 수 집계와 전체 평균 계산

System.out.println("scores[" + i + "][" + j + "] : " + scores[i][j]);

✅ 2. 고정형 2차원 배열 (MultidimensionalArrayByNewExample)

• new int[2][3] → 2행 3열 배열 생성
• 모든 요소 출력 후 값 입력, 평균 계산

✅ 3. 가변형 2차원 배열

• 행마다 열 개수가 다른 배열 구조

int[][] eng = new int[2][];
eng[0] = new int[2];
eng[1] = new int[3];

• 각각의 행에 점수 대입 후 전체 평균 계산

📌 8일차 핵심 요약

이번 글에서는 new 키워드를 사용하여 2차원 배열을 생성하는 방법을 익히고,
고정형 2차원 배열과 가변형 2차원 배열의 차이를 비교합니다.
또한 수학과 영어 점수를 배열로 관리하며, 전체 평균을 계산해보는 예제를 작성합니다.

📌 예제 코드

public class MultidimensionalArrayByNewExample {
	public static void main(String[] args) {
		int[][] math = new int[2][3];
		for (int i = 0; i < math.length; i++)
			for (int j = 0; j < math[i].length; j++)
				System.out.println("math[" + i + "][" + j + "] : " + math[i][j]);

		math[0][0] = 80; math[0][1] = 83; math[0][2] = 85;
		math[1][0] = 86; math[1][1] = 90; math[1][2] = 92;

		int stu = 0, sum = 0;
		for (int i = 0; i < math.length; i++) {
			stu += math[i].length;
			for (int j = 0; j < math[i].length; j++)
				sum += math[i][j];
		}
		System.out.println("전체 학생의 수학 평균 점수 : " + (double) sum / stu + "\n");

		int[][] eng = new int[2][];
		eng[0] = new int[2];
		eng[1] = new int[3];

		for (int i = 0; i < eng.length; i++)
			for (int j = 0; j < eng[i].length; j++)
				System.out.println("eng[" + i + "][" + j + "] : " + eng[i][j]);

		eng[0][0] = 90; eng[0][1] = 91;
		eng[1][0] = 92; eng[1][1] = 93; eng[1][2] = 94;

		stu = sum = 0;
		for (int i = 0; i < eng.length; i++) {
			stu += eng[i].length;
			for (int j = 0; j < eng[i].length; j++)
				sum += eng[i][j];
		}
		System.out.println("전체 학생의 영어 평균 점수 : " + (double) sum / stu + "\n");	
	}
}

💬 코드 설명

🟢 수학(math) 배열 – 고정형

• int[][] math = new int[2][3];
  → 2행 3열의 고정형 2차원 배열 생성
• 모든 요소는 초기값 0으로 채워짐
• 각 인덱스에 점수를 수동 입력한 후 평균 계산

🔵 영어(eng) 배열 – 가변형

• int[][] eng = new int[2][];
  → 2행만 생성한 뒤, 각 행에 다른 열 길이를 개별 설정
  • eng[0] = new int[2]; → 2열
  • eng[1] = new int[3]; → 3열
• 가변 구조이므로 행마다 학생 수가 달라도 가능

💻 실행 결과 (요약)

math[0][0] : 0
math[0][1] : 0
math[0][2] : 0
...
전체 학생의 수학 평균 점수 : 84.33333333333333

eng[0][0] : 0
eng[0][1] : 0
...
전체 학생의 영어 평균 점수 : 92.0

📌 간단 정리

💡 포인트 정리

• new int[행][열] → 고정형 2차원 배열
• new int[행][] → 가변형 2차원 배열
• 배열의 길이는 .length로 확인 (각 행도 .length 사용 가능)
• 평균 계산 시 학생 수(stu) 누적 후 (double) sum / stu로 계산
• 초기값은 기본형: 0, 참조형: null

이번 강의에서는 2차원 배열을 값 목록으로 초기화하고,
각 반별 평균과 전체 평균을 계산하는 프로그램을 작성해봅니다.
2차원 배열은 행과 열 구조로 구성되며,
각 배열의 길이는 .length 속성으로 확인할 수 있습니다.

📌 예제 코드

public class MulltidimensionalArrayByValueListExample {
	public static void main(String[] args) {
		int scores[][] = {
			{ 80, 90, 96 },
			{ 76, 88 },
			{ 80, 90, 55 },
			{ 50, 60, 70, 80 }
		};

		System.out.println("1차원 배열 길이(전체 반의 수) : " + scores.length);
		for (int i = 0; i < scores.length; i++) {
			System.out.println("2차원 배열 길이( " + (i + 1) + "번째 반의 학생 수) : " + scores[i].length);
			for (int j = 0; j < scores[i].length; j++)
				System.out.println("scores[" + (i + 1) + "][" + (j + 1) + "] : " + scores[i][j]);
		}

		int sum = 0, allSum = 0, pCount = 0;
		for (int i = 0; i < scores.length; i++) {
			for (int j = 0; j < scores[i].length; j++, pCount++)
				sum += scores[i][j];
			System.out.println((i + 1) + "반의 평균 점수 : " + (double) sum / scores[i].length);
			allSum += sum;
			sum = 0;
		}
		System.out.println("전체 학생의 평균 : " + (double) allSum / pCount);
	}
}

💬 코드 설명

• int[][] scores = { ... };
  → 2차원 배열 선언과 값 목록으로 초기화
  → 각 반마다 학생 수가 다름 → 가변 배열
• scores.length
  → 반의 개수 (1차원 배열 길이)
• scores[i].length
  → 해당 반의 학생 수 (2차원 배열의 각 행 길이)
• sum += scores[i][j]
  → 한 반의 점수 합계 계산
• (double) sum / scores[i].length
  → 각 반의 평균 계산
• allSum, pCount
  → 전체 점수 합과 전체 학생 수를 누적 → 마지막에 전체 평균 계산

💻 실행 결과 (예시)

1차원 배열 길이(전체 반의 수) : 4
2차원 배열 길이( 1번째 반의 학생 수) : 3
scores[1][1] : 80
scores[1][2] : 90
scores[1][3] : 96
2차원 배열 길이( 2번째 반의 학생 수) : 2
scores[2][1] : 76
scores[2][2] : 88
...

1반의 평균 점수 : 88.66666666666667
2반의 평균 점수 : 82.0
3반의 평균 점수 : 75.0
4반의 평균 점수 : 65.0
전체 학생의 평균 : 77.875

📌 간단 정리

💡 포인트 정리

• 2차원 배열은 [행][열] 구조, 각 행의 길이는 서로 다를 수 있음
• 배열.length는 1차원 배열(반 수)
  배열[i].length는 각 행의 길이(학생 수)
• 반복문 중첩 시 반복 기준을 .length로 설정하면 유지보수에 유리
• 전체 평균 = 총합 ÷ 총 학생 수 → 따로 누적 변수 필요

이번 글에서는 배열의 크기를 알려주는 length 속성을 활용하여
반복문을 동적으로 처리하고, 배열 요소의 합계와 평균을 계산하는 방법을 학습합니다.
배열의 길이는 고정되어 있지만, length 속성을 활용하면 코드를 유연하게 작성할 수 있습니다.

📌 예제 코드

public class ArrayLengthExample {
	public static void main(String[] args) {
		int scores[] = { 84, 90, 96 }, sum = 0;
		double avg;

		for (int i = 0; i < scores.length; i++)
			sum += scores[i];
		System.out.println("sum : " + sum);
		
		avg = (double) sum / scores.length;
		System.out.println("avg : " + avg);
	}
}

💬 코드 설명

• int[] scores = {84, 90, 96};
  → 정수형 배열을 값 목록으로 초기화
• scores.length
  → 배열의 길이(요소 개수)를 반환 → 이 경우 3
• for (int i = 0; i < scores.length; i++)
  → 배열의 길이만큼 반복 → 데이터 개수 변화에 유연하게 대응 가능
• (double) sum / scores.length
  → 정수 나눗셈을 피하고 실수 평균을 계산

💻 실행 결과

sum : 270
avg : 90.0

📌 간단 정리

💡 포인트 정리

• .length는 배열의 길이 (인덱스 수 X)
• 배열을 반복 처리할 때는 .length를 기준으로 하면 유지보수가 쉬움
• 평균 계산 시 정수/정수 나눗셈은 주의! → (double) 형변환 필요
• .length는 괄호가 없음 → 배열.length, 메서드 아님!

이번 글에서는 배열을 new 키워드로 생성하는 방법을 배웁니다.
자바에서는 배열을 생성할 때 기본값으로 자동 초기화가 되며,
기본형(int, double)과 참조형(String)의 초기값이 서로 다릅니다.

📌 예제 코드

public class ArrayCreateByNewExample {
	public static void main(String[] args) {
		int[] arr1 = new int[3];
		for (int i = 0; i < arr1.length; i++)
			System.out.print("arr1[" + i + "] : " + arr1[i] + ",\t");
		System.out.println("\n" + "-".repeat(50));

		arr1[0] = 10;
		arr1[1] = 20;
		arr1[2] = 30;
		for (int i = 0; i < arr1.length; i++)
			System.out.print("arr1[" + i + "] : " + arr1[i] + ",\t");
		System.out.println("\n" + "-".repeat(50));

		double[] arr2 = new double[3];
		for (int i = 0; i < arr2.length; i++)
			System.out.print("arr2[" + i + "] : " + arr2[i] + ",\t");
		System.out.println("\n" + "-".repeat(50));

		arr2[0] = 0.1;
		arr2[1] = 0.2;
		arr2[2] = 0.3;
		for (int i = 0; i < arr2.length; i++)
			System.out.print("arr2[" + i + "] : " + arr2[i] + ",\t");
		System.out.println("\n" + "-".repeat(50));

		String array[] = new String[3];
		for (int i = 0; i < array.length; i++)
			System.out.print("arr3[" + i + "] : " + array[i] + ",\t");
		System.out.println("\n" + "-".repeat(50));

		array[0] = "1월";
		array[1] = "2월";
		array[2] = "3월";
		for (int i = 0; i < array.length; i++)
			System.out.print("arr3[" + i + "] : " + array[i] + ",\t");
	}
}

💬 코드 설명

• new int[3], new double[3], new String[3]
  → new 키워드로 배열을 생성하고 크기만 지정, 값은 자동 초기화
• 기본값:
  • int → 0
  • double → 0.0
  • String → null (참조형)
• 이후 배열에 각각 값을 직접 대입한 후, 내용을 다시 출력함

💻 실행 결과

arr1[0] : 0,	arr1[1] : 0,	arr1[2] : 0,
--------------------------------------------------
arr1[0] : 10,	arr1[1] : 20,	arr1[2] : 30,
--------------------------------------------------
arr2[0] : 0.0,	arr2[1] : 0.0,	arr2[2] : 0.0,
--------------------------------------------------
arr2[0] : 0.1,	arr2[1] : 0.2,	arr2[2] : 0.3,
--------------------------------------------------
arr3[0] : null,	arr3[1] : null,	arr3[2] : null,
--------------------------------------------------
arr3[0] : 1월,	arr3[1] : 2월,	arr3[2] : 3월,

📌 간단 정리

💡 포인트 정리

• 배열은 new 타입[크기]로 생성하며, 초기값은 자동으로 지정됨
• 기본형은 0, 참조형은 null로 초기화됨
• .length 속성을 통해 반복문에서 쉽게 접근 가능
• 필요 시 배열 값은 인덱스를 통해 개별적으로 수정 가능

✅ 오전 수업 요약: 문자열 메서드 심화

1. length() – 문자열 길이 확인

• 주민등록번호 등 입력 자릿수 검증에 사용

if (str.length() == 13) { ... }

2. replace() – 문자열 치환

• 특정 문자열을 다른 문자열로 변경
• 원본 문자열은 변경되지 않음 (불변)

String replaced = str.replace("자바", "Java");

3. substring() – 문자열 자르기

• 주민등록번호를 앞자리/뒷자리로 나누는 예제

str.substring(0, 6);   // 앞 6자리
str.substring(7);      // 8번째 문자부터 끝까지

4. indexOf(), contains() – 문자열 포함 여부

• indexOf()는 위치 반환, 없으면 -1
• contains()는 true/false 반환

if (str.contains("자바")) { ... }

✅ 오후 수업 요약: 배열 활용 및 문자열 분리

1. split() – 문자열 분리

• 구분자 기준으로 문자열을 배열로 분리

String[] data = str.split(",");

• 배열 요소를 반복문으로 출력

2. 배열 선언과 초기화

String[] season = {"봄", "여름", "가을", "겨울"};
season[1] = "Summer"; // 값 변경 가능

3. 배열을 이용한 총합 및 평균 계산

int[] scores = {83, 90, 87};
int sum = 0;
for (int i = 0; i < scores.length; i++)
    sum += scores[i];
double avg = (double) sum / scores.length;

4. new 키워드를 통한 배열 재할당

scores = new int[] {83, 90, 87};

• 배열을 새롭게 생성하여 교체 가능

📌 7일차 핵심 요약표

이번 글에서는 값 목록을 사용해 배열을 선언하고,
new 키워드를 이용한 배열 재생성 방식을 배웁니다.
자바에서는 배열이 한 번 생성되면 크기가 고정되므로,
배열을 다시 만들고자 할 때는 new를 이용한 새 배열 생성이 필요합니다.

📌 예제 코드

public class ArrayCreateByValueListExample2 {
	public static void main(String[] args) {
		int scores[] = { 83, 90, 87 }, sum = 0;

		for (int i = 0; i < 3; i++)
			sum += scores[i];
		System.out.println("총합 : " + sum);

		scores = new int[] { 83, 90, 87 };
		for (int i = 0; i < 3; i++)
			System.out.println("score[" + i + "]: " + scores[i]);
	}
}

💬 코드 설명

• int scores[] = { 83, 90, 87 };
  → 정수형 배열을 값 목록으로 바로 선언 및 초기화
• sum += scores[i];
  → 배열의 각 값을 순회하면서 합계 계산
• scores = new int[] { 83, 90, 87 };
  → 기존 배열을 새 배열로 재생성
  → 이 방식은 값 목록 초기화를 `선언 없이 단독으로 쓸 수 있는 유일한 방법
• 이후 다시 반복문을 돌면서 새로운 배열 값을 출력

💻 실행 결과

총합 : 260
score[0]: 83
score[1]: 90
score[2]: 87

📌 간단 정리

💡 포인트 정리

• 배열을 재생성할 때는 반드시 new 타입[] { ... } 형식으로 작성해야 함
• int[] arr = { ... }는 선언할 때만 가능, 대입 시엔 new 필수
• 배열은 한 번 생성된 후 크기를 변경할 수 없기 때문에,
  새로운 값으로 바꾸려면 재생성이 필요함