중첩 반복문

  • 정삼각형 만들기

 

  • 구구단

 

 label

  • break와 같이 사용
public class LabelExam1 {
    public static void main(String[] args){
        outter:
        for(int i = 0; i< 3; i++){
            for(int k = 0; k < 3; k++){
                if( i == 0 && k == 2)
                    break outter;
                System.out.println(i + ", " + k);
            }
        }
    }
}

 

break와 사용 할 때 이중 for문 아예 나가짐

 

  • continue와 같이 사용 
public class LabelExam2 {
    public static void main(String[] args){
        outter:
        for(int i = 0; i< 3; i++){
            for(int k = 0; k < 3; k++){
                if( i == 0 && k == 2)
                    continue outter;
                System.out.println(i + ", " + k);
            }
        }
    }
}

 

continue와 사용할 때는 첫번째 for문으로 이동하고 for문 다시 돌림

배열 

  •  배열 선언
기본형타입[] 변수명 = new 기본형타입[배열의크기];
변수명[index값] = 값;
기본형타입[]변수명 = new 기본형타입[]{ 값1, 값2, .... };
기본형타입[] 변수명 = {값1, 값2, 값3.... };

타입[][] 변수명 = new 타입[행의수][열의수];
변수명[행인덱스][열인덱스] = 값;

 

  • 기본형 배열

boolean, byte, short, char, int, long, float, double 타입의 배열 

  • 참조형 배열

배열의 타입이 기본형이 아닌 타입, 배열 공간이 값이 아니라 값을 참조함

  • 이차원 가변 배열
타입[][] 변수명 = new 타입[행의수][];
변수명[행의인덱스] = new 타입[열의수];

 

- 이차원 가변 배열 더 깊이 공부해야할듯 

  • for each 문
for(타입 변수명 : 배열명){
.......
}
public class ArrayExam6 {
    public static void main(String[] args) {
        int[][] iarr = {{1,2,3},{3,4,5}};

        for(int[] arr :iarr){
            for(int num :arr){
                System.out.println(num);
            }
        }
    }
}

 

2차원 배열에서 1차원 배열 , 1차원 배열에서 정수 하나로 순환

 

Arrays

배열을 다룰 때 사용하는 유틸리티

import java.util.Arrays;

 

Arrays.copyOf

배열을 복사 하고 새 배열의 길이를 지정, 부족한 배열을 기본값으로 채워짐 (정수는 0)

public class Array14 {
    public static void main(String[] args) {
        // 원본 배열 선언 및 초기화
        int[] copyFrom = {1, 2, 3};

        // copyOf 메소드를 이용해 배열 복사 (같은 길이로 복사)
        int[] copyTo = java.util.Arrays.copyOf(copyFrom, copyFrom.length);

        // 복사된 배열 요소 출력
        for (int c : copyTo) {
            System.out.println(c); // 1, 2, 3 출력
        }

        System.out.println("----------------------------------");

        // copyOf 메소드를 이용해 배열 복사 (길이를 5로 확장)
        int[] copyTo2 = java.util.Arrays.copyOf(copyFrom, 5);

        // 확장된 배열 요소 출력 (추가된 공간은 기본값 0으로 채워짐)
        for (int c : copyTo2) {
            System.out.println(c); // 1, 2, 3, 0, 0 출력
        }
    }
}

 

Arrays.copyOfRange

복사, 두번째 매개변수(1)부터 세번째 매개변수(3:포함되지 않음)까지 

public class Array15 {
    public static void main(String[] args) {
        // 원본 배열 선언 및 초기화
        char[] copyFrom = {'h', 'e', 'l', 'l', 'o', '!'};

        // copyOfRange 메소드를 이용해 배열의 일부 복사 (인덱스 1부터 3 전까지)
        char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 1, 3);

        // 복사된 배열 요소 출력
        for (char c : copyTo) {
            System.out.println(c); // 'e', 'l' 출력
        }
    }
}

 

Arrays.compare

배열을 비교

import java.util.Arrays;

public class Array16 {
    public static void main(String[] args) {
        // 두 개의 배열 선언 및 초기화
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5}; // 비교할 배열
        // int[] array2 = {1, 2, 3, 4, 6}; // 값이 다른 배열
        // int[] array2 = {1, 2, 3, 4, 4}; // 길이와 값이 다른 배열

        // 두 배열 비교
        int compare = Arrays.compare(array1, array2);

        // 비교 결과 출력
        System.out.println(compare);
    }
}
반환값  
0 두 배열이 같음
<0 첫 번째 배열이 두 번째 배열보다 작음
>0 첫 번째 배열이 두 번째 배열보다 큼

 

Arrays.binarySearch  

정렬된 배열에서 이진탐색을 통해 특정 값을 찾음

값이 존재하면 인덱스 반환 

import java.util.Arrays;

public class Array18 {
    public static void main(String[] args) {
        // 배열 선언 및 초기화
        int[] array = {5, 4, 3, 1, 2};

        // 배열 정렬
        Arrays.sort(array);

        // 정렬된 배열에서 값 4의 인덱스 찾기
        int i = Arrays.binarySearch(array, 4);

        // 검색 결과 출력
        System.out.println(i);
    }
}

접근 제한자

제한자 같은 클래스  같은 패키지  하위 클래스 다른 패키지
public 0 0 0 0
protected 0 0 0 X
(단,상속 관계에서는 0)
(default) 0 0 X X
privite 0 X X X

새롭게 알게 된 것 

① java 배열 선언과 초기화 

int[] arr1 = {}; 
int[] arr2;

 

1.int[] arr1 = {} 초기화 된 배열

    • 빈 배열
    • 크기가 0으로 초기화 된 배열
    • 메모리 할당 됨
    • null이 아닌 배열 객체 참조
    • 배열의 크기 변경 불기
    • NPE(NullPointerException) 방지 , 배열이 생성 되었기 때문

2. int[] arr2; 배열 참조 변수 선언

저 코드에서 에러가 날 줄 알았는데 아니였음

  • 배열을 참조 할 수 있는 변수 선언, 실제로는 배열 객체 생성 되지 않았음(메모리 할당x)
  • 초기화 되지 않은 상태, 초기화 하지 않고 실제로 사용할 때는 컴파일 오류가 남
  • 초기화 없을 시 NPE(NullPointerException) 발생 하여 에러 찾기 쉬움  

→ 빈 배열이 필요하다면 int[] arr1 = {}; 사용 , 동적인 배열이 필요하다면 int[] arr2;을 선언 후 필요할 시에 초기화 한다. 

 

※0과 NULL의 차이점

특성 0 NULL
의미  숫자 값 0 아무것도 참조 하지 않음
사용 가능 타입 기본형(primitive type) 참조형(reference type)
메모리 상태 값 0이 저장 참조가 비어있음
연산 가능 여부  연산 가능 (0+1=1) 연산 불가능(NullPointerException)

 

② String 클래스

 

1. 주요 특징

  1. 불변성(Immutable)
  • 문자열이 생성 되면 변경 할 수 없다. 문자열의 내용을 변경하면 항상 새로운 String 객체 생성 
String s1 = "hello";
s1.concat(" world");  // "hello world"가 생성되지만, s1은 여전히 "hello"
System.out.println(s1);  // 출력: hello

 

  2.객체 생성 방식

  • 리터럴 방식: 문자열이 상수 풀(String Pool)에 저장.
  • new 키워드 사용: 항상 힙 메모리에 새로운 객체를 생성.
String s1 = "hello";            // 상수 풀에 저장
String s2 = new String("hello"); // 힙 메모리에 새로운 객체 생성
메모리 위치 상수 풀(Constant Pool) 힙 메모리(Heap)
객체 생성 여부 동일한 문자열이 있으면 재활용 항상 새로운 객체 생성
메모리 효율성 메모리 사용량 적음 메모리 사용량 높음
불변성 불변(Immutable) 불변(Immutable)
3. 불변성의 이점 
  • 스레드 안전(Thread-safe).
  • 상수 풀을 통해 메모리 사용 효율성 증가.

 

2. 문자열 상수 풀(String Constant Pool)

  • 문자열 상수 풀은 런타임 상수 풀의 일부분으로, 문자열 리터럴을 저장함. 
  • 동일한 문자열 리터럴이 여러 번 사용될 경우 메모리 낭비를 방지하기 위해 동일한 객체를 재사용
String str1 = "hello";   // 문자열 리터럴은 상수 풀에 저장
String str2 = "hello";   // 이미 상수 풀에 "hello"가 있으므로, 같은 객체를 참조
System.out.println(str1 == str2); // true (참조 비교)

String str3 = new String("hello"); // 힙 메모리에 새로운 객체 생성
System.out.println(str1 == str3); // false (다른 객체)

 

3. 문자열 비교 

 1. 참조 비교 (==)

  • 객체 참조 주소 비교 
  • 문자열 상수 풀에서 동일한 문자열 리터럴을 참조하면 true를 반환, new 키워드로 생성한 경우에는 false.
String str1 = "world";
String str2 = "world";
System.out.println(str1 == str2); // true (같은 객체)

String str3 = new String("world");
System.out.println(str1 == str3); // false (다른 객체)

 

 2. 값 비교 (equals())

 

  • 문자열의 내용을 비교.
  • 문자열 내용이 같으면 true를 반환.

 

String str1 = "java";
String str2 = new String("java");
System.out.println(str1.equals(str2)); // true (내용이 같음)
특성 상수 풀(Constant Pool) 힙 메모리(Heap Memory)
위치 메소드 영역(Method Area) 힙 메모리(Heap Memory)
저장 대상 상수, 문자열 리터럴 객체, 동적으로 생성된 데이터
중복 저장 여부 동일 상수는 한 번만 저장 (메모리 절약) 중복 객체 생성 가능 (메모리 낭비 가능)
생성 방법 리터럴 방식  new 키워드를 통해 명시적으로 생성
비교  ==로 참조 비교 시 동일 객체 참조 반환 가능 항상 새로운 객체, 참조 비교 시 다름

 

메소드 영역: 클래스, 메서드 정보, 상수 풀, 스태틱 변수를 저장. 모든 스레드가 공유.
힙(Heap): 객체와 인스턴스 변수를 저장. 모든 스레드가 공유
스택(Stack): 메서드 호출 시 생성되는 지역 변수와 호출 스택을 저장. 각 스레드마다 독립적.

'TIL' 카테고리의 다른 글

241210 [멋쟁이사자처럼 부트캠프 TIL 회고] Back-End school  (2) 2024.12.10
241209 TIL  (2) 2024.12.09
241206 TIL  (1) 2024.12.06
241205 TIL  (0) 2024.12.05
241203 TIL  (2) 2024.12.03

티스토리툴바