kungfugay's Blog

split 메소드는 token을 기준으로 문자열을 슬라이싱 한다.

반환값은 String[] 이다.

public class Sample3 {
    public static void main(String[] args) {
        // String
        // 문자열 자르기
        // Split - array, 제어문

        String str = "AA-BB-CC-DD";               // -는 token임.
        String human = "홍길동-24-172.1-서울시";


        String[] msg = str.split("-");      // split 메소드의 리턴값은 문자열의 배열임
        String[] msg2 = human.split("-");

        System.out.println(Arrays.toString(msg));
        System.out.println(Arrays.toString(msg2));
        // Integer.parseInt(msg[1])
        // Integer.parseDouble(msg[2])

    }
}

static int[] arrayTwoOfArrayOne(int[][] arr) {
    // return 할 일차원 배열 선언
    int[] nArray = null;
    
    // 순환을 돌면서 파라미터 배열의 길이(전체 요소 수)를 구하고,
    int total_length = 0;
    for (int i=0; i<arr.length; i++) { // 행의 개수만큼 반복
        total_length += arr[i].length; // 각 행의 길이를 합산
    }
    
    // return 할 일차원 배열 크기 초기화
    nArray = new int[total_length];

    // 다시 순환을 돌면서 배열을 넣는다.
    int w = 0; // 인덱스 번호 추적을 위한 변수
    for (int i=0; i<arr.length; i++) { // 행의 개수만큼
        for (int j=0; j<arr[i].length; j++) { // 열의 개수만큼
            int temp = arr[i][j];
            nArray[w] = temp;
            w++;
        }
    }
    return nArray;
}

함수 호출부

실행결과

이것을 함수의 내부 처리 방식으로 확인해보자.

● 코드 예시 1: value 할당 방식

함수 내부에서 아무리 장난질을 쳐도 원본 데이터가 변경되지 않는다.

public class Practice {
    public static void main(String[] args) {
        int n = 123;
        System.out.println("초기 n = " + n);

        function1(n);
        System.out.println("main 복귀 n = " + n);
    }

    static void function1 (int n) {
        n = n*n;
        System.out.println("함수 내부 n = " + n );
    }
}

●  코드 예시 2: 메모리 주소 할당 방식

함수 내부에서 값이 변경되면 원본 데이터가 변경된다.

import java.util.Arrays;

public class Practice2 {
    public static void main(String[] args) {
        // 원본 어레이
        int[] arr = { 1, 2, 3 };

        // 원본 데이터 확인:
        System.out.println("main 함수의 원본 데이터 배열");
        System.out.println(Arrays.toString(arr));

        // 함수 호출
        // function에 arr 자체를 넘겨줌 (address 할당)
        function(arr);

        // 원본 데이터 확인:
        System.out.println("main 함수로 복귀하였음.");
        System.out.println(Arrays.toString(arr));
    }

    static void function(int[] arr) {
        arr[0] = 999;
        arr[1] = 999;
        System.out.println("함수 내부입니다.");
        System.out.println(Arrays.toString(arr));
    }
}

● Function = 함수 = 처리자(Processor)

● 목적: 코드를 간략히 함, 동일한 처리 코드를 집약적으로 작성

● 기본적인 구조

구성요소1) 매개변수 (=parameter, 인수, 인자)

구성요소2) 함수 내부에서 처리되는 로직

구성요소3) return 값 (=return value, 돌아오는 값)

* 파라미터와 return 값은 없을 수도 있다.

* return 값이 없는 것을 void라고 한다.

● 가능한 함수의 선택지

- 매개변수 X, 리턴값 X

- 매개변수 O, 리턴값 X

- 매개변수 X, 리턴값 O

- 매개변수 O, 리턴값 O

● 가능한 매개변수의 개수?

- 0개 ~ 약 20개 이상?

● 가능한 리턴값의 개수?

- 대체로 없거나 1개임 (but 예외가 존재)

● 코드 예시 1: 매개변수와 리턴값이 모두 없는 함수 (void형 함수)

public class MainClass {
    public static void main(String[] args) {
        
        // 함수 호출
		function();
    }
    
    // 매개변수, 리턴값이 모두 없는 함수
    static void function() {
    	System.out.println("function의 내부 처리중");
    }
}

●  코드 예시 2: 매개변수가 있고, 리턴값이 없는 함수

public class MainClass {
    public static void main(String[] args) {
    	
        // 함수 호출부
        int n = 123;
        function(n); 
        	// 여기서의 n은 argument이다. 실제 넘겨주는 값이고, 이것은 parameter와는 다르다.
        
        System.out.println("main 함수 복귀: n -> " + n);
    }

    static void function(int n) { 
    	// 12줄에서 선언된 int n이 Parameter이다. 
        // 가인수이기 때문에 이름 중복을 신경 쓸 필요 없음.
        
        n = 234;
        System.out.println("function 함수 내부: n -> " + n);
    }
}

● 코드 예시 3: 매개변수와 리턴값이 모두 있는 함수

public class MainClass {
    public static void main(String[] args) {

        // 함수 호출 (1) -> 리턴된 값을 바로 출력 구문으로 받음
        System.out.println(toLowerChar('A'));

        // 함수 호출 (2) -> 리턴된 값을 변수에 저장하여 출력함
        char output = toLowerChar('B');
        System.out.println(output);
    }

    // 영어 대문자를 입력받으면, 소문자로 변환해주는 함수
    // 매개변수 1개, 리턴 값 1개 (char)
    static char toLowerChar(char c) {
        // ASCII 코드 값을 이용함
        // 대문자 'A' === 65, 소문자 'a' == 97
        int cValue = (int)c;
        cValue += 32;

        return (char)cValue;
    }
}

import java.util.Scanner;

public class HW1_calculator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("::::::::::사칙연산 계산기::::::::::");
        int a = 0, b = 0; // 입력값 2개
        char c;   // 연산자 1개

        String input; // 검사를 위한 임시 String 변수

        // 첫번째 수 검사
        out: while (true) {
            System.out.println("첫번째 숫자를 입력해주세요.");
            System.out.print(">>> ");
            input = sc.next();
            for (int i=0; i<input.length(); i++) {
                if (input.charAt(i) > 57 || input.charAt(i) < 48) {
                    System.out.println("유효하지 않은 숫자");
                    break;
                } else {
                    a = Integer.parseInt(input);
                    break out;
                }
            }
        }

        // 연산자 입력 후 검사
        while (true) {
            System.out.println("연산자를 입력해주세요 (+, -, *, /)");
            System.out.print(">>> ");
            input = sc.next();
            c = input.charAt(0);
            if (c == '+' || c == '-' || c == '*' || c == '/') {
                break;
            } else {
                System.out.print("올바른 연산자가 아닙니다.\n\n");
            }
        }

        // 두번째 수 검사
        out: while (true) {
            System.out.println("두번째 숫자를 입력해주세요.");
            System.out.print(">>> ");
            input = sc.next();
            for (int i=0; i<input.length(); i++) {
                if (input.charAt(i) > 57 || input.charAt(i) < 48) {
                    System.out.println("유효하지 않은 숫자");
                    break;
                } else {
                    b = Integer.parseInt(input);
                    break out;
                }
            }
        }

        // 계산 후 출력
        System.out.print("\n");
        System.out.print("계산 결과\n");
        if (c == '+') {
            System.out.printf("%d %c %d = %d", a, c, b, a+b);
        } else if (c == '-') {
            System.out.printf("%d %c %d = %d", a, c, b, a-b);
        } else if (c == '*') {
            System.out.printf("%d %c %d = %d", a, c, b, a*b);
        } else if (c == '/') {
            if ( b == 0) {
                System.out.println("0으로 나눌 수 없습니다!");
            } else {
                System.out.printf("%d %c %d = %.2f", a, c, b, (double) a / b);
            }
        } else {
            System.out.println("예상하지 못한 오류 발생");
        }
    }
}