연산자, 조건문, 반복문, 배열

항해 99 : TIL - 2

학습 참조 : 강의 - Java 문법 종합반 2주차

팀과제 - 숫자 야구 프로그램

조건

• 컴퓨터는 0 과 9 사이의 서로 다른 숫자 3개를 무작위로 뽑는다 (ex) 123, 490
• 사용자는 컴퓨터가 뽑은 숫자를 맞추기 위해 시도한다
• 컴퓨터는 사용자가 입력한 세자리 숫자에 대해서, 아래의 규칙대로 스트라이크(S)와 볼(B)를 알려준다
  • 숫자의 값과 위치가 모두 일치하면 S
  • 숫자의 값은 일치하지만 위치가 틀렸으면 B
• 기회는 무제한이며, 몇 번의 시도 후에 맞췄는지 기록
• 숫자 3개를 모두 맞춘 경우, 게임을 종료

import java.util.Random;
import java.util.Scanner;

public class BaseballGame {
    public static void main(String[] args) {
        // 컴퓨터 점수 지정
        int[] computerNumbers = getComputerNumbers();

        // 사용자 입력 부분
        playBaseball(computerNumbers);
    }

    private static void playBaseball(int[] computerNumbers) {
        Scanner sc = new Scanner(System.in);
        System.out.println("컴퓨터가 숫자를 생성하였습니다. 답을 맞춰보세요!");

        int tryCount = 1;
        while (true) {
            System.out.print(tryCount + "번째 시도 : ");
            int userNumber = sc.nextInt();
            int[] userNumbers = {userNumber / 100, userNumber % 100 / 10, userNumber % 10};

            int strike = 0;
            int ball = 0;

            for (int i = 0; i < computerNumbers.length; i++) {
                for (int j = 0; j < userNumbers.length; j++) {
                    if (computerNumbers[i] == userNumbers[j]) {
                        if (i == j) {
                            strike++;
                        } else {
                            ball++;
                        }
                    }
                }
            }

            showBaseballScore(strike, ball);

            if (strike == 3) {
                System.out.println(tryCount + "번만에 맞히셨습니다.");
                System.out.println("게임을 종료합니다.");
                break;
            }

            tryCount++;
        }
    }

    private static void showBaseballScore(int strike, int ball) {
        if (ball == 3) {
            System.out.println(ball + "B");
        } else if (strike == 3) {
            System.out.println(strike + "S");
        } else {
            System.out.println(ball + "B" + strike + "S");
        }
    }

    private static int[] getComputerNumbers() {
        int[] computerNumbers = new int[3];
        Random random = new Random();

        for (int i = 0; i < computerNumbers.length; i++) {
            int randomNumber = random.nextInt(10); // 0 ~ 9
            computerNumbers[i] = randomNumber;

            // 중복 체크
            for (int j = 0; j < i; j++) {
                if (computerNumbers[j] == randomNumber) {
                    i--;
                    break;
                }
            }
        }
        return computerNumbers;
    }
}

 

설계

• 컴퓨터 랜덤 숫자 선택부 제작
  • Java util Random 으로 랜덤 숫자 생성
  • 중첩 반복문과 조건문을 사용해 랜덤한 3개의 숫자(0 ~9)를 중복 없이 컴퓨터 선택 숫자 배열에 저장.
  • 컴퓨터 선택 숫자를 메서드로 만들기
• 사용자 입력 및 숫자 야구 게임 메인 제작
  • Java util Scanner 로 사용자가 3자리 숫자를 입력
  • 사용자가 입력한 3자리 수를 자릿수 별로 나눠서 배열에 순서대로 저장( / 100 , % 100 / 10, % 10)
  • 중첩 반복문과 조건문을 사용해 컴퓨터 선택 숫자와 순서와 값이 모두 같을 경우 strike, 숫자만 같을 경우 ball 값을 증가
  • while문을 사용해 사용자의 값을 반복해서 입력 받고, 사용자의 입력 값이 3 strike가 될 경우 break문을 통해 반복문 종료
  • print 문을 사용해 반복 횟수 및, ball 과 strike 값을 출력
• ball , strike 출력부 제작
  
  • ball, strike가 각각 3이 될 경우 다른 값을 print하지 않도록 조건문 사용(예 : ball 이 3일 경우 ball 값만 출력 "3B")
• 실제 사용을 통한 테스트 및 각 부분 메서드로 변경.

 

학습 내용 정리

산술연산자

피연산 대상을 계산하는 역할 수행을 하는 연산자.

종류

• 더하기 +
• 빼기 -
• 곱하기 *
• 나누기(몫) / : 예) 4 / 2, 4를 2로 나눈 몫 2
• 나누기(나머지) % : 예) 5 % 2, 5를 2로 나눈 나머지 1
• 비트연산 << , >> : 잘 사용하지 않음

package test;

public class W02 {
    public static void main(String[] args) {
        // 산술 연산
        int x = 7, y = 4;

        // 더하기
        int z = x + y;
        System.out.println("x + y = " + z);
        // 빼기
        z = x - y;
        System.out.println("x - y = " + z);
        // 곱하기
        z = x * y;
        System.out.println("x * y = " + z);
        // 나누기(몫)
        z = x / y;
        System.out.println("x / y = " + z);
        // 나머지
        z = x % y;
        System.out.println("x % y = " + z);
    }
}

 

 

비교연산자

두 개의 값을 비교하는 연산자로 boolean 값을 반환한다.

종류

• >, < : 크고 작음
• >=, <= : 크거나 같음, 작거나 같음
• == : 두 값이 같음
• != : 두 값이 다름

package test;

public class W02_1 {
    public static void main(String[] args) {
        // 비교 연산
        int x = 10, y = 6;
        // 값이 크거나 작은지
        System.out.println(x > y);
        System.out.println(x < y);
        // 값이 크거나 같은지 , 작거나 같은지
        System.out.println(x >= y);
        System.out.println(x <= y);
        // 두 값이 같은지, 다른지
        System.out.println(x == y);
        System.out.println(x != y);
    }
}

 

 

논리연산자

비교 연산의 결과값으로 받는 boolean 값을 연결하는 연산자

종류

• &&(AND) : 모든 조건이 참이면 true, 하나라도 거짓이면 false 반환
• ||(OR) : 조건 중 하나라도 참이면 true, 모두 거짓이면 false 반환
• !(NOT) : 조건의 반대 값을 반환 참일 경우 false, 거짓이면 false 반환

package test;

public class W04 {
    public static void main(String[] args) {
        // 논리 연산자
        int x = 10, y = 5, z = 3;

        // AND 연산 - 2개 다 true일 때만 true 출력
        System.out.println(x > y && y > z);
        System.out.println(x > y && z > y);

        // OR 연산 - 2개 중 1개만 true이면 true 출력
        System.out.println(x > y || z > y);
        System.out.println(y > x || z > y);
        System.out.println(x > y || y > z);

        // NOT 연산 - 반대로 출력
        System.out.println(!true);
        System.out.println(!false);
    }
}

 

 

대입연산자

변수를 연산해서 저장하는 연산자(왼쪽의 변수에 오른쪽 변수의 값을 대입)

종류

• = (기본 대입 연산자) : 변수를 연산한 결과를 저장
• +=, -= (복합 대입 연산자) : 기본 대입 연산자를 간단하게 기록하는 방법
• 전위, 후위 증감 연산
  • ++, -- 처럼 복합 대입 연산자를 사용할 수 있음
  • 전위(연산 대상의 앞)에서 사용할 경우 증감 연산 이후 다른 연산을 실행하고
  • 후위(연산 대상의 뒤)에서 사용할 경우 다른 연산 이후 증감 연산이 수행된다.

package test;

public class W05 {
    public static void main(String[] args) {
        // 대입 연산자
        int x;
        x = 10;
        System.out.println("대입 연산: " + x);

        // 복합 대입 연산
        System.out.println("복합 대입 연산");
        System.out.println(x += 2);
        System.out.println(x /= 2);
        
        // 전위 증감
        int count = 0;
        System.out.println("전위 증감 연산");
        System.out.println(++count);
        System.out.println(--count);
        
        // 후위 증감
        System.out.println("후위 증감 연산");
        System.out.println(count++);
        System.out.println(count--);
        System.out.println(count);
    }
}

 

 

기타연산자

형변환 연산자, 삼항 연산자, instance of 등이 해당

종류

• 형변환 연산자 : (type)
  • 다른 타입의 변수를 연산할 때 사용하며 (type)을 형을 변환할 변수 앞에 쓴다.
  • int number = 9 + (int) 8.5; 이면 double인 8.5를 int 8로 변환해서 연산
• 삼항 연산자 : (조건)? 참 값 : 거짓 값
  • 조건을 비교해서 참일 때 값과 거짓일 때의 값을 반환함
  • int number = (8 > 5)? 1 : 0; 이면 조건이 참이므로 number에 1을 대입
• instance of : 클래스, 객체를 비교할 때 사용함

package test;

public class W06 {
    public static void main(String[] args) {
        // 기타 연산자
        // 형변환 연산자
        int intNum = 94 + (int)96.7; // 명시적 형변환
        System.out.println(intNum);
        double doubleNum = 94 + 96.7; // 자동 형변환 (double) 생략 가능
        System.out.println(doubleNum);

        // 삼항 연산자
        int result = (3 > 0)? 1 : 2;
        System.out.println(result);

        // instanceof
        // 클래스, 객체 비교 연산자
    }
}

 

 

연산자 우선순위

산술 연산자 → 비교 연산자 → 논리 연산자 → 대입 연산자

• 연산자 여러 개를 동시에 사용할 때는 연산자 우선 순위에 따라 연산 수행
• ( ) 괄호를 사용하는 경우 괄호 안의 연산이 최우선 순위로 수행
• 피연산자의 타입이 다를 경우 형 변환 연산자를 사용하거나 큰 범위의 변수 타입으로 자동으로 형 변환되어 연산 수행

 

 

if 조건문

특정 조건에 따른 다른 연산을 수행할 때 사용 (예: a 가 b 보다 크면 c 수행, a 가 b 보다 작으면 d 수행)

if문 : 특정 조건에 따른 연산 수행

• if ( 조건 ) { 연산 } 형태로 사용 : ( ) 안의 조건이 boolean true일 경우 { } 안의 연산을 수행

else문 : if 문의 조건을 만족하지 못할 경우 else 문의 연산 수행

• if ( 조건 ) { 연산 } else { 연산 } 형태로 사용 : ( ) 안의 조건이 true일 경우 if { } 안의 연산을 수행하고 false일 경우 else { } 안의 연산을 수행

else-if  문 : 다양한 조건을 사용할 때 사용 if 문에 else if 로 조건 추가

• if ( 조건1 ) { 연산 } else if ( 조건2 ) { 연산 } 형태로 사용 : if ( ) 안의 조건이 false 일 경우 else if ( ) 조건을 체크하여 true 일 경우 else if { } 안의 연산을 수행
• if , else if , else 문은 같이 사용할 수 있으며, else if 조건은 여러 개 만들 수 있음

중첩 조건문 : 조건문 안에 조건문을 넣어 조건을 여러 개 만족해야 연산을 수행하도록 설계 가능(if, else if, else 문에 if 문 추가 가능)

package test;

public class IfElse {
    public static void main(String[] args) {
        // if 조건문
        int x = 10;
        if (x > 5) {
            System.out.println("x는 5보다 크다.");
        }

        //if else 조건문
        if (x == 5) {
            System.out.println("x는 5 입니다.");
        } else {
            System.out.println("x는 5가 아닙니다.");
        }

        // if else-if 문
        if (x > 10) {
            System.out.println("x는 10보다 큽니다.");
        } else if (x > 5) {
            System.out.println("x는 5보다 큽니다.");
        } else {
            System.out.println("x는 5보다 작습니다.");
        }

        // 중첩 if문
        int y = 5;
        if (x <= 10) {
            System.out.println("x는 10보다 작거나 같습니다.");
            if (y == 5) {
                System.out.println("y는 5 입니다.");
            }
        }
    }
}

 

 

switch 조건문

조건이 하나일 때 코드의 중복을 줄이고 가독성이 좋은 조건문 표현식

• switch ( 피연산자 ) { case( 조건 ) : ( 연산 ) } 형태로 사용
• 피연산자가 case ( 조건 )을 만족할 경우 해당 case의 연산을 수행
  • case 문의 마지막에 break를 사용해서 해당 조건의 연산을 수행한 후 switch문 종료(break가 없으면 모든 case를 실행함)
  • 모든 case를 만족하지 못할 경우 default(기본값)을 수행(기본 조건 없을 시 생략 가능)

package test;

public class Switch {
    public static void main(String[] args) {
        // switch 조건문
        int number = 1;
        switch (number) {
            case 1:
                System.out.println("남자입니다.");
                break;
            case 2:
                System.out.println("여자입니다.");
                break;
            default:
                System.out.println("회원이 아닙니다.");
        }
    }
}

 

if문과 switch문의 차이점

• if문은 복합 조건을 사용할 수 있음 ( ) 안에 조건 여러 개를 지정할 수 있음
  • if ( 5 > 3 && 3 > 1 ) { 연산 } 같이 사용 가능
• switch문은 피연산자 1개에 대한 조건만 지원
• if문은 상대적으로 코드 중복이 많음
• switch문은 상대적으로 코드 중복이 적음

 

 

for 반복문

특정 조건에 따라 연산을 반복 수행할 때 사용, (예: a 가 b보다 작을 동안 c를 반복해서 출력)

• for (초기값; 조건문; 증가연산) { ( 연산 ) } 형태로 사용
  • 향상된 for문은 for (변수 타입 변수명 : 목록변수) { ( 연산 ) } 형태로 사용(연속된 목록 변수를 출력할 때 사용 - 배열 출력)
• 특정 조건은 초기값과 조건문을 통해서 정의, 조건문을 만족할 경우 연산을 수행하고 초기값에 증가연산 수행, 다시 조건문 체크 후 만족할 경우 반복(연산, 증가연산)하고 조건문을 만족하지 못할 경우 반복문 종료
• for문을 중첩하여 중첩 반복문으로 사용 가능 (예: 구구단 출력), for문 안에 조건문을 추가적으로 사용 가능.

package test;

public class For {
    public static void main(String[] args) {
        // for 반복문
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }

        // 중첩 반복문
        System.out.println("구구단 출력");
        for (int i = 1; i <= 9; i++) { // 특정 단만 나오도록 수정도 가능
            for (int j = 1; j <= 9; j++) {
                System.out.println(i + " x "+ j + " = " + i * j);
            }
        }

        // 향상된 반복문
        int[] numbers = {1, 2, 3, 4, 5, 6, 7};
        for (int number : numbers) {
            System.out.println(number);
        }

        // 반복문 안에 조건문 사용
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                System.out.println(i + "는 짝수입니다.");
            } else {
                System.out.println(i + "는 홀수입니다.");
            }
        }
    }
}

 

 

while 반복문

for문과 동일하게 특정 조건에 따라 연산을 반복 수행할 때 사용

• while( 조건문 ) { ( 연산 ) } 형태로 사용.
  • 조건문을 만족해야 연산을 수행하며 조건을 만족하지 못할 때까지 반복해서 연산 수행(반복 시 마다 조건 체크)
  • while( true ) { ( 연산 ) , if ( 조건 ) { break; } } 형태로 특정 if 조건문을 만족할 때까지 반복을 수행하는 무한 반복문의 형태로도 사용 가능
• do { ( 연산 ) } while( 조건 ) 형태로 사용하는 do while문의 경우 무조건 연산을 한 번 수행하고 while ( 조건 ) 의 조건문 체크하여 조건을 만족하면 반복하는 문맥(조건을 만족하지 못하더라도 연산을 1번 수행함).

package test;

public class While {
    public static void main(String[] args) {
        // while 반복문
        int n = 0;
        while (n < 5) {
            System.out.println(n);
            n++;
        }

        // do while 반복문 - 무조건 한 번은 실행되는 while 문
        n = 6;
        do {
            System.out.println(n);
        } while (n < 5);

        // 무한반복 while 문
        n = 0;
        while (true) {
            System.out.println(n);
            if (n == 3) { // if 문과 break 문을 사용해서 무한 반복문 종료
                break;
            }
            n++;
        }
    }
}

 

 

break, continue

반복문에서 반복문을 중단하거나 다음 loop(반복)으로 넘어가는 명령문

break

• 반복문을 종료시키고 반복문의 밖으로 나간다(중첩 반복문의 경우 가장 가까운 블록의 반복문을 중단함)
• switch문에서 case 뒤에서 조건문을 빠져 나오거나 반복문에서 특정 조건(if 문)을 만족할 경우 반복문을 중단하도록 사용

continue

• 반복문에서 다음 loop(반복)으로 넘어간다(continue 아래의 연산은 수행하지 않고 다음 loop로 넘어가서 조건을 체크 후 true일 경우 반복을 실행)
• 조건문(if문)을 사용해 특정 조건을 만족할 경우에만 다음 loop로 넘어가도록 사용 가능

package test;

public class BreakContinue {
    public static void main(String[] args) {
        // break - 반복문 종료
        for (int i = 0; i < 10; i++) {
            if (i > 3) {
                System.out.println("반복문 종료");
                break;
            }
            System.out.println(i);
        }

        // continue - 다음 loop로 이동
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue; // i % 2 의 나머지가 0일 경우 다음 loop로 이동
            }
            System.out.println(i);
        }

        // break, continue 동시 사용
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            if (i > 5) {
                System.out.println("반복문 종료");
                break;
            }
            System.out.println(i);
        }
    }
}

 

 

반복문 활용

반복문과 조건문을 잘 활용하면 다양한 프로그램을 설계할 수 있음.

구구단 출력 프로그램(특정 단수 제외, 특정 단수만 출력)

package test;

import java.util.Scanner;

public class W07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("출력 제외할 단수 선택: ");
        int num = sc.nextInt();
        for (int i = 2; i <= 9; i++) {
            if (i == num) {
                continue;
            }
            for (int j = 1; j <= 9; j++) {
                System.out.println(i +" x "+ j +" = "+ i*j);
            }
        }

        System.out.print("출력할 단수 선택: ");
        num = sc.nextInt();
        for (int i = 2; i <= 9; i++) {
            if (i == num) {
                for (int j = 1; j <= 9; j++) {
                    System.out.println(i + " x " + j + " = " + i * j);
                }
                break;
            }
        }
    }
}

 

 

배열

자료구조 : 기본형 변수가 1개의 값만 저장할 수 있는 것과 달리 배열형 변수는 여러 개의 값을 저장할 수 있음.

• 배열형 변수는 참조형 변수로 변수에 값을 직접 저장하는 것이 아닌 참조값을 저장한다.
• 배열은 정적 배열로 생성 시 크기를 지정해야 사용할 수 있다(동적 배열은 크기를 지정하지 않고 사용 가능).
• 배열에는 생성 시 정한 타입의 변수만 저장할 수 있고 다른 타입의 값은 저장할 수 없다.
• 배열의 인덱스는 0부터 시작 됨(new int[8] 배열의 경우 인덱스는 0 ~ 7까지만 있음, index는 배열 크기 - 1)

선언 및 조회, 초기화

• 배열을 사용하기 위해서는 배열의 타입과 이름을 선언하고 크기를 지정해서 배열을 생성해야 한다.
  • 선언 : int[ ] intArr(변수명); 형태로 선언할 수 있다.
  • 생성 : intArr = new int[3];  형태로 생성할 수 있다.
  • 선언과 생성은 동시에 할 수 있음 ( int[ ] intArr = new int[3]; )
• 배열의 값을 조회하는 방법으로는 index를 사용한 단 건 조회와 for문을 통한 순회(배열의 모든 값 조회)가 있다(향상된 for문 사용 가능).
• 초기화는 { }를 사용해 직접 값을 입력하는 방법과, for문(향상된 for문 포함)을 사용해 값을 입력하는 방법, Arrays.fill 메서드를 사용해서 초기화하는 방법이 있음

package test;

import java.util.Arrays;

public class Array1 {
    public static void main(String[] args) {
        // 배열 생성
        int[] intArr = new int[3];
        boolean[] boolArr = new boolean[3];
        String[] strArr = new String[3];

        // 배열 선언만
        int[] intArr2;
        // 배열 초기화
        intArr2 = new int[3];

        // 단건 조회
        System.out.println(intArr[0]);

        // 다건 조회
        for (int i : intArr) {
            System.out.println(i);
        }
        for (int i = 0; i < intArr2.length; i++) {
            System.out.println(intArr2[i]);
        }

        // 초기화
        int[] intArr3 = {1, 2, 3, 4, 5};
        String[] strArr2 = {"A", "B", "C"};

        // for문으로 초기화
        for (int i = 0; i < intArr3.length; i++) {
            intArr3[i] = i -1;
        }

        // 조회 향상된 for문 사용
        for (int i : intArr3) {
            System.out.println(i);
        }

        // 배열 주소 모두 같은 값으로 초기화
        Arrays.fill(intArr, 2);
        for (int item : intArr) {
            System.out.println(item);
        }
    }
}

 

 

얕은 복사, 깊은 복사

• 배열의 경우 참조형 변수이기 때문에 a 배열을 b 배열에 대입하는 얕은 복사를 하는 경우에는 참조 값이 복사되기 때문에 b 배열의 값을 변경할 때 a 배열의 값까지 같이 변경된다.
• 깊은 복사의 경우 for문을 사용한 복사와 .clone( ) , Arrays.copyOf( )등을 사용해서 a 배열의 값을 복사해서 새로운 배열 b를 만들 수 있다.
  • 2차원 이상의 다차원 배열에서는 .clone( )이 얕은 복사가 된다.

package test;

import java.util.Arrays;

public class Copy {
    public static void main(String[] args) {
        // 얕은 복사
        int[] a = {1, 2, 3, 4, 5};
        int[] b = a;
        System.out.println(a);
        System.out.println(b);
        a[2] = 0;
        System.out.println("a 배열: " + a[2] + " b 배열: " + b[2]);

        // 깊은 복사
        int[] c = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            c[i] = a[i];
        }
        System.out.println(a);
        System.out.println(c);
        a[2] = 3;
        System.out.println("a 배열: " + a[2] + " c 배열: " + c[2]);

        // 깊은 복사 메서드
        int[] d = a.clone(); // 다차원 배열에서는 얕은 복사
        System.out.println(a);
        System.out.println(d);
        int[] e = Arrays.copyOf(a, a.length); // 복사할 배열, 복사할 길이(length = 배열의 길이)
        System.out.println(a);
        System.out.println(e);
    }
}

 

 

String 배열

문자열을 다룰 때 사용하는 문자열 배열로 선언과 생성 방법은 기존 배열과 동일(초기화 방법도 기존 배열과 동일)

String 배열의 다양한 기능

• length( ) : 문자열 길이를 반환 (int)
• charAt(int index) : 문자열에서 해당 index의 문자를 반환 (char)
• subString(int from, int to) : 문자열에서 해당 범위의 문자열을 반환(to는 미포함) (String)
• equals(String str) : 문자열의 내용이 같은지 확인 같으면 true, 다르면false 반환 (boolean)
• toCharArray( ) : 문자열을 문자배열로 변환해 반환 (char[ ])
• new String(char[ ] charArr) : 문자배열을 받아서 String으로 복사해서 반환 (String)

package test;

public class Array2 {
    public static void main(String[] args) {
        // 문자, 문자열
        char ch = 'a';
        String str = "abcd";

        // length
        int strLength = str.length();
        System.out.println(strLength);

        // charAt(int index)
        char strChar = str.charAt(2);
        System.out.println(strChar);

        // subString(int fromIdx, int toIdx)
        String strSub = str.substring(0, 1);
        System.out.println(strSub);

        // equals(String str)
        String newStr = "abcd";
        boolean strEqual = newStr.equals(str);
        System.out.println(strEqual);

        // toCharArray() : String -> char[]
        char[] strCharArr = str.toCharArray();

        //Char[] -> String -> char
        char[] charArr = {'A', 'B', 'C'};
        String strArr = new String(charArr);
        System.out.println(strArr);
    }
}

 

 

다차원 배열

기본 배열은 열이 1개인 1차원 배열이고 열이 2개 이상인 배열을 2차원 배열이라고 하며 2차원 배열부터 다차원 배열이라고 부름

선언, 생성, 초기화

• 선언 시 int[ ] [ ] array 형태로 [ ] 를 만들 차원 수만큼 추가한다(int[ ] [ ] [ ] array 는 3차원 배열)
• 생성 시 array = new int[1][ ] 형태로 선언할 수 있다(1차원은 크기를 지정해야 되고, 2차원부터는 크기를 지정하지 않고 생성 가능)
• 초기화는 1차원 배열과 동일한 방법으로 가능하다( { { 1, 2 } , { 3 , 4 } } 처럼 중괄호를 이용한 초기화와 중첩 반복문을 사용한 초기화 가능)
• 가변 배열 : 2차원 배열을 생성할 때 행마다 다른 길이의 배열을 요소로 저장할 수 있음 { {1, 2, 3} , { 4 } , { 5, 6 } } 형태로 가변 배열 초기화 가능

다차원 배열 조회

• 중첩 반복문을 통해 2차원 배열 및 가변 배열을 출력할 수 있음

package test;

public class Array3 {
    public static void main(String[] args) {
        // 2차원 배열
        // 생성
        int[][] arr2D = new int[2][3];

        // 선언
        String[][] str2D;
        // 초기화
        str2D = new String[1][2];

        // 값 넣어서 생성
        int[][] array2D = {{1, 2}, {3, 4}, {5, 6}};

        // 단건 조회
        System.out.println(array2D[0][1]);

        // 다건 조회
        for (int i = 0; i < array2D.length; i++) {
            for (int j = 0; j < array2D[i].length; j++) {
                System.out.println(array2D[i][j]);
            }
        }
        
        // 가변 배열
        int[][] array = new int[2][];

        // 배열 원소마다 다른 크기로 지정
        array[0] = new int[3];
        array[1] = new int[1];
        
        int[][] array2 = {{1, 2, 3}, {4}, {5, 6}};

        // 다차원 배열
        int[][][] arr3D = new int[1][2][2];
        int[][][] array3D = {{{0, 1}, {2, 3}}, {{1, 2}, {3, 4}}};

        // 단건 조회
        System.out.println(array3D[0][1][1]);

        // 다건 조회
        for (int i = 0; i < array3D.length; i++) {
            for (int j = 0; j < array3D[i].length; j++) {
                for (int k = 0; k < array3D[i][j].length; k++) {
                    System.out.println(array3D[i][j][k]);
                }
            }
        }
    }
}

 

 

컬렉션

Java에서 배열을 고도화시켜 컬렉션이라는 이름으로 제공하는 자료구조(참조형 분류통), 참조형 변수만 저장하고 여러 기능을 제공함

컬렉션 기능

• 크기 자동조정 / 추가 / 수정 / 삭제 / 반복 / 순회 / 필터 / 포함 확인 / ....

종류

• List : 순서가 있는 데이터의 집합(데이터 중복 허용) - 배열과 비슷
• Stack : 데이터를 수직으로 쌓아놓고 넣고 빼서 조회하는 형식(First In - Last Out)
• Queue : 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합(First In - First Out)
• Set : 순서가 없는 데이터의 집합(데이터 중복 불가) - 순서 없고 중복 없는 배열
• Map : 순서가 없는 (key, value)쌍으로 이루어진 데이터의 집합(key 값 중복 안 됨)

 

List

ArrayList : 배열처럼 일렬로 데이터를 저장 및 조회(인덱스로 값을 1개씩 조회 가능)

• 동적 배열로 List에 값이 추가될 때마다 크기가 늘어남
• 기능
  • 선언 및 생성 : ArrayList<Integer> intList = new ArrayList<Integer>( ); 형태로 선언 및 생성
  • 초기화 : 사이즈 지정 없어서 필요 없음
  • 값 추가 : intList.add( 추가할 값) 형태로 값을 추가
  • 값 수정 : intList.set(수정할 값의 index, 수정할 값) 형태로 값을 수정
  • 값 삭제 : intList.remove(삭제할 값의 index) 형태로 값을 삭제
  • 전체 출력 : intList.toString() 형태로 전체 값을 출력
  • 전체 제거 : intList.clear( ) 형태로 전체 값을 삭제

LinkedList : 메모리의 남는 공간을 요청해 여러 곳에 나누어서 실제 값을 담고, 값이 있는 주소값으로 목록을 구성하고 저장

• LinkedList는 모든 값을 조회하는 속도가 느린 대신, 값을 중간에 추가하거나 삭제하는 속도는 빠름
• 기능(ArrayList와 다른 부분만 기록, 나머지는 ArrayList를 LinkedList로 바꾸기만 하면 동일)
  • 값 중간에 추가 : linkedList.add(추가할 index , 추가할 값) 형태로 중간에 값을 추가

package test;

import java.util.ArrayList;
import java.util.LinkedList;

public class Col1 {
    public static void main(String[] args) {
        // List -> 동적 배열
        // ArrayList
        ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 및 생성
        // List에 값 추가
        intList.add(1);
        intList.add(2);
        // List 값 읽기
        System.out.println(intList.get(1));

        // List 값 변경
        intList.set(0, 4);
        System.out.println(intList.get(0));

        // List 값 삭제
        intList.remove(0);
        System.out.println(intList.get(0));

        // List 전체 값 삭제
        System.out.println(intList.toString());
        System.out.println("리스트 값 전체 삭제");
        intList.clear();
        System.out.println(intList.toString());

        // LinkedList
        LinkedList<Integer> intList2 = new LinkedList<Integer>(); // 선언 및 생성
        intList2.add(1);
        intList2.add(3);
        intList2.add(2);

        // 전체 출력
        System.out.println(intList2.toString());

        // 값 추가
        intList2.add(2, 5);
        System.out.println(intList2.toString());

        // 값 변경
        intList2.set(1, 4);
        System.out.println(intList2.toString());

        // 값 지우기
        intList2.remove(0);
        System.out.println(intList2.toString());

        // 값 삭제
        intList2.clear();
        System.out.println(intList2.toString());
    }
}

 

 

Stack

• 상자에 물건을 넣고 빼듯이 밑에서 위로 쌓고, 꺼낼 때는 위에서부터 꺼냄
• 넣기(push( )) , 조회(peek( )), 꺼내기(pop( )) 기능만 존재
• 최근 데이터를 나열하거나 데이터의 중복처리를 막기위해 사용
• 기능
  • 선언 및 생성 : Stack<Integer> intStack = new Stack<Integer>( );
  • 추가 : intStack.push(추가할 값)
  • 조회 : intStack.peek( ) 맨 위에 값을 조회
  • 꺼내기 : intStack.pop( ) 맨 위 값부터 꺼내고 삭제

package test;

import java.util.Stack;

public class Col2 {
    public static void main(String[] args) {
        // Stack
        // 선언, 생성
        Stack<Integer> stack = new Stack<Integer>();

        // push
        stack.push(2);
        stack.push(4);
        stack.push(6);

        // stack.isEmpty()
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }

        stack.push(2);
        stack.push(4);
        stack.push(6);
        //peek
        System.out.println(stack.peek());

        // size
        System.out.println(stack.size());
    }
}

 

 

Queue

• 먼저 들어간 순서대로 값을 조회할 수 있음
• add( ) : 넣는 기능 , peek( ) : 조회 , poll( ) : 꺼내기 기능만 있음
• 생성자가 없으므로 바로 생성 불가, LinkedList를 사용해 Queue를 생성하고 받을 수 있음\
• 기능
  • 선언 및 생성 : Queue<Integer> intQeueu = new LinkedList<Integer>( );
  • 추가 : intQueue.add(추가할 값)
  • 조회 : intQueue.peek( ) 가장 먼저 들어간 값 조회
  • 꺼내기 : intQueue.poll( ) 가장 먼저 들어간 값 꺼내고 삭제

package test;

import java.util.LinkedList;
import java.util.Queue;

public class Col3 {
    public static void main(String[] args) {
        //Queue
        //선언, 생성
        Queue<Integer> queue = new LinkedList<Integer>();

        // 값 추가
        queue.add(3);
        queue.add(2);
        queue.add(7);

        // 값 추출
        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }

        queue.add(3);
        queue.add(2);
        queue.add(7);

        // 값 조회
        System.out.println(queue.peek());

        // 크기
        System.out.println(queue.size());
    }
}

 

 

Set

• 순서가 보장되지 않는 대신 중복을 허용하지 않음
• Set은 Set으로 쓸 수 있지만, HashSet, TreeSet 등으로 응용 가능
• Set은 생성자가 없어서 바로 생성 불가, HashSet을 사용해서 Set을 생성하고 받을 수 있음
• 기능
  • 선언 및 생성 : Set<Integer> set = new HashSet<Integer>( );
  • 추가  : set.add(추가할 값)
  • 삭제 : set.remover(삭제할 값)
  • 포함 확인 : set.contains(포함 확인 할 값) 값이 포함 되었는지 boolean 타입으로 반환

package test;

import java.util.HashSet;
import java.util.Set;

public class Col4 {
    public static void main(String[] args) {
        //Set
        //선언, 생성
        Set<Integer> set = new HashSet<Integer>();

        //값 추가
        set.add(1);
        set.add(4);
        set.add(8);

        //값 확인
        for (Integer num : set) {
            System.out.println(num);
        }
        
        //contains
        System.out.println(set.contains(1));
        System.out.println(set.contains(3));
    }
}

 

 

Map

• key-value 형태로 데이터를 저장, key값을 기준으로 value를 조회
• key 값 중복 허용 안 됨
• HashMap, TreeMap 등으로 응용하여 사용 가능
• 기능
  • 선언 : Map<String, Integer> map = new HashMap<>();
  • 추가 : map.put(추가 key 값, 추가 value 값)
  • 조회 : map.get(조회할 key 값)
    
    • 전체 key 조회 : map.keySet()
    • 전체 value 조회 : map.valueSet()
  • 삭제 : map.remover(삭제할 key 값)

package test;

import java.util.HashMap;
import java.util.Map;

public class Col5 {
    public static void main(String[] args) {
        //Map key - value pair
        // 선언, 생성
        Map<String, Integer> map = new HashMap<>();

        //key 값, value
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);

        //key 출력
        for (String key : map.keySet()) {
            System.out.println(key);
        }

        //value 출력
        for (Integer value : map.values()) {
            System.out.println(value);
        }

        //key 값으로 value 출력
        System.out.println(map.get("a"));
    }
}

 

length vs length( ) vs size( )

• length : 배열의 길이 조회
• length( ) : 문자열 길이 조회
• size( ) : 컬렉션 타입목록 길이 조회

 

담임 매니저님과 면담 기록 요약

• 공부하는 과정에서 기록으로 남기는 것이 중요함
  • TIL, WIL 등으로 배운 내용을 기록하면 기록하지 않을 때보다 기억하고 내것으로 만들기 좋음
  • 취업할 때 Histroy나 경험 등으로 살릴 수도 있음
• 주특기 과정에서 도움되는 방법
  • 인텔리제이의 내장 Git 관련 기능을 활용하면 팀 프로젝트에 도움이 됨
  • ChatGPT에게 코드 리뷰를 받은 후 구글링 또는 StackOverflow 등으로 코드에 대해 검사하고 내 생각을 넣어서 코드를 수정하면 내 것으로 만들 수 있음
• 항해 99 과정 수료 후 도움이 되는 정보
  • 항해 99의 잡담 방을 확인하면 다양한 사이드 프로젝트에 참여할 기회를 얻을 수 있음