프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

제한 사항

• 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

입출력 예

문제풀이

• speeds를 통해 progresses가 100이 되려면 얼마나 걸리는지 계산한다.
• progresses부터 큰 수가 먼저 나오고 그 다음에 작은 수가 나오게 된다면 갯수를 1씩 더해간다.
• progresses에서 지정한 하나의 수 보다 더 큰 수가 나오게 된다면 지금까지 더해온 숫자를 answer에 저장하고 새롭게 진행한다.

풀이 방법

• 갯수에 따라 반환 길이가 달라지므로 Array를 사용하지 않고 List로 answer값 지정
• result를 통해서 처음부터 끝까지 하나씩 비교를 하므로 queue를 사용
• for문을 돌면서 각 progresses가 100이 되려면 몇일이 필요한지 계산한다.
• 계산한 값을 queue에 offer
• 첫번째 값을 poll한다.
• 그 값이 다음 값보다 크면 cnt를 1씩더한다.
• 만약 그 값이 다음값보다 작으면 answer에 현재 cnt를 저장하고 비교 값을 바꿔버린다.
• 그 후 cnt는 다시 1로 지정
• 계속하면서 result(queue)가 empty가 되어버린다면 while문을 탈출한다.
• answer를 return한다.

풀이

import java.util.*;
class Solution {
    public List solution(int[] progresses, int[] speeds) {
        List<Integer> answer = new ArrayList<>();
        Queue<Integer> result = new LinkedList<>();
        for(int i = 0; i < progresses.length; i++){
            int rest = 100 - progresses[i];
            int date = rest / speeds[i];
            if(rest % speeds[i] != 0){
                date += 1;
            }
            result.offer(date);
        }
        int first = result.poll();
        int cnt = 1;
        while(!result.isEmpty()){
            int com = result.poll();
            if(first < com){
                answer.add(cnt);
                first = com;
                cnt = 1;
            }else{
                cnt++;
            }
        }
        answer.add(cnt);
        return answer;
    }
}

배운점

• 오늘 pccp를 풀었는데 lv2 같은 구현을 풀었는데 생각보다 오래걸려서 아직 실력이 부족하다는 생각을 많이 했다...
• 이와 같은 문제를 풀 때, 한번 생각을 정리하고 푸는 법을 조금 더 익숙해지도록 하자
• 구현 문제는 효율성도 중요하지만 어떤 방식으로 가볍게 풀 수 있는지 매우 중요한것 같다.

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/42586

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다. Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• scoville의 길이는 2 이상 1,000,000 이하입니다.
• K는 0 이상 1,000,000,000 이하입니다.
• scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
• 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

입출력 예

scoville [1, 2, 3, 9, 10, 12]

K 7

return 2

문제풀이

1. scoville을 계속해서 sort를 한다.
2. sort한 scville에서 가장 작은 수를 계속 그 다음수와 계산식을 사용한다.
3. 만약 모든 스코빌 지수가 7이상이면 answer값 return

풀이 방법

1. PriorityQueue를 사용한다.
2. 계속해서 sort되어서 그 맨앞에 수를 계속해서 사용하는 것이기 때문에 PriorityQueue 사용
3. for문을 통해 scoville의 내용을 sco에 추가
4. sco는 스스로 sort가 되기 때문에 맨 앞에 숫자를 출력하여 k보다 작을 때 첫번째와 두번째 수를 poll하여 offer를 통해서 새로운 값을 추가
5. answer값을 1추가한다.
6. 만약 sco.size()가 2보다 작다면 즉, 공식을 사용해도 k이상이 안되는 것이므로 -1을 return한다.

풀이

import java.util.*;
class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> sco = new PriorityQueue();

        for(int i =0; i< scoville.length; i++){
            sco.offer(scoville[i]);
        }

        while(sco.peek() < K) {
            if(sco.size() < 2) {
                  answer = -1;
                  break;
               }
               int a = sco.poll();
               int b = sco.poll();
               sco.offer(a + (b * 2));
               answer++;
        }
        return answer;
    }
}

배운점

1. 자동 sort를 생각하고 있을 때 무조건 tree를 생각하기보단 우선순위 큐도 있다는 것을 생각하자
2. lv2만한 문제를 푼것 같다
3. lv3하고 lv4까지 도전해서 내일은 풀어보자

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/42626

삼각형의 꼭대기에서 바닥까지 이어지는 경로 중, 거쳐간 숫자의 합이 가장 큰 경우를 찾아보려고 합니다. 아래 칸으로 이동할 때는 대각선 방향으로 한 칸 오른쪽 또는 왼쪽으로만 이동 가능합니다. 예를 들어 3에서는 그 아래칸의 8 또는 1로만 이동이 가능합니다.

삼각형의 정보가 담긴 배열 triangle이 매개변수로 주어질 때, 거쳐간 숫자의 최댓값을 return 하도록 solution 함수를 완성하세요.

제한 사항

• 삼각형의 높이는 1 이상 500 이하입니다.
• 삼각형을 이루고 있는 숫자는 0 이상 9,999 이하의 정수입니다.

입출력 예

triangle [[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]]

result 30

문제풀이

• 밑에서부터 둘 중 큰 수를 만들어 그 위에 숫자에 더한다.
• 이와 같은 방식을 계속 이어나가면서 맨 위 숫자를 출력

풀이 방법

• 맨 밑줄은 값이 그대로 가면서 3번째 줄부터 더하기로 올라가는 것이므로 i 값을 triangle.length-2부터 시작
• 그럼 3번째 줄의 양 쪽 숫자중 큰 숫자를 더하게 된다.
• 3번째 숫자의 숫자가 전부 바뀌고 똑같은 방식으로 위에 숫자를 더해가면서 for문을 수행한다.
• for문 수행이 끝나면 triangle[0][0]의 값을 출력한다면 가장 큰 값 실행

첫번째 풀이

import java.util.*;
class Solution {
    public int solution(int[][] triangle) {
        int answer = 0;
        for(int i = triangle.length-2; i >= 0; i--){
            for(int j = 0; j < triangle[i].length; j++){
                triangle[i][j] += Math.max(triangle[i+1][j], triangle[i+1][j+1]);
            }
        }
        answer = triangle[0][0];
        return answer;
    }
}

배운점

• 처음에는 위에서 전체 다 수행하여 가장 작은 값을 찾아내는 dfs를 사용하려고 함
• 프로그래머스 문제 유형이 dp유형이라서 점화식 방식을 생각했다
• 생각해보니 밑에서부터 풀면 된다고 알게되었다
• 역시... 문제는 바로 보이는대로 dfs로 풀어야지!보다는 어떤 방식으로 풀면 더 빠를까를 어느정도 시간을 두고 생각하고 푸는게 좋을 것 같다
• 근데 사실 이것도 3레벨이라고 봐야하나..? 싶다

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/43105

게임 캐릭터를 4가지 명령어를 통해 움직이려 합니다. 명령어는 다음과 같습니다.

• U: 위쪽으로 한 칸 가기

• D: 아래쪽으로 한 칸 가기

• R: 오른쪽으로 한 칸 가기

• L: 왼쪽으로 한 칸 가기

캐릭터는 좌표평면의 (0, 0) 위치에서 시작합니다. 좌표평면의 경계는 왼쪽 위(-5, 5), 왼쪽 아래(-5, -5), 오른쪽 위(5, 5), 오른쪽 아래(5, -5)로 이루어져 있습니다.

명령어가 매개변수 dirs로 주어질 때, 게임 캐릭터가 처음 걸어본 길의 길이를 구하여 return 하는 solution 함수를 완성해 주세요.

제한 사항

• dirs는 string형으로 주어지며, 'U', 'D', 'R', 'L' 이외에 문자는 주어지지 않습니다.
• dirs의 길이는 500 이하의 자연수입니다.

입출력 예

dirs answer "ULURRDLLU" 7 "LULLLLLLU" 7

문제풀이

• 문자에 따라 x,y축 값을 더하고 뺀다.
• 그 값이 -5이하거나 +5이상이면 신경쓰지 않는다.
• 이미 방문한 이동구간이면 신경쓰지 않는다.
• 총 이동거리를 계산한다.

풀이 방법

• 각각 이동하는 x,y축에 대해서 더하기 및 빼기를 하기 위한 x값 및 y값의 초기값을 0으로 설정
• 이전과 이후의 이동한 거리를 저장하기 위하여 beforeX및 beforeY를 설정
• 문자열에 따라 x,y값을 더하기 및 빼기한다.
• 값이 5이상이거나 5이하면 수행하지 않고 continue
• 각 값을 일정하게 String타입으로 전환한다.
• HashSet에 String을 집어넣어 중복된 경우 저장하지 않게 설정
• 총 HashSet의 값에 대한 Size를 answer로 설정한다.

첫번째 풀이

import java.util.*;
class Solution {
    public int solution(String dirs) {
        int answer = 0;
        int x = 0;
        int y = 0;
        int beforeX = 0;
        int beforeY = 0;
        Set<String> result = new HashSet<>();
        for(int i = 0; i < dirs.length(); i++){
            beforeX = x;
            beforeY = y;
            String position = "";
            if(dirs.charAt(i) == 'U' && x < 5){
                x++;
            }else if(dirs.charAt(i) == 'D' && x > -5){
                x--;
            }else if(dirs.charAt(i) == 'L' && y > -5){
                y--;
            }else if(dirs.charAt(i) == 'R' && y < 5){
                y++;
            }else{
                continue;
            }
            position += x;
            position += y;
            position += beforeX;
            position += beforeY;
            result.add(position);
        }
        answer = result.size();
        return answer;
    }
}

• 테스트 코드를 수행했을 때 반은 맞지만 반은 틀리는 것을 확인했다.
• 생각해보니 한 방향이 두번 일어나면 무시하지만
• 왕복 방향은 무시하지 못하고 저장되는 것을 확인했다.
• 왕복 방향을 신경쓰도록 했다.

두번째 풀이

import java.util.*;
class Solution {
    public int solution(String dirs) {
        int answer = 0;
        int x = 0;
        int y = 0;
        int beforeX = 0;
        int beforeY = 0;
        Set<String> result = new HashSet<>();
        for(int i = 0; i < dirs.length(); i++){
            beforeX = x;
            beforeY = y;
            String position = "";
            if(dirs.charAt(i) == 'U' && x < 5){
                x++;
                position += x;
                position += y;
                position += beforeX;
                position += beforeY;
            }else if(dirs.charAt(i) == 'D' && x > -5){
                x--;
                position += beforeX;
                position += beforeY;
                position += x;
                position += y;
            }else if(dirs.charAt(i) == 'L' && y > -5){
                y--;
                position += beforeX;
                position += beforeY;
                position += x;
                position += y;
            }else if(dirs.charAt(i) == 'R' && y < 5){
                y++;
                position += x;
                position += y;
                position += beforeX;
                position += beforeY;
            }else{
                continue;
            }
            result.add(position);
        }
        answer = result.size();
        return answer;
    }
}

• 왕복 방향도 신경쓰기 위해 position의 저장 방식을 일정하게 맞췄다.
• 그러니까 모두 정답이 나왔다.

배운점

• 회사 코딩테스트는 전체적인 테스트케이스를 확인할 수 없다.
• 그러므로 코드를 다 작성하고 조건에 따른 다양한 테스트케이스를 생각해보고 최종 제출을 하자
• lv2여도 생각보다 쉬웠다.

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/49994

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.

다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.

• 1478 → "one4seveneight"
• 234567 → "23four5six7"
• 10203 → "1zerotwozero3" 이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다. 숫자 영단어 0 zero 1 one 2 two 3 three 4 four 5 five 6 six 7 seven 8 eight 9 nine

제한 사항

• 1 ≤ s의 길이 ≤ 50
• s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다.
• return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만 s로 주어집니다.

입출력 예

s "one4seveneight" "23four5six7" "2three45sixseven" "123"

result 1478 234567 234567 123

문제풀이

1. 문자에 대해서 일치하는 num의 string값이 있는지 확인

2. 그 string값을 숫자로 변환

3. s를 int로 변환

풀이 방법

1. 각 숫자에 대한 String타입을 하나의 배열로 만든다.

2. 그 배열에 따라서 일치하는 s값안에 문자열이 있으면 replace를 통해서 숫자로 바꾼다.

3. 바꿀때는 string 타입으로 바꿔야하기 때문에 Integer.toString(i)로 설정

4. 총 바꾼 s를 Integer.parseInt(s)를 통해 숫자로 변환

풀이

class Solution {
    public int solution(String s) {
        String[] num = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};  

        for(int i=0; i<10; i++){
            s = s.replace(num[i], Integer.toString(i));
        }

        int answer = Integer.parseInt(s);

        return answer;
    }
}

배운점

• 생각보다 1레벨도 너무 쉽다고 자만할순없다...
• 각 자료 타입을 변환하는 함수에 대해서 정확하게 공부하자

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/81301

알파벳 소문자로만 이루어진 어떤 문자열에서, 2회 이상 나타난 알파벳이 2개 이상의 부분으로 나뉘어 있으면 외톨이 알파벳이라고 정의합니다.

문자열 "edeaaabbccd"를 예시로 들어보면,

• a는 2회 이상 나타나지만, 하나의 덩어리로 뭉쳐있으므로 외톨이 알파벳이 아닙니다.
  • "ede(aaa)bbccd"
• b, c도 a와 같은 이유로 외톨이 알파벳이 아닙니다.
• d는 2회 나타나면서, 2개의 부분으로 나뉘어 있으므로 외톨이 알파벳입니다.
• "e(d)eaaabbcc(d)"
  • e도 d와 같은 이유로 외톨이 알파벳입니다.

문자열 "eeddee"를 예시로 들어보면,

• e는 4회 나타나면서, 2개의 부분으로 나뉘어 있으므로 외톨이 알파벳입니다.
  • "(ee)dd(ee)"
• d는 2회 나타나지만, 하나의 덩어리로 뭉쳐있으므로 외톨이 알파벳이 아닙니다.
  • "ee(dd)ee"

문자열 input_string이 주어졌을 때, 외톨이 알파벳들을 알파벳순으로 이어 붙인 문자열을 return 하도록 solution 함수를 완성해주세요. 만약, 외톨이 알파벳이 없다면 문자열 "N"을 return 합니다.

제한 사항

• 1 ≤ input_string의 길이 ≤ 2,600

• input_string은 알파벳 소문자로만 구성되어 있습니다..

입출력 예

input_string "edeaaabbccd" "eeddee" "string" "zbzbz"

result "de" "e" "N" "bz"

문제풀이

1. input을 돌면서 이전값과 비교했을 때 똑같은 값이면 계속 나아간다.

2. 나아가다가 다른 값이 나오게 된다면 그 값을 또 측정한다.

3. 나왔던 알파벳을 따로 저장해두면서 다른 값이 나왔을 때 따로 저장된 곳에 들어가 있으면 result에 넣는다.

4. result를 정렬해서 string 타입으로 출력한다.

풀이 방법

1. 나왔던 알파벳들을 저장하기 위한 input을 list로 설정한다.

2. 띄워져서 나온 알파벳을 저장하기 위한 TreeSet을 설정한다.

3. 처음 값을 ' '로 설정한다.

4. for문을 돌며 input_String을 하나하나 탐색한다.

5. 탐색하며 전 값과 동일 하면 아무 작업도 안한다.

6. 전 값과 다르면 input에 add를 하는데 만약 이미 input에 있다면 result에 add한다.

7. result에 계속 add해도 set이므로 중복 값은 허용되지 않아서 하나의 값만 들어간다.

8. treeset이므로 따로 sort하지 않아도 정렬이 되어서 나온다.

9. 정렬된 값을 string으로 출력

첫번째 풀이

import java.util.*;
class Solution {
    public String solution(String input_string) {
        List<Character> input = new ArrayList<>();
        List<Character> result = new ArrayList<>();
        String answer = "";
        char a = ' ';
        for(int i = 0; i < input_string.length(); i++){
            if(input_string.charAt(i) != a){
                if(input.contains(input_string.charAt(i)) && !result.contains(input_string.charAt(i))){
                    result.add(input_string.charAt(i));
                }else{
                    input.add(input_string.charAt(i));
                }
            }
            a = input_string.charAt(i);
        }
        Collections.sort(result);
        for(int j = 0; j < result.size(); j++){
            answer += result.get(j);
        }
        if(answer == ""){
            answer = "N";
        }
        return answer;
    }
}

• 다음과 같은 코드로 풀었을 땐, input에 값이 들어있으면 result에 똑같은 값이 추가되어서 따로 if문안에 AND를 통해 두개의 조건을 넣어야 했다.
• 또한, 따로 result를 sort를 통해서 정렬을 했어야했다.
• 이러한 문제를 해결하기 위해서 굳이 저 두 문장을 안쓰고 중복된 값을 없애며 바로 정렬하는 함수를 사용할 수 없을까라고 생각을 했다.
• 그래서 TreeSet을 생각하기로 했다.
• TreeSet은 Set으로 중복도 막아주며 Tree를 통해 add하면서 정렬이 자동적으로 이루어진다.

두번째 풀이

import java.util.*;
class Solution {
    public String solution(String input_string) {
        List<Character> input = new ArrayList<>();
        Set<Character> result = new TreeSet<>();
        String answer = "";
        char a = ' ';
        for(int i = 0; i < input_string.length(); i++){
            if(input_string.charAt(i) != a){
                if(input.contains(input_string.charAt(i))){
                    result.add(input_string.charAt(i));
                }else{
                    input.add(input_string.charAt(i));
                }
            }
            a = input_string.charAt(i);
        }
        for(Character b : result){
            answer += b;
        }
        if(answer == ""){
            answer = "N";
        }
        return answer;
    }
}

배운점

• 사실 아직 효율성을 따지는데 어려움이 발생하는 것 같기도하다.
• Java의 List의 contains 메서드는 주어진 요소가 리스트에 포함되어 있는지 확인하기 위해서는 리스트를 순회해야 하므로 시간 복잡도가 O(n)이다.
• 따라서 리스트가 큰 경우에는 성능 문제가 발생할 수 있다.
• 최대한 효율성도 따지면서 코딩을 풀어나가보자...

문제풀이 주소https://school.programmers.co.kr/learn/courses/15008/lessons/121683

고속도로를 이동하는 모든 차량이 고속도로를 이용하면서 단속용 카메라를 한 번은 만나도록 카메라를 설치하려고 합니다.

고속도로를 이동하는 차량의 경로 routes가 매개변수로 주어질 때, 모든 차량이 한 번은 단속용 카메라를 만나도록 하려면 최소 몇 대의 카메라를 설치해야 하는지를 return 하도록 solution 함수를 완성하세요.

제한 사항

• 차량의 대수는 1대 이상 10,000대 이하입니다.

• routes에는 차량의 이동 경로가 포함되어 있으며 routes[i][0]에는 i번째 차량이 고속도로에 진입한 지점, routes[i][1]에는 i번째 차량이 고속도로에서 나간 지점이 적혀 있습니다.

• 차량의 진입/진출 지점에 카메라가 설치되어 있어도 카메라를 만난것으로 간주합니다.

• 차량의 진입 지점, 진출 지점은 -30,000 이상 30,000 이하입니다.

입출력 예

routes [[-20,-15], [-14,-5], [-18,-13], [-5,-3]]
return 2

문제풀이

1. routes를 기준을 잡아 정렬한 후 정렬된 array를 통해 프로그래머스의 greedy문제였기에 greedy를 사용하게 되었다.

2. routes[i][0]를 기준으로 정렬하였다.

3. 맨 앞 기준으로 카메라를 설치하거나 맨 뒤에 설치를 하여도 최소의 카메라 설치가 나오지 않았다.

4. routes[i][1]를 기준으로 정렬하였다.

5. 맨 앞 기준으로 카메라를 설치하였을 땐, 필요없는 카메라까지 설치되었으나 맨뒤를 기준으로 카메라를 설치하였을 때, 최소 기준의 카메라가 설치되었다.

풀이 방법

1. 맨 처음 차량은 무조건 카메라에 찍혀야하니 현재 기준 값을 문제에서 제시하는 최솟값 -30000으로 지정

2. 받아온 array를 routes[i][1]기준으로 Arrays.sort(routes)적용

3. 현재 기준 값이 routes[i][0]값보다 작다면 차량간의 진입진출이 서로 엮이지 않는 상황이게 된다.

4. 그래서 현재 기준 값을 routes[i][1]값으로 바꾸고 answer에 1을 더한다.

5. 그게 아니라면 continue

import java.util.*;
class Solution {
    public int solution(int[][] routes) {
        int answer = 0;
        int nowValue = -30000;
        Arrays.sort(routes, (a,b) -> Integer.compare(a[1], b[1]));
        for(int i = 0; i < routes.length; i++){
            if(routes[i][0] > nowValue){
                nowValue = routes[i][1];
                answer++;
            }
        }
        return answer;
    }
}

배운점

• 처음 이 문제를 접할 때 무조건 정렬을 routes[i][0]으로만 실행한 후 코드를 작성하다보니 계속해서 풀리지 않았다.
• 역시 어려울 땐, 그림을 그려봐야한다...
• 근데 막상 이해하고 코드로 작성해보니 이게 lv3는 아닌 최대 lv2가 아닌가 하는....
• 풀이 방식을 생각하는데 어려움이 있어 lv3라면 살짝 인정해보도록 하려고한다.

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/42884

정수 n, left, right가 주어집니다. 다음 과정을 거쳐서 1차원 배열을 만들고자 합니다.

1. n행 n열 크기의 비어있는 2차원 배열을 만듭니다.
2. i = 1, 2, 3, ..., n에 대해서, 다음 과정을 반복합니다.
3. 1행 1열부터 i행 i열까지의 영역 내의 모든 빈 칸을 숫자 i로 채웁니다.
4. 1행, 2행, ..., n행을 잘라내어 모두 이어붙인 새로운 1차원 배열을 만듭니다. 새로운 1차원 배열을 arr이라 할 때, arr[left], arr[left+1], ..., arr[right]만 남기고 나머지는 지웁니다.

정수 n, left, right가 매개변수로 주어집니다. 주어진 과정대로 만들어진 1차원 배열을 return 하도록 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ n ≤ 107
• 0 ≤ left ≤ right < n2
• right - left < 105

입출력 예

n left right result 3 2 5 [3,2,2,3] 4 7 14 [4,3,3,3,4,4,4,4]

문제풀이

1. 처음에는 전체적으로 만들어진 2차원 배열 모습의 결과를 1차원 배열로 나열하여 그 사이에 left ~ right까지의 값을 출력해야한다고 생각했다.

2. 그 결과 시간 복잡도가 길어질뿐더러 전체적으로 다 구해야하는 코드의 불필요성이 존재하게 되었다.

3. 배열의 모습을 보니 직접 전체를 구하지 않아도 2차원 배열의 열과 행의 값을 통해서 +1만하여도 같은 값이 나오는걸 확인하였다.

풀이 방법

1. left, right가 Long 타입으로 주어지기 때문에 ArrayList의 Long 타입으로 반환 타입을 변경했다. (일반 int 형식의 Array타입은 길이를 구할 때 right-left+1을 하였으나 long타입이라서 error발생)

2. 행은 left~right의 현재 값 i를 n값으로 나눈 몫으로 지정

3. 열은 left~right의 현재 값 i를 n값으로 나눈 나머지로 지정

4. 행과 열의 Math.max값을 통해 최대값을 구하고 +1을 수행

5. answer.add(result)값을 통해 ArrayList에 값 저장

6. return

import java.util.*;
class Solution {
    public List<Long> solution(int n, long left, long right) {
        List<Long> answer = new ArrayList<>();
        for(long i = left; i <= right; i++){
            long a = i % n;
            long b = i / n;
            long result = Math.max(a,b) + 1;
            answer.add(result);
        }
        return answer;
    }
}

배운점

• 초반에 전체적인 모습을 보고 푸는 방식을 구현해보자
• 단순히 문제를 읽고 방식을 생각해내지 말고 문제의 모습과 전체적인 결과값의 일정한 규칙을 찾아내자
• 사실 이게 2레벨인가...? 싶기도하다

문제풀이 주소

https://school.programmers.co.kr/learn/courses/30/lessons/87390

C나 C++을 공부하는 사람들을 친구로써 두다보면 많이 어려워하고 포기하는 부분인 포인터라는 개념을 확인할 수 있다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size;
    printf("Enter the size of the array: ");
    scanf("%d", &size);

    // 동적으로 정수 배열 할당
    int* arr = (int*)malloc(size * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // 배열에 값 입력 받기
    printf("Enter the elements of the array:\n");
    for (int i = 0; i < size; i++) {
        scanf("%d", &arr[i]);
    }

    // 배열 요소 출력
    printf("Array elements: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 동적 할당 해제
    free(arr);

    return 0;
}

위의 코드에서 int* arr은 int형 포인터로서 동적으로 할당된 정수 배열을 가리킵니다. malloc() 함수를 사용하여 메모리를 동적으로 할당하고, free() 함수를 사용하여 할당된 메모리를 해제합니다.

#include <iostream>

class MyClass {
private:
    int data;

public:
    MyClass(int value) : data(value) {}

    void printData() {
        std::cout << "Data: " << data << std::endl;
    }
};

int main() {
    // 동적으로 MyClass 객체 생성
    MyClass* myObj = new MyClass(42);

    // 포인터를 사용하여 객체 멤버에 접근
    myObj->printData();

    // 동적 할당 해제
    delete myObj;

    return 0;
}

위의 코드에서 MyClass* myObj는 MyClass 타입의 포인터로서 동적으로 생성된 객체를 가리킨다. 그 후 new 키워드를 사용하여 객체를 동적으로 생성하고, -> 연산자를 사용하여 포인터를 통해 객체의 멤버에 접근한다.

여기서 포인터는 변수의 메모리 주소를 가리키는 변수라고 할 수 있다.

즉, 변수의 데이터 내용이 아닌 위치를 가리키는 것이다.

그렇기 때문에 포인터를 사용하게 된다면 변수의 주소를 직접 조작하고, 그 주소에 접근하여 데이터를 읽거나 변경할 수 있게 된다.

포인터와 참조의 차이에 대해서 간단하게 알아볼 수 있는데 포인터와 참조는 둘다 주소를 통해서 원본 데이터에 접근을 하는 공통적인 특성을 가지고 있다.

차이점은 위에서 말햇듯이 포인터는 직접적인 주소를 접근이 가능하기 때문에 메모리를 직접적으로 컨트롤할 수 있게 된다.

하지만 참조는 직접적으로 메모리에 접근을 할 수 없기 때문에 메모리를 직접 컨트롤할 수 없다.

중요한 점은 참조는 메모리에 직접적으로는 접근이 불가능하지만 내부적으로는 이미 접근하고 있다는 것을 알길 바란다.

여기서 포인터는 직접적인 주소를 접근하기 때문에 주소 값이 잘못 변경되면 오류가 발생하게 된다.

여기서 JAVA는 포인터의 유연성과 성능보단 안정성을 고려하면서 포인터라는 개념을 개발자에게는 직접 제공하지 않는 것이다.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the size of the array: ");
        int size = scanner.nextInt();

        // 동적으로 정수 배열 할당
        int[] arr = new int[size];

        // 배열에 값 입력 받기
        System.out.println("Enter the elements of the array:");
        for (int i = 0; i < size; i++) {
            arr[i] = scanner.nextInt();
        }

        // 배열 요소 출력
        System.out.print("Array elements: ");
        for (int i = 0; i < size; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

class MyClass {
    private int data;

    public MyClass(int value) {
        this.data = value;
    }

    public void printData() {
        System.out.println("Data: " + data);
    }
}

public class Main {
    public static void main(String[] args) {
        // 동적으로 MyClass 객체 생성
        MyClass myObj = new MyClass(42);

        // 객체 멤버에 접근
        myObj.printData();
    }
}

JAVA Garbage Collector

여기서 Java가 직접적으로 주소를 접근할 필요가 없는 이유는 JVM에는 직접 메모리를 관리해주는 Garbage Collector(GC)가 존재하게 된다.

Garbage Collector는 Java 프로그램이 실행될 때 필요하지 않은 메모리를 감지하고 해제하여 프로그래머가 직접 메모리 관리를 하지 않게 해준다.

이때 5를 담고 있던 heap 영역은 Unreachable Object가 되는데 이를 제거해 메모리를 관리하는게 가비지 컬렉터가 되는 것이다.

Garbage Collector의 제거 과정

이 과정에서 가비지 컬렉터는 Mark라는 과정을 시행하게 되는데 스택에 할당된 모든 변수들의 연결된 주소값인 Reachable Object를 탐색하며 어떤 힙 영역이랑 연결되는지 Mark하게 된다.

이와 같은 진행을 한 후 Sweep을 통해 Mark가 되지 않은 객체들을 제거하게 된다.

제거하는 과정은 다음과 같다.

1. Eden에서는 매번 new 생성자를 통해 새롭게 생기는 객체가 생기게 된다.

2. Eden이 꽉차게 된다면 Minor GC가 일어나게 된다.

3. 그러면 Eden에 Unreachable Object만 남기고 survivor1에 넘기게 된다. (이 과정에서 age라는 값을 1더하게 된다.)

4. 그 후 survivor1이 꽉차면 survivor2에 넘기게 된다. (이 과정에서 age라는 값을 1더하게 된다.)

5. survivor1과 survivor2를 왔다갔다하면서 꽉차면 Minor GC가 일어나 Unreachabel Object만 남기고 서로 넘기게 되는 것이다. (이 과정에서 넘어갈 때마다 age라는 값을 1더하게 된다.)

6. 객체의 age가 일정 값 이상이 된다면 Old로 주로 사용되는 것이라는 생각을 하게 되어 Old로 이동하게 된다.

7. Old에서도 꽉차게 된다면 Major GC가 일어나게 되며 Mark,Sweep이 이뤄지게 된다.

이와 같은 방식으로 java에서는 메모리 관리를 직접 해주기 때문에 포인터와 같은 방식을 사용하지 않고도 메모리에 직접 접근하지 않아도 효율적으로 메모리 관리를 할 수 있는 것이다.

이와 같이 java는 직접 메모리를 처리함으로써 개발자가 메모리에 직접적인 접근을 하는 것을 막아 코드의 안정성을 매우 높게 올렸다고 볼 수 있다.

Garbage Collector의 단점

하지만 직접적인 메모리 관리를 하지 않기 때문에

1. 성능 영향: GC 작업은 프로그램 실행 중에 발생하며, GC 실행 시간에 따라 프로그램의 일시 중단이 발생할 수 있습니다. 이로 인해 애플리케이션의 응답성이 저하될 수 있습니다.

2. 예측 어려움: GC의 작동 방식과 타이밍은 JVM에 의해 제어되므로 개발자는 명확한 제어를 할 수 없습니다. 따라서 GC가 언제 실행될지 예측하기 어려울 수 있습니다. 이는 실시간 시스템이나 지연 시간이 중요한 애플리케이션에서 문제가 될 수 있습니다.

3. 자원 사용: GC는 CPU 및 메모리 자원을 사용합니다. GC 작업 중에는 메인 애플리케이션 스레드와 동일한 자원을 공유하므로, GC 작업이 많아지면 애플리케이션의 성능에 영향을 줄 수 있습니다.

4. 메모리 누수 가능성: GC가 자동으로 메모리를 관리하므로 메모리 누수가 발생할 수 있습니다. 예를 들어, 객체에 대한 참조가 제대로 해제되지 않으면 해당 객체는 GC의 수거 대상이 되지 않고 계속해서 메모리를 점유하게 될 수 있습니다.

5. 객체 소멸의 타이밍 제어 어려움: GC는 객체가 더 이상 사용되지 않는지 판단하고 소멸시킵니다. 따라서 객체의 소멸 시점을 개발자가 직접 제어하기 어렵습니다. 이는 파일 핸들이나 네트워크 연결과 같이 명시적인 리소스 해제가 필요한 경우에 문제가 될 수 있습니다.

6. 세밀한 메모리 관리 제한: GC를 사용하면 개발자가 메모리 할당 및 해제를 세밀하게 제어할 수 없습니다. 따라서 특정 애플리케이션에서 메모리 사용에 대한 최적화를 수행해야 하는 경우, GC를 사용하는 것보다는 명시적인 메모리 관리가 필요할 수 있습니다.

다음과 같은 단점은 생길 수 있게 된다.

참조 : https://sorjfkrh5078.tistory.com/77?category=1007499 https://sorjfkrh5078.tistory.com/278

- 클래스와 관련된 추상적인 개념
- 클래스가 가져야 하는 메소드의 시그니처를 정의하는 역할
- 메소드들의 집합으로 구성
- 클래스는 인터페이스의 모든 메소드를 구현해야 한다.
- 클래스와 달리 멤버 변수를 가질 수 ㅇ벗다.
- 기본적으로 모든 메소드는 추상 메소드로 선언된다.
- 즉, 구체적인 구현을 갖지 않고, 메소드의 시그니처만 정의

다형성(Polymorphism)

- 인터페이스는 클래스들 간의 다형성을 구현하기 위한 중요한 개념이다.
- 클래스가 특정 인터페이스를 구현할 때, 해당 클래스는 인터페이스의 모든 메소드를 구현
- 다양한 클래스가 동일한 인터페이스를 구현함으로써, 동일한 인터페이스를 사용하는 코드는 각각 다른 클래스의 인스턴스를 대체하여 사용

예제 코드

public interface MyInterface {
    // 추상 메서드 선언
    void method1();
    int method2(String str);

    // 상수 선언
    int CONSTANT = 100;

    // 디폴트 메서드
    default void defaultMethod() {
        // 구현 내용
    }

    // 정적 메서드
    static void staticMethod() {
        // 구현 내용
    }
}

- MyInterface라는 인터페이스를 정의
- method1, method2는 추상메소드로 선언
- 클래스는 이를 구현해야 한다.
- CONSTANT라는 상수를 정의할 수 있고, 인터페이스 내부에서는 디폴드 메소드와 정적 메소드 구현까지 가능하다.

implements

- 인터페이스를 구현하는 클래스는 'implement' 키워드를 사용하여 인터페이스 구현이 가능하다.
- 클래스는 인터페이스의 모든 메서드를 구현해야한다.
- 이를 통해, 클래스는 인터페이스가 요구하는 동작을 제공

예제 코드

public interface Interface1 {
    void method1();
}

public interface Interface2 {
    void method2();
}

public class MyClass implements Interface1, Interface2 {
    public void method1() {
        // Interface1의 메서드 구현
    }

    public void method2() {
        // Interface2의 메서드 구현
    }
}

- 다중 상속이 가능한 인터페이스를 사용.
- MyClass 객체는 Interface1, Interface2 메소드 모두 사용가능하다.
- 코드의 재사용성과 유연성을 높인다.

- Application Programming Interface의 약자이다.
- Java 프로그래밍에 사용되는 클래스, 인터페이스, 패키지 등의 모음이다.
- Java를 통해 소프트웨어를 개발할 때 필요한 기능과 도구를 제공

JDK

- Java Development Kit
- Java 개발에 필요한 도구와 라이브러리를 제공하는 패키지이다.
- JDK를 설치하면 자동으로 Java API도 설치

Java API

- 다양한 패키지로 구성
- 각 패키지는 특정한 기능과 작업 영역을 담당
- 필요한 기능에 따른 패키지를 import하여 사용한다.
- 클래스와 인터페이스의 집합으로 구성
- 이러한 클래스와 인터페이스는 재사용이 가능하다.

기능

- 파일 및 디렉터리 작업, 네트워크 통신, 데이터베이스 연결, GUI 개발 등
- 다른 프로그래밍 언어와 통합할 수 있는 인터페이스도 제공

예제 코드

import java.util.ArrayList;
import java.util.Random;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        Random random = new Random();

        // 1부터 10까지의 임의의 정수 5개를 생성하여 리스트에 추가
        for (int i = 0; i < 5; i++) {
            int randomNumber = random.nextInt(10) + 1;
            numbers.add(randomNumber);
        }

        // 리스트의 모든 요소 출력
        System.out.println("Numbers: " + numbers);

        // 리스트의 모든 요소의 합 계산
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }

        // 합 출력
        System.out.println("Sum: " + sum);
    }
}

- java.util.ArrayList 클래스를 사용하여 정수형 요소를 저장하는 ArrayList 객체 생성
- java.util.Random 클래스를 사용하여 1부터 10까지의 임의의 정수를 생성하기 위한 Random 객체 생성

- 클래스 간에 부모-자식 관계를 형성하여 코드의 재사용성과 계층 구조를 구축
- 자식 클래스는 부모 클래스의 속성과 메소드를 상속받아 사용
- 자식 클래스만의 속성과 메소드도 따로 정의 가능
- 즉 부모클래스를 확장하여 새 클래스를 만든다는 의미이다.
- 코드의 중복을 피하고, 계층적인 구조를 표현하며 유지 보수성을 향상시킨다.

예제 코드

// 부모 클래스 (슈퍼 클래스)
class Animal {
    protected String name; // 동물의 이름

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "이(가) 먹이를 먹습니다.");
    }
}

// 자식 클래스 (서브 클래스)
class Cat extends Animal {
    private String color; // 고양이의 색상

    public Cat(String name, String color) {
        super(name); // 부모 클래스의 생성자 호출
        this.color = color;
    }

    public void meow() {
        System.out.println(color + " 고양이 " + name + "이(가) 야옹 소리를 내면서 움직입니다.");
    }
}

// 자식 클래스 (서브 클래스)
class Dog extends Animal {
    private String breed; // 개의 품종

    public Dog(String name, String breed) {
        super(name); // 부모 클래스의 생성자 호출
        this.breed = breed;
    }

    public void bark() {
        System.out.println(breed + " 종의 개 " + name + "이(가) 짖으면서 움직입니다.");
    }
}

// 메인 클래스
public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat("나비", "흰색");
        cat.eat(); // 부모 클래스의 메서드 호출
        cat.meow(); // 자식 클래스의 메서드 호출

        Dog dog = new Dog("맥스", "래브라도");
        dog.eat(); // 부모 클래스의 메서드 호출
        dog.bark(); // 자식 클래스의 메서드 호출
    }
}

- Animal 클래스가 부모 클래스
- Cat, Dog 클래스는 Animal 클래스를 상속받은 자식 클래스
- 자식 클래스는 부모 클래스의 속성 name과 메소드 eat()을 상속받아 사용 가능하다.
- 자식 클래스는 자신들만의 속성과 메소드인 meow()와 bark()가 존재

- 접근 제한자를 사용하여 클래스, 메서드, 변수 등의 접근 범위를 제어할 수 있다.
- 접근 제한자는 클래스의 캡슐화를 촉진하고 데이터를 안전하게 보호한다.

public

- 가장 넓은 범위의 접근 제한자이다.
- 'public'으로 선언된 클래스, 메서드, 변수 등은 모든 패키지에서 접근 가능하다.
- 다른 패키지에서 해당 클래스에 접근하여 인스턴스를 생성하거나 해당 메서드 및 변수 사용이 가능하다.

    public class People {
    public String name; // public으로 선언된 변수

    public void myName() { // public으로 선언된 메서드
        System.out.println(name);
        }
    }

- 위의 class(클래스), name(변수명), myName()(메서드)는 모두 다른 클래스에서 접근이 가능하다.

protected

- 같은 패키지와 하위 클래스에서만 접근이 가능한 접근 제한자
- 해당 클래스와 같은 패키지에서는 자유롭게 접근 가능
- 다른 패키지에서는 해당 클래스의 하위 클래스에서만 접근이 가능하다.

    public class People {
    protected String name; // protected로 선언된 변수

    protected void myName() { // protected로 선언된 메서드
        System.out.println(name);
        }
    }

    public class Student extends Person {
        public void introduce() {
               System.out.println("이름: " + this.name);
            this.sayHello();
        }
    }

- people 클래스의 name 변수와 myName() 메서드는 protected로 선언되었다.
- Student 클래스는 extends를 통하여 Person 클래스를 상속 받아 인스턴스에서 Person클래스의 protected 멤버에 접근이 가능하다.

default

- 접근 제한자를 아무것도 명시하지 않는다면 default 접근 제한자를 가지게 된다.
- default 접근 제한자는 같은 패키지에서만 접근 가능하다.

게터와 세터

- Private로 선언된 필드는 해당 클래스 내부에서만 접근이 가능하다.
- 외부에서 접근하려면 게터와 세터 메소드를 사용한다.
- 메소드를 통해 간접적으로 접근하게 하는 것 = 캡슐화
- 클래스의 내부 구조를 외부로부터 감추며, 오직 메소드를 통해 접근 가능하게 한다.

게터(Getter)

- Private로 선언된 필드의 값을 반환하는 메소드
- 외부에서 해당 필드의 값을 가져와야 할 때 게터를 호출하여 값을 반환

세터(Setter)

- Private로 선언된 필드의 값을 설정하는 메소드
- 외부에서 해당 필드의 값을 변경해야 하는 경우, 세터를 호출하여 값을 설정
- 값의 유효성 검증을 한다.(잘못된 값이 필드에 들어가는 것을 방지)

    public class Person {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            if(age < 0) {
                throw new IllegalArgumentException("나이는 0보다 작을 수 없습니다.");
            }
            this.age = age;
        }
    }

- name과 age는 private으로 선언
- getName()과 getAge()메소드를 통해 값을 반환
- setName()과 setAge()메소드를 통해 값을 설정

- 객체를 가리키는 변수
- 객체가 메모리 상에 생성되면, 그 객체의 주소값을 가지고 있는 변수
- 레퍼런스는 객체의 복사본이 아니라 객체의 주소값을 가지고 있기 때문에, 같은 객체를 가리키는 레퍼런스끼리는 같은 주소값을 가지고 있다.

예제코드

MyObject obj1 = new MyObject();
MyObject obj2 = obj1;
- obj1과 obj2는 모두 MyObject 클래스의 객체를 가리키는 레퍼런스이다.
- obj2에 obj1을 대입함으로써, obj2도 obj1이 가리키는 같은 객체를 가리키게 된다.
- 레퍼런스는 null 값을 가질 수도 있습니다. null은 객체가 아니라, 아무것도 가리키지 않는 상태이다.

Static

- 클래스 레벨의 키워드로, 클래스에 속한 필드나 메서드에 적용된다.
- static으로 선언된 필드나 메서드는 클래스에 종속된다.
- 인스턴스와는 별개로 존재한다.
- 객체를 생성하지 않아도 클래스에서 직접 접근할 수 있다.

예제코드

public class MyClass {
private static int count = 0;
public MyClass() {
    count++;
}
public static int getCount() {
    return count;
}
}
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
System.out.println(MyClass.getCount());

- MyClass 클래스에는 count라는 static 필드와 getCount()라는 static 메서드가 선언한다.
- static 필드와 메서드는 객체 생성 없이도 MyClass.getCount()와 같이 클래스에서 직접 접근할 수 있다.
- MyClass 객체를 2개 생성하고, getCount()를 호출하여 생성된 객체의 개수를 출력하는 코드이다.
-  count 필드는 static으로 선언되어 있으므로, 객체를 생성할 때마다 count 값을 증가시키고, getCount()를 호출하면 현재까지 생성된 객체의 수를 반환한다.

클래스 변수와 인스턴스 변수

클래스 변수

- 해당 클래스의 모든 인스턴스가 공유하는 변수
- static 키워드를 사용하여 선언
- 클래스 이름으로 직접 접근할 수 있다.
- 객체를 생성하지 않아도 사용할 수 있으며, 해당 클래스의 모든 객체가 값을 공유하므로, 하나의 클래스 변수 값 변경은 모든 객체에 영향을 미친다.

public class MyClass {
static int classVariable = 10;
}

인스턴스 변수

- 객체가 가지는 변수로, 객체의 속성을 나타낸다.
- 인스턴스 변수는 객체를 생성할 때마다 새로 생성되며, 객체마다 값이 달라진다.
- 인스턴스 변수는 클래스 내부에 선언되며, 객체 생성 후 접근할 수 있다.

public class MyClass {
int instanceVariable = 5;
}

클래스 메소드와 인스턴스 메소드

클래스 메소드

- 해당 클래스와 관련된 작업을 수행하는 메소드
- static 키워드를 사용하여 선언
- 클래스 메소드는 객체를 생성하지 않고도 클래스 이름으로 직접 호출할 수 있다.
- 클래스 메소드는 클래스 변수와 마찬가지로, 클래스의 모든 객체가 공유하는 메소드

   public class MyClass {
        static void classMethod() {
        // 클래스 메소드 구현
    }
}

인스턴스 메소드

- 해당 객체와 관련된 작업을 수행하는 메소드
- 인스턴스 메소드는 객체를 생성한 후, 생성된 객체를 통해 접근
- 인스턴스 메소드는 인스턴스 변수와 함께 사용되는 경우가 많다.

public class MyClass {
    void instanceMethod() {
        // 인스턴스 메소드 구현
    }
}

요약

- 클래스 변수와 클래스 메소드는 클래스에 고정된 속성과 동작을 정의
- 인스턴스 변수와 인스턴스 메소드는 객체에 대한 속성과 동작을 정의
- 클래스 변수와 메소드는 객체를 생성하지 않고도 호출 가능
- 인스턴스 변수와 메소드는 객체 생성 후에만 호출 가능

- FiltInputStream 함수를 사용한다.
- 파일을 읽고 쓰는 역할을 한다.

import java.io.FileInputStream
- FileInputStream을 쓰기 위한 import를 시행
- FileInputStream inputStream을 통하여 txt파일을 읽어들인다.
FileInputStream inputStream = new FileInputStream("파일명");

FileInputStream 경고메세지

- Java에서는 해당 파일이 그 위치에 없을 수 있으므로 경고 메세지가 나오게 된다.
- 파일에 대한 예외처리를 하기 위해서 try-catch문을 사용한다.

try{
    inputStream = new FileInputStream("파일명");
} catch(FileNotFoundException e) {
    System.out.println("error");
    System.exit(3);
}

- System.exit(3)를 사용하면 만약 try-catch에 대해 3번째가 종료되었을 때 파일을 찾지 못한 것을 인지 

Scanner

import java.util.Scaaner;
- import를 통하여 Scanner 사용

Scanner scanner = new Scanner(inputStream);
String line = scanner.nextLine();
System.out.println(line);
- Scanner를 생성하며 앞에서 생성한 InputStream을 입력
- scanner를 통하여 파일의 내용을 한줄씩 읽어온다.
- while문을 통하여 원하는 줄까지 출력 가능
while(scanner.hasNextLine()) {
}
- hasNextLine = 다음 줄이 존재한다면 true를 반환한다.

txt 파일 저장

FileWriter writer = new FileWriter("파일명");
writer.write("넣고싶은 내용");
writer.close();
- FileWriter를 통하여 원하는 내용을 추가한다.
- 파일을 열어 글을 작성하였으므로 close를 통하여 파일을 닫는다.
- 한 줄을 추가하고 다음 줄을 추가할 때 \n을 통하여 줄바꿈을 한다.

Scanner scanner = new Scanner(System.in);
- System.in을 통하여 원하는 문자열을 입력할 수 있다.

- 객체를 생성할 때 호출되는 특별한 종류의 메소드
- 객체가 생성될 때, 객체의 초기화를 담당
    ClassName objectName = new ClassName();
- 생성자는 클래스 이름과 동일한 이름을 가지며, 리턴 타입이 없다.
- 생성자는 오버로딩이 가능하여 여라 개의 생성자 정의 가능

생성자의 역할

1. 객체 생성 : 생성자에서 필드 값을 설정하고, 객체의 상태를 변경하는 메소드를 호출하여 객체 초기화도 가능
2. 객체 초기화 : 객체를 생성할 때, 객체의 초기화를 담당

생성자 호출

1. 명시적 호출 : 객체 생성 후, 객체 이름을 통해 생성자를 호출한다.
    ClassName objectName = new ClassName();
    objectName.ConstructorName();
2. 암시적 호출 : 객체 생성시에 생성자가 자동으로 호출
    ClassName objectName = new ClassName(argument);

- 프로그램을 객체의 조립을 만드는 방식
- 프로그램을 여러 개의 객체로 나누어 관리하고 구성한다.
- 객체는 데이터와 해당 데이터를 처리하는 메소드로 구성

장점

1. 모듈화와 재사용성 : 객체는 독립적으로 개발하고, 다른 객체와 결합이 가능하다. 즉, 재사용성을 높여 유지보수를 용이하게 만들어준다.
2. 캡슐화 : 객체의 내부의 상태를 외부에서 접근할 수 없도록 보호하는 캡슐화. 코드의 신뢰성과 안정성을 높여준다.
3. 다형성 : 객체는 다양한 형태로 동작.
4. 상속 : 부모 클래스에서 자식 클래스로 코드를 상속. 중복성 제거 및 재사용성을 높인다.

클래스(Class)와 객체(object)

- Class : 객체를 생성하기 위한 일종의 틀(template)
    - 객체가 가져야 할 속성과 행위를 정의한다.
- Object : 클래스를 기반으로 생성된 인스턴스(instance)
    - 클래스에서 정의한 속성과 메소드를 가질 수 있다.

클래스 설계 및 구현

- 객체 지향 프로그램의 유지보수성과 확장성을 높일 수 있다.
- 필드(상태)와 메소드(동작)으로 구성된다.
- 클래스 설계는 요구사항 분석 -> 클래스 분해 -> 클래스 관계 정의 -> 클래스 구현 단계이다.
- 클래스를 구현 할 때 주의 할 점
    응집도, 결합도, 캡슐화, 상속성, 다형성

-특정 횟수를 반복하거나 특정 조건을 만족할 때까지 반복할 때 사용

for문

for(초기값; 종료조건; 증가){
    실행코드
}

중첩 for문

- for 안에 for문이 또 들어가는 형식이다.
- 밖의 for문의 초기값~종료조건에 따라 내부 for문의 횟수가 계속해서 진행된다.

while문

while(조건) {
    실행코드
}
- 조건은 boolean값으로 표현된다.
- 값이 true면 실행하며 false면 멈춘다.
- 즉, 무한루프이며 지정된 값에 따른 멈춤이 없다면 계속해서 실행한다.

do-while문

do{
    실행코드
} while(조건);
- do로 시작하고 그 뒤에 중괄호가 있다.
- 코드 마지막에 세미콜론이 붙는 것을 유의해야한다.
- while문과는 다르게 무조건 실행코드를 한번은 실행한다.
- 그 후 참인지 비교
- 참인경우 반복 시행

break

- 반복문을 시행하다보면 강제 중단을 필요로 할 순간이 있다.
- 그 조건에 맞게 된다면 break를 통하여 무한루프를 중단한다.
- for문, switch문, while문, do-while문에 전부 사용 가능하다.

continue

- 코드를 더 이상 진행하지 않고 반복문의 처음으로 되돌아가 다음 반복을 시행한다.

for-each

for(type element : array){
    실행할 코드
}

배열(Array)

배열의 선언

arraytype[] array = {값...}
- 변수를 하나하나 선언하는 귀찮음을 해소하기 위하여 사용
- 자료형이 같은 데이터를 모아놓은 구조
- 배열에는 각각 번호 즉, 인덱스(index)가 부여된다.
- 배열의 첫번째는 0으로 시작하는 것에 주의한다.
- array.length는 배열의 길이를 반환해준다.
- array.length를 사용하여 for문에 횟수 지정 가능
- array[0] = "다른 값"을 통하여 값을 대입할 수 있다.
- 배열을 통째로 출력하기 위해서는 Arrays.toString(array)를 사용한다.

2차원 배열

arraytype[][] array = {{값...}, {값...}};

if문

if(boolean 형태의 조건문) {
    실행코드
}

else문

- 조건문이 참일 때와 그렇지 않을 때 두 조건으로 나눠 처리 할 수 있는 방법
- if문을 먼저 선언한 후 사용 가능
- if문의 조건을 제외한 상황이 else에 들어가게 된다.
if(boolean 형태의 조건문) {
    실행코드
}
else {
    실행코드
}

else if문

- if를 제외한 추가 조건을 넣고 싶을 때 사용한다.
- if와 else if문의 조건을 모두 충족하지 못하면 else문을 시행한다.
- if와 else 사이에 else if문 여러개 사용 가능

if(number == 10)
{
    System.out.println("축하합니다");
}
else if(number < 10)
{
    System.out.println("작습니다");
}
else {
    System.out.println("큽니다");
}

조건에 따른 실행

- if나 else if문에 두 가지의 조건을 넣고 싶을 때 사용
- 두 조건을 모두 만족하고 싶은 경우 각 조건 사이에 &&사용
- 두 조건 중 하나만 만족해도 되는 경우 각 조건 사이에 ||사용

switch-case

switch(value) {
    case 1:
        value의 값이 1이면 실행할 문장
        break;
    default:
        일차하는 값이 없으면 실행할 문장
}

- 각 케이스의 실행 영역 마지막 줄에는 "break;"와 같은 코드가 필요하다.
- break가 없을 경우 switch문을 종료하지 않고 모든 코드를 실행하게 된다.

- 같은 정수 데이터라도 숫자의 범위에 따라 타입을 나눠 놓는다.
- 데이터의 크기를 생각하여 많은 공간을 차지함에 따라 타입을 설정한다.
- byte, short, int, long

실수형

- 소수점 아래까지 표현할 수 있는 자료형으로 두가지 타입이 존재
- float, double
- Java에서는 float형을 사용하기 위해서 숫자 뒤에 F 또는 f를 붙여줘야 한다.
- double에는 상관 없음

문자형과 문자열

- 문자형은 char 형태가 존재하며 문자 1개를 저장하는 자료형이다.
- 문자열은 여러 문자가 합쳐진 것
- 선언 방식은 일반 변수와 같으며 string으로 명시한다.
    String data = "문자열"
- 문자열과 문자열을 연결하기 위해서는 더하기(+) 연산자를 통해 이어준다.
- 문자열의 글자 수를 세기 위해서는 length를 사용
    data.length();
- 문자열의 일부를 바꾸기 위해서는 replaceAll을 사용한다.
    data.replace("바꿀 문자열", "새 문자열)
- 문자열을 자르기 위해서는 substring을 사용한다.
    data.substring(시작위치, 끝위치);

논리형

- 참 거짓의 값을 가지는 자료형 (boolean)
- true와 false라고 표현하며 각각 1과 0의 값을 가지고 있다.