kosta 클라우드 네이티브 애플리케이션 개발 과정 day 7

kosta 클라우드 네이티브 애플리케이션 개발 과정 day 7

---

배열 내용을 정렬하기 

 

정렬 알고리즘을 구현할 수도 있지만 지금은 api를 이용해보자! 

 

Arrays 메서드 이용하기

 

Arrays.sort는 퀵소트로 구현해놓았다. 

 

 

arr를 정렬해보자 ! 

 

api를 이용한 정렬 = Arrays.sort() 메서드 

 

int[] arr = {3, 2, 5};
System.out.println(Arrays.toString(arr));

// 오름차순 정렬하기
Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

 

새로운 배열을 이용한 for문으로 다시 역정렬해보기 ! 

 

// for문을 이용해 내림차순으로 바꿔보자
// 새로운 arr를 사용해서 하는 방법
int[] arr2 = new int[arr.length];
int count = 0;
for (int i = arr.length - 1; i > 0; i--) {
    System.out.println();
    arr2[count] = arr[i];
}
System.out.println(Arrays.toString(arr2));

 

 

 

버블 소트 구현해보기 ! 

 

    private static void bubbleSort() {
        int[] arr = {1, 2, 3, 4, 5};

        for (int i = 0; i< arr.length-1; i++) {
            for (int j = arr.length - 1; j > i; j--) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }

//        for (int i = arr.length - 1; i > 0; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 1; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 2; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 3; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }


        System.out.println(Arrays.toString(arr));
    }

 

 

 

---

2차원 배열도 정렬할 수 있을까? 

 

출력하는 방법 

//2차원 배열을 정렬하는 방법
int arr2[][] = {
        {2,90},
        {1,60},
        {3,20}
};

System.out.println(Arrays.deepToString(arr2));

 

 

Comparator 객체를 이용해서 2차원 배열 안의 1차원 첫 번째 인덱스를 기준으로 정렬하기 => 오름차순 

 

o1[0] - o2[0] => 음수를 리턴하면 자리를 변경하지 않고, 양수를 리턴하면 자리를 변경한다 ! 

 

Arrays.sort(arr2, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                // 정렬 기준 작성 : 2차원 배열 안에 있는 1차원 첫 번째 인덱스를 기준으로 오름차순
                return o1[0] - o2[0];   //
            }
        }
);

 

 

람다식으로 줄이기 

 

Arrays.sort(arr2, Comparator.comparingInt(o -> o[0]));

 

 

전체 코드 

 

package kosta.basic.day007;

import java.util.Arrays;
import java.util.Comparator;

public class ArraySort {
    public static void main(String[] args) {
        sort2DimensionalArray();
    }

    private static void sort2DimensionalArray() {
        //2차원 배열을 정렬하는 방법
        int[][] arr2 = {
                {2, 90},
                {1, 60},
                {3, 20}
        };

        System.out.println(Arrays.deepToString(arr2));

        // 배열은 단순한 sort 함수로 정렬되지는 않는다!
        Arrays.sort(arr2, new Comparator<int[]>() {
                    @Override
                    public int compare(int[] o1, int[] o2) {
                        // 정렬 기준 작성 : 2차원 배열 안에 있는 1차원 첫 번째 인덱스를 기준으로 오름차순
                        return o1[0] - o2[0];   //
                    }
                }
        );

        System.out.println(Arrays.deepToString(arr2));

        Arrays.sort(arr2, Comparator.comparingInt(o -> o[0]));

        System.out.println(Arrays.deepToString(arr2));


        int[][] arr3 = {
                {2, 90},
                {5, 30},
                {3, 80}
        };
        Arrays.sort(arr3, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o2[1] - o1[1];
            }
        });
        // Arrays.sort(arr3, (o1, o2) -> o2[1] - o1[1]);
        System.out.println(Arrays.deepToString(arr3));
    }

    private static void bubbleSort() {
        int[] arr = {1, 2, 3, 4, 5};

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = arr.length - 1; j > i; j--) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }

//        for (int i = arr.length - 1; i > 0; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 1; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 2; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }
//
//        for (int i = arr.length - 1; i > 3; i--) {
//            int temp = arr[i - 1];
//            arr[i - 1] = arr[i];
//            arr[i] = temp;
//        }


        System.out.println(Arrays.toString(arr));
    }

    private static void moveLastElementToFirst() {
        int[] arr = {1, 2, 3, 4, 5};

        for (int i = arr.length - 1; i > 0; i--) {
            int temp = arr[i - 1];
            System.out.println(i);
            arr[i - 1] = arr[i];
            arr[i] = temp;
        }

        System.out.println(Arrays.toString(arr));
    }

    private static void practiceSortMethod() {
        // 배열 내용을 정렬하기
        int[] arr = {3, 2, 5};
        System.out.println(Arrays.toString(arr));

        // 오름차순 정렬하기
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

        // for문을 이용해 내림차순으로 바꿔보자
        // 새로운 arr를 사용해서 하는 방법
        int[] arr2 = new int[arr.length];
        int count = 0;
        for (int i = arr.length - 1; i > 0; i--) {
            System.out.println();
            arr2[count] = arr[i];
        }
        System.out.println(Arrays.toString(arr2));
    }
}

 

 

 

 

---

Exception에 대해 배워보자 ! 

 

error와 exception의 차이 : 

- error : 그냥 에러 => 관리되지 않는 것 

- exception : 관리가 가능한 것 

 

 

모든 상황에 대해서 관련된 예외 클래스가 존재한다. 

 

e.g. 문자열을 정수로 변환할 때 발생하는 에러 => 

numberFormatException 

 

 

IDE가 알려주지 않고 실행하기 전에는 모르는 exception을 run time Exception이라고 한다. 

=> 실행해봐야 안다 ! 

 

 

---

arithmeticException이 발생했을 때 try catch 구문으로 처리하기 

 

int a = 10;
int b = 0;

try {
    int divided = a / b;
    System.out.println(divided);
} catch (ArithmeticException e) {
    System.out.println(e.getMessage());
}

 

finally -> 무조건 실행 

 

---

예외를 의도적으로 발생시켜서 throw하기 

 

private static void practiceThrowMethod() throws Exception {
    int a = 10;
    int b = 10;

    if (a==b){
     throw new Exception("같으면 안돼");
    }
}

 

 

메서드 내부에서 예외를 처리하지 않고 호출한 상위 객체로 예외를 던진다. 

 

해당 메서드에서 예외를 처리해주는 방법 

1) try - catch 

2) 다시 throw 

 

try{
    practiceThrowMethod();
} catch (Exception e){
    e.printStackTrace();    // 예외 발생한 자취를 추적해준다.
}

 

 

---

가위바위보 게임을 만들어보자 ! 

 

package kosta.mission2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Mission2_04 {
    public static void main(String[] args) throws IOException {
        // TODO : 가위바위보 게임을 만들어보자
        // 맨 첫 줄에 케이스 횟수가 주어진다
        // 다음 줄에 A의 케이스가 주어진다
        // 다음 줄에 B의 케이스가 주어진다

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        int testCase = Integer.parseInt(bufferedReader.readLine());
        int[][] cases = new int[2][testCase];
        
        for (int i = 0; i < 2; i++) {
            StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());

            for (int j = 0; j < testCase; j++) {
                cases[i][j] = Integer.parseInt(stringTokenizer.nextToken());
            }
        }

        for (int i = 0; i < testCase; i++) {
            int A = cases[0][i];
            int B = cases[1][i];

            System.out.println(judgeWinner(A, B));
        }
    }

    private static String judgeWinner(int A, int B) {
        String a = "A";
        String b = "B";
        String draw = "D";

        // 1 = 가위
        // 2 = 바위
        // 3 = 보

        // 1, 2 => number2 win
        // 1, 3 => number1 win
        // 2, 3  => number2 win

        if (A == 1 && B == 2) {
            return b;
        }

        if (A == 1 && B == 3) {
            return a;
        }

        if (A == 2 && B == 3) {
            return b;
        }

        if (A == 2 && B == 1) {
            return a;
        }

        if (A == 3 && B == 1) {
            return b;
        }

        if (A == 3 && B == 2) {
            return a;
        }

        return draw;
    }
}

 

---

객체 지향 프로그래밍 

 

 

프로그래밍 기술의 변천 

과거 : 절차적 프로그래밍 

 

시대의 흐름 => 빠르게 변화하는 세상 => 빠른 소프트웨어 업데이트의 필요성 

 

파이썬이 지금 뜨는 이유? 

- 인공지능, 데이터 

 

자바는 20-30년 전의 시대 정신 

=> 객체 지향 언어의 등장 ! 

 

객체 지향 언어에서 가장 중요한 특징은 무엇일까?! 

=> 확장성 (확장에는 열려 있고 수정에는 닫혀 있다 !) 

=> 재활용성 

 

=> 고객의 needs 그때 그때 달라지는 시대의 변화 => 민첩하게 대응할 수 있다 ! 

 

---

객체 지향은 무엇일까? 

 

상호작용하는 객체들로 이루어진 세상 // 상호작용하는 객체들로 이루어진 프로그램 

 

객체란

=> 상태와 행동으로 구분한 것이다 ! 

= 상태 (특성)

= 행동 (기능) 

 

 

객체를 표현하는 한 가지 방법 => 클래스 

 

e.g. 쇼핑몰 

- 회원

- 상품

- 장바구니

- 주문

- 결재

- 배송 

 

 

 

클래스를 만드는 방법 

=> 공통된 데이터 구조와 기능을 추출한다 

 

e.g.

- 계좌번호

- 예금주 이름 

- 잔액

- 예금한다

- 인출한다 

 

 

객체 모델링 = 추상화 작업 

=> 일단 필요한 것이 무엇일지를 정의한다 ! 

 

---

account 객체 생성 해보기 ! 

 

package kosta.oop.day007;

public class Account {
    // 계좌 객체
    // 상태 (특성) : 계좌번호, 계좌주, 잔액  => 멤버 변수 (=필드) ! (지금까지는 지역 변수)
    // 행동 (기능) : 입금하다, 출금하다 => 멤버 메서드

    String accountNo;
    String ownerName;
    int balance;

    public void deposit(int amount){
        balance +=amount;
    }

    public int withdraw(int amount){
        balance -= amount;
        return amount;
    }
}

 

만든 객체를 활용해보자.

 

데이터 타입을 클래스로 선언하여 생성하는 것을 인스턴스 변수라고 할 수 있다. 

= 객체 

=> 주소값을 갖는다. 

 

객체 생성 후 호출 연습 ! 

// 객체 생성하기 !
// 데이터 타입에 클래스 타입이 있다. = 인스턴스 변수

Account account = new Account();

account.accountNo = "111 - 111";
account.ownerName = "홍길동";
account.balance = 10000;

account.deposit(5000);

 

withdraw 메서드에 예외를 던지는 기능을 구현해보자 ! 

 

public void withdraw(int amount){
    if (balance < amount){
        throw new IllegalArgumentException("balance < amount !!!");
    }
    balance -= amount;
}

 

---

 

1. 객체 대상 선정

2. 해당 객체에 대한 상태와 행동

3. 공통된 상태와 행동을 기준으로 클래스 생성 

4. 객체를 생성 

5. 객체를 사용(필드를 초기화, 메서드를 호출 등)