문제: https://school.programmers.co.kr/learn/courses/30/lessons/12933

🔻 String.parseString()의 오류

처음에는 String.parseString(n) 메서드를 사용하려 했으나, Java에서 이런 메서드는 없었다. 필요할 경우 String.valueOf(n) 또는 Long.toString(n)을 사용하여 long 타입의 숫자를 문자열로 변환할 수 있었다.

🔻 Collections.sort()와 StringBuilder.reverse()의 정렬과 문자열 변환

내가 생각해낸 방법은 아래와 같다.

1. 숫자를 각 자릿수별로 분해하여 ArrayList에 저장.
2. Collections.sort()를 사용하여 내림차순 정렬.
3. StringBuilder를 사용하여 정렬된 숫자를 문자열로 변환.

이 내용을 토대로 문제를 풀어봤다.

--

✅ 내 풀이(1) : Arrays.sort()와 StringBuilder 사용

import java.util.Arrays;

class Solution {
    public long solution(long n) {
        String str1 = Long.toString(n);
        char[] ch = str1.toCharArray();
        StringBuilder sbuilder = new StringBuilder();

        Arrays.sort(ch);

        for(int i=ch.length-1; i>=0; i--) {
            sbuilder.append(ch[i]);
        }
        String str2 = sbuilder.toString();
        long answer = Long.parseLong(str2);
        return answer;
    }
}

👉 문자열을 배열로 변환하고, 배열을 정렬한 후 StringBuilder를 사용하여 문자열을 뒤집고, 다시 숫자로 변환했다.

✅ 내 풀이(2) : ArrayList와 Collections 사용

import java.util.ArrayList;
import java.util.Collections;

class Solution {
    public long solution(long n) {
        ArrayList<Integer> temp = new ArrayList<>();
        while(n > 0){
            temp.add((int)(n % 10));
            n /= 10;
        }
        Collections.sort(temp, Collections.reverseOrder());

        StringBuilder result = new StringBuilder();
        for (int digit : temp) {
            result.append(digit);
        }

        return Long.parseLong(result.toString());
    }
}

👉 숫자를 분해하여 각 자릿수를 내림차순으로 정렬한 후, 다시 문자열로 합치는 과정을 거칩니다.

📚 배운 점: StringBuilder의 reverse() 메서드 StringBuilder 클래스에는 문자열을 뒤집는 reverse() 메서드가 구현되어 있었다. 반면, String 클래스는 불변(immutable)하기 때문에 reverse() 메서드를 직접 제공하지 않는다. 따라서 문자열을 뒤집기 위해서는 StringBuilder를 사용하는게 효율적이다

✅ 내 풀이 ①

import java.util.Arrays;
class Solution {
    public int[] solution(int[] arr, int divisor) {
        int[] answer = new int[arr.length];
        int index = 0;          // 새 배열의 인덱스값 확인하기

                for(int i : arr){
            if(i % divisor == 0) {
                answer[index] = i;
                index++;
            }
        }
        if(index == 0) {
            return new int[] {-1};
        }else {
            answer = Arrays.copyOf(answer, index);          // 초기화된 값 잘라내기
            Arrays.sort(answer);
            return answer;
        }
    }
}

처음에는 주어진 배열인 int[]에 임의로 길이를 설정한 후 index변수를 부여하여 잘라내는 방식으로 진행했다.

생각해보니 길이를 부여해서 추가작업이 생긴거면 애초에 길이설정이 필요없는 ArrayList로 진행하면 되지 않을까? 라는 생각이 들어서 다시 확인해봤다.

✅ 내 풀이 ②

import java.util.ArrayList;
import java.util.Collections;
class Solution {
    public ArrayList<Integer> solution(int[] arr, int divisor) {
        ArrayList<Integer> answer = new ArrayList<Integer>();

        for(int i : arr){
            if(i % divisor == 0) {
                answer.add(i);
            }
        }
        if(answer.size() == 0) {
            answer.add(-1);
        }else {
           Collections.sort(answer);

                    }
        return answer;
    }
}

ArrayList를 사용하면 index를 추가하고 copyOf(배열, 원하는 길이)를 안해도 된다.

다만 return값이 int[]라서 마지막에 int[]배열로 바꿔줘야 하는 단점이 있다.

현재 코드가 정상적으로 진행되는지 확인하기위해 ArrayList로 선언했으나 문제의 의도대로 진행하려면 int[]배열로 바꿔야하는점을 기억하자!

Arrays.copyOf()

배열의 특정 부분을 복사하여 새로운 배열을 생성하는 데 사용됩니다. 이 메서드는 원하는 길이로 배열을 크기 조정하거나, 배열의 특정 부분을 추출하고 싶을 때 유용하다.

배열 전체를 복사할 경우

sourceArray.length를 사용하여 복사할 길이를 지정함

배열의 일부분을 복사할 경우

배열의 인덱스 1부터 4까지 (4는 포함되지 않음)만 복사한다.

Arrays.copyOf() 메서드는 원본 배열의 요소 유형과 동일한 유형의 새로운 배열을 반환하기 때문에 int[] 배열의 경우에는 int[]로, String[] 배열의 경우에는 String[]로 복사된 배열이 생성된다.

✅ 내 풀이 

class Solution {
    public String solution(String[] seoul) {
        String answer = "";
        String find = "Kim";
                for(int i=0; i<seoul.length; i++) {
            if(seoul[i].equals(find)){
                answer = "김서방은 " + i + "에 있다";
                break;
            }
        }
        return answer;
    }
}

equals는 JAVA에서 두 객체의 서로 동일한지 비교하는 메서드이다.

Object를 상속받았기 때문에 모든 메서드에서 사용할 수 있다.

자바의 원시 타입인 int, double, boolean 등에 대해서도 equals 메서드를 사용할 수 있는데 이 경우에는 원시 타입을 해당하는 객체 래퍼 클래스로 자동 박싱하여 비교한다.

int num1 = 10;
int num2 = 20;
boolean isEqual = Integer.valueOf(num1).equals(Integer.valueOf(num2)); // false

배열에 대해서도 equals 메서드를 사용할 수 있습니다. 배열의 내용이 같은지 비교하기 위해서는 Arrays 클래스의 equals 메서드를 사용하면 된다.

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2); // true

 equals 메서드는 모든 객체에 대해 사용할 수 있으며, 숫자, 문자열, 배열 등 모든 타입에 대해 내용 비교를 수행할 수 있습니다.

✅ 다른 풀이

import java.util.Arrays;
public class FindKim {
    public String findKim(String[] seoul){
        //x에 김서방의 위치를 저장하세요.
        int x = Arrays.asList(seoul).indexOf("Kim");        
        return "김서방은 "+ x + "에 있다";
    }

👇  풀이

1. int x = Arrays.asList(seoul).indexOf("Kim");

• Arrays.asList(seoul)을 사용하여 seoul 배열을 List로 변환한다.
• indexOf("Kim") 메서드를 사용하여 "Kim"이라는 문자열이 List에서 처음으로 등장하는 인덱스를 찾는다.
• 찾은 인덱스를 x에 저장한다.

3. return "김서방은 "+ x + "에 있다";

• "김서방은 " 문자열과 x 값을 문자열로 결합한다.
• 결합한 문자열에 "에 있다"를 더해서 최종 결과를 반환한다.

Arrays.asList(seoul).indexOf("Kim");    

1. asList

asList는 자바에서 배열을 리스트로 변환하기 위한 메서드이다. (java.util.Arrays 클래스에 있음)
배열 -> 리스트
기본형 배열의 경우 각 요소는 해당 기본형의 래퍼 클래스로 자동 변환된다.

예시)

2. indexOf("Kim")

indexOf()
컬렉션 또는 문자열에서 특정 요소 또는 문자열이 처음으로 등장하는 인덱스를 반환하는 메서드이다.
이 메서드는 주어진 요소 또는 문자열을 찾아서 해당 위치의 인덱스를 반환하며, 찾지 못한 경우 -1을 반환한다.

배열에서 특정 문자열이 처음으로 나오는 인텍스를 찾는건 indexOf()만 있으며, 배열형의 경우 List인터체이스를 구현한 컬렉션 클래스에서만 사용이 가능하다. 
일반 배열에서는 사용할 수 없기 때문에 Arrays.asList()로 변환되었다.

* indexOf() 메서드의 사용은 컬렉션과 문자열에서 약간 다를 수 있기 때문에 아래의 예시를 참고.

1. 컬렉션에서의 indexOf()

• List 인터페이스를 구현한 컬렉션 클래스에서 사용할 수 있습니다.
• 메서드 시그니처: int indexOf(Object o)
• 주어진 객체 o를 컬렉션에서 찾아서 처음 등장하는 위치의 인덱스를 반환합니다.
• 찾지 못한 경우 -1을 반환합니다.

2. 문자열에서의 indexOf()

• String 클래스에 정의된 메서드로 문자열에서 사용할 수 있습니다.
• 메서드 시그니처: int indexOf(String str)
• 주어진 문자열 str을 호출한 문자열에서 찾아서 처음 등장하는 위치의 인덱스를 반환합니다.
• 찾지 못한 경우 -1을 반환합니다.

✅ 다른 풀이 2

import java.util.Arrays;
class Solution {
   public String solution(String[] seoul) {
        for (int i = 0; i<seoul.length;i++)
            if (seoul[i].equals("Kim")){
                return "김서방은 "+i+"에 있다";
            }
        return "-1";
    }
}

문제: https://school.programmers.co.kr/learn/courses/30/lessons/12916

✅ 내 풀이

class Solution {
    boolean solution(String s) {
        String lowercase = s.toLowerCase();
        int p = 0, y = 0;
       for(int i=0; i<s.length(); i++) {
           if (lowercase.charAt(i) == 'p'){
               p++;
           }
           else if(lowercase.charAt(i) == 'y') {
               y++;
           }
       }

        return p == y;
    }
}

.toLowerCase();

주의할 점은 문자열은 불변(immutable)이기 때문에 원래의 문자열이 변경되는 것이 아니라 새로운 문자열이 생성된다는 점이다.

✅ 다른풀이1

class Solution {
    boolean solution(String s) {
        s = s.toLowerCase();
        int count = 0;
               for(int i=0; i<s.length(); i++) {
           if (s.charAt(i) == 'p'){
               count++;
           }
           else if(s.charAt(i) == 'y') {
               count--;
           }
       }

        return count==0;
    }
}

1. 매개변수 s를 재정의 하면서 변수를 줄임 2. 값의 비교를 ±로 진행하면서 변수를 줄임

내 코드와 비슷하지만 이런식으로 변수를 줄일 수 있는 방법을 생각해보자!

✅ 다른풀이2

//stream 사용
class Solution {
    boolean solution(String s) {
        s = s.toUpperCase();

        return s.chars().filter( e -> 'P'== e).count() == s.chars().filter( e -> 'Y'== e).count();
    }
}

stream은 아직 배우지 않았으나 코드가 간결해보여서 어떤 의미인지 찾아봤다.

1. s = s.toUpperCase();: 주어진 문자열 s를 대문자로 변환하면서 통일시킴. (두 번째 줄에서 사용되는 s.chars() 메서드를 통해 문자열을 문자 스트림으로 변환하기 전에 수행됨)
2. s.chars().filter( e -> 'P'== e): 문자열 s를 문자 스트림으로 변환한 후, 해당 스트림에서 문자 'P'와 일치하는 요소만 필터링을 진행하여 새로운 스트임을 반환함.
3. .count(): 이전 단계에서 필터링된 문자 스트림의 요소 개수를 계산하여 반환함(즉, 문자열 s에서 문자 'P'의 개수를 카운팅)
4. s.chars().filter( e -> 'Y'== e): 문자열 s를 문자 스트림으로 변환한 후, 해당 스트림에서 문자 'Y'와 일치하는 요소만 필터링함.
5. .count(): 이전 단계에서 필터링된 문자 스트림의 요소 개수를 계산하여 반환함(즉, 문자열 s에서 문자 'Y'의 개수를 카운팅)
6. ==: 앞서 계산된 'P'의 개수와 'Y'의 개수를 비교한다.

따라서, 반환되는 값은 문자열 s에 포함된 'P'와 'Y'의 개수가 동일한지를 나타내는 boolean 값이다. 만약 개수가 동일하다면 true를 반환하고, 그렇지 않다면 false를 반환하게 된다.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/12954

✅ 내 풀이

class Solution {
    public long[] solution(int x, int n) {
        long[] answer = new long[n];
        for (int i = 0; i < n; i++) {
            answer[i] = (long) x * (i + 1);
        }
        return answer;
    }
}

처음 이 문제를 풀었을때는 오답으로 나왔는데 그 이유는 타입변환에 있었다. x 자체가 int이기 때문에 long 타입으로 변환해주지 않으면 부분 에러가 발생하게 된다. 그렇지 않으면 큰 수에서 오버플로우가 발생할 수 있다.

valueOf 메서드

valueOf 메서드는 Java에서 기본 데이터 타입을 해당하는 래퍼 클래스의 객체로 변환하는 데 사용되는 정적 메서드다. 이 메서드는 기본 데이터 타입을 객체로 변환하는 과정, 즉 오토박싱(autoboxing)에 유용하다.

valueOf 메서드의 역할과 사용

• 기본 데이터 타입: int, long, float, double, boolean, char 등
• 래퍼 클래스: Integer, Long, Float, Double, Boolean, Character 등

int number = 10;
Integer integerValue = Integer.valueOf(number);

이러한 방법으로 문제를 해결하면서 각 메서드와 클래스의 특성을 이해하고, 상황에 맞는 최적의 해결책을 찾는 데 도움이 되었습니다.

사용 예시

1. 정수 변환 예시:

int number = 10;
Integer integerValue = Integer.valueOf(number);

int -> Integer 객체로 변환

2. 문자열 변환 예시:

Integer integerValue = Integer.valueOf("123");

문자열 "123" -> Integer 객체로 변환

주의사항

• valueOf 메서드는 자동으로 형변환을 수행하지 않는다. 예를 들어, Double.valueOf(3)는 오류를 발생시킬 수 있기 때문에 Double.valueOf(3.0)과 같이 실수 리터럴을 사용하는 것을 주의하자.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/12901

✅ 내 풀이

class Solution {
    public String solution(int a, int b) {
        String dayWeek[] = {"THU","FRI","SAT","SUN","MON","TUE","WED"};       //요일판별
        int monthDay[] ={31,29,31,30,31,30,31,31,30,31,30,31};  //한달일수
        int day = 0;
        String answer = "";


            for(int i=0; i<a-1; i++) {             // 1월부터 입력한 전달까지만 
                day += monthDay[i];
            }

        day = day + b;        

        answer = dayWeek[(day % 7)]; 
        return answer;
    }
}

이 풀이는 2016년의 특정 날짜에 해당하는 요일을 찾기 위해 배열을 사용했다.

1. 날짜 계산: for문을 사용하여 주어진 월(a)의 전 월까지의 총 일수를 day 변수에 누적함.
   예를 들어, a가 3월이면 1월과 2월의 총 일수를 더한다. 입력된 일(b)을 day에 더하여, 2016년 1월 1일부터 a월 b일까지의 총 일수를 계산한다.
   
   
2. 요일 계산: 계산된 총 일수(day)를 7로 나눈 나머지를 구하여 해당 요일의 인덱스를 얻는다.
   문제의 기준점인 2016년 1월 1일이 금요일이기 때문에, 나머지에 해당하는 인덱스를 사용하여 요일을 결정힌다. 예를 들어, 나머지가 0이면 "THU"(목요일), 1이면 "FRI"(금요일)가 되는것이다.
   
   
3. 결과 반환: 계산된 요일을 answer에 할당하고, 이를 반환한다.

✅ 다른 풀이 1: LocalDate 활용

import java.time.*;
class Solution {
  public String solution(int a, int b) {
      return LocalDate.of(2016, a, b).getDayOfWeek().toString().substring(0,3);
  }
}

Java 8의 LocalDate 클래스를 활용하여 날짜를 처리한다. getDayOfWeek() 메서드를 통해 요일을 구하고, 문자열로 변환하여 출력한다.

• LocalDate.of(2016, a, b): 2016년의 특정 월(a)과 일(b)에 해당하는 LocalDate 객체를 생성한다.
• getDayOfWeek(): 생성된 LocalDate 객체에서 요일 정보를 얻는다.
• toString().substring(0, 3): 요일 정보를 문자열로 변환하고, 첫 세 글자를 추출하여 요일의 축약형(예: "TUE")을 얻는다.

LocalDate와 DayOfWeek 클래스는 Java 8에서 도입된 날짜와 시간 API의 일부로, 날짜 관련 연산을 간결하고 직관적으로 처리할 수 있게 해준다. 이 방법은 내부적인 계산 없이 표준 라이브러리를 사용하여 요일을 구하는 가장 간단하고 효율적인 방법이라고 생각한다.

✅ 다른 풀이 2: Calendar 클래스 활용

import java.util.*;

class TryHelloWorld {
    public String getDayName(int month, int day)     {
        Calendar cal = new Calendar.Builder().setCalendarType("iso8601")
                        .setDate(2016, month - 1, day).build();
        return cal.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.SHORT, new Locale("ko-KR")).toUpperCase();
    }
    public static void main(String[] args)     {
        TryHelloWorld test = new TryHelloWorld();
        int a=5, b=24;
        System.out.println(test.getDayName(a,b));
    }
}

Calendar 클래스를 사용하여 더 복잡한 달력 처리를 수행하지만 코드가 길어질 수 있다.

• Calendar.Builder(): Calendar 객체를 구성하기 위한 빌더를 사용한다.
• setCalendarType("iso8601"): ISO 8601 달력 시스템을 사용하도록 설정한다..
• setDate(2016, month - 1, day): 날짜를 2016년, 월(month - 1), 일(day)로 설정합니다. Calendar 클래스에서 월은 0부터 시작하기 때문에 month - 1을 사용한다.
• getDisplayName(): 설정된 날짜에 해당하는 요일의 이름을 지정된 언어(여기서는 한국어)로 반환한다.

Calendar 클래스는 Java의 초기 버전부터 사용되어 온 전통적인 날짜 및 시간 처리 클래스입니다. 더 복잡한 날짜 시간 계산이 필요할 때 유용하다. 이 방법은 더 많은 설정과 세부적인 날짜 시간 관리가 가능하지만, 코드가 길어지고 복잡해질 수 있다.

두 방법 모두 유효하지만, LocalDate를 사용하는 방법이 더 현대적이고 간결하다는 점을 기억하자

• Calendar를 사용하는 방법은 더 복잡한 날짜 시간 연산에 적합할 수 있다.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/12948

✅ 내 풀이(최종코드)

```java
class Solution {
    public String solution(String phone_number) {
        String answer = "";
        int phoneLength = phone_number.length();  

        answer = "*".repeat(phoneLength-4);
        answer += phone_number.substring(phone_number.length()-4);
        return answer;
    }
}

❓ 처음엔 당연히 반복문을 사용했다. 하지만 주어진값이 최대 20자까지 되고, 문제가 간단하기 때문에
"마스킹('*') 처리만 하면 될 것 같은데 반복문을 꼭 돌려야 할까??"
라는 의문이 들어서 문자열을 대체하는 방법을 알아보았다.

1. replaceAll()과 replace() 메서드

replaceAll()과 replace() 메서드는 둘 다 문자열에서 특정 패턴을 찾아 다른 문자열로 대체하는 역할을 하지만 차이가 있다.

1. replaceAll() 메서드:

• 문법: replaceAll(String regex, String replacement)
• 기능: 주어진 정규 표현식(regex)과 일치하는 모든 부분을 찾아 replacement로 대체한다.
• 예시:위 예시에서 "o"라는 정규 표현식과 일치하는 모든 부분이 "*"로 대체되어 출력된다.
• 주의사항:
  • replaceAll() 메서드는 정규 표현식을 사용하기 때문에 패턴이 복잡할 수 있습니다. 일반적인 문자열 대체를 위해서는 replace() 메서드를 사용하는 것이 더 편리하다.

2. replace() 메서드:

• 문법: replace(CharSequence target, CharSequence replacement)
• 기능: 주어진 대상 문자열(target)과 일치하는 모든 부분을 찾아 replacement로 대체한다.
• 예시:위 예시에서 "o"라는 대상 문자열과 일치하는 모든 부분이 "*"로 대체되어 출력된다.
• javaCopy code

String str = "Hello, World!"; String replaced = str.replace("o", "\*");
System.out.println(replaced); // Hell\*, W\*rld!

• 주의사항:
  • replace() 메서드는 정규 표현식을 사용하지 않으므로 간단한 문자열 대체에 적합하다. 문자열 내에서 특정 문자 또는 문자열을 대체할 때 사용할 수 있다.

String str = "Hello, World!";
String replaced = str.replace("o", "*");
System.out.println(replaced); // Hell*, W*rld!

따라서, replaceAll() 메서드는 정규 표현식을 사용하여 문자열을 대체하고 싶을 때 사용하며, replace() 메서드는 단순히 특정 문자 또는 문자열을 대체하고 싶을 때 사용한다. 해당 문제는 특정한 단어를 대체하는게 아니기 때문에 다른 방법을 알아보았다.

2. substring()

class Solution {
    public String solution(String phone_number) {
        String answer = "";

        for(int i=0; i<phone_number.length()-4; i++) {
            answer += "*";
        }
        answer += phone_number.substring(phone_number.length()-4);
        return answer;
    }
}

substring() 메서드는 문자열에서 원하는 부분 문자열을 추출하는 데 사용된다. 이 문제에서는 뒤의 4자리만 기존값을 사용하고 나머지는 모두 마스킹처리를 진행하면 되기 때문에 substring()으로 필요한 부분만 추출해서 사용하는게 더 좋다고 생각한다.

substring() 메서드의 사용 예시

1. substring(int beginIndex) 메서드:

• beginIndex부터 문자열의 끝까지의 부분 문자열을 반환

String str = "Hello, World!";
String substr = str.substring(7);
System.out.println(substr); // "World!"

• 위의 예시에서 substring(7)은 인덱스 7부터 문자열의 끝까지의 부분 문자열인 "World!"를 추출합니다.

2. substring(int beginIndex, int endIndex) 메서드:

• beginIndex부터 endIndex - 1까지의 부분 문자열을 반환

String str = "Hello, World!";
String substr = str.substring(0, 5);
System.out.println(substr); // "Hello"

콤마를 안찍으면 기입한 숫자부터 끝까지 출력

주의사항:

• substring() 메서드는 추출된 부분 문자열을 반환하며, 원본 문자열은 변경되지 않습니다.
• beginIndex는 추출하려는 부분 문자열의 시작 인덱스를 나타내며, endIndex는 추출하려는 부분 문자열의 끝 인덱스를 나타냅니다. endIndex는 실제 추출되는 부분 문자열에는 포함되지 않습니다.
• 인덱스는 0부터 시작하므로 첫 번째 문자는 인덱스 0입니다.
• beginIndex와 endIndex 값은 유효한 범위 내에 있어야 합니다. 그렇지 않으면 IndexOutOfBoundsException이 발생할 수 있습니다.

위의 사용 방법을 참고하여 substring() 메서드를 적절히 활용하여 원하는 부분 문자열을 추출할 수 있습니다.

✅다른풀이(1)

class Solution {
  public String solution(String phone_number) {
     char[] ch = phone_number.toCharArray();
     for(int i = 0; i < ch.length - 4; i ++){
         ch[i] = '*';
     }
     return String.valueOf(ch);
  }
}

.toCharArray();

앞 부분의 배열만 바꾸면 되는거라 바꾸고 스트링으로 다시 변환하기

✅다른풀이 (2-1)

class Solution {
  public String solution(String phone_number) {
      String answer = "";

        for (int i = 0; i < phone_number.length() - 4; i++)
            answer += "*";

        answer += phone_number.substring(phone_number.length() - 4);

        return answer;
  }
}

✅다른풀이 (2-2)

class Solution {
    public String solution(String phone_number) {
        String answer = "";
        int phoneLength = phone_number.length();  

        answer = "*".repeat(phoneLength-4);
        answer += phone_number.substring(phone_number.length()-4);
        return answer;
    }
}

풀이 2번에서는 두번 사용되는 String phone_number의 길이를 변수화 시키고, .repeat()을 활용하여 phone_number의 자리수가 달라지더라도 (phoneLength-4)번만 마스킹 처리를 진행하게 만든다.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/12910

✅ 내 풀이

import java.util.Arrays;
class Solution {
    public int[] solution(int[] arr, int divisor) {
        int[] answer = new int[arr.length];
        int index = 0;

        for(int i=0; i<arr.length; i++) {
            if(arr[i] % divisor == 0) {
                answer[index] = arr[i];
                index++;
            }
        }
        if(index == 0) {
            return new int[] {-1};
        }else {
            answer = Arrays.copyOf(answer, index);
            Arrays.sort(answer);
        }

                return answer;
    }
}

✅ 반환값을 바꿔봤음

import java.util.ArrayList;
import java.util.Collections;

class Solution {
//    public int[] solution(int[] arr, int divisor) {
//    public ArrayList<Integer> solution(int[] arr, int divisor) {
        ArrayList<Integer> answer = new ArrayList<Integer>();

                for(int a:arr) {
            if(a % divisor == 0) {
                answer.add(a);
            } 
        }
        if (answer.size() == 0) {
            answer.add(-1);
        }
        Collections.sort(answer);

                return answer;
    }
}

이렇게 문제를 바꾸면 안되지만 주어진 문제대로 풀어보기도 했고 내가 원하는 방식으로 풀고싶어서 확인해봤다.

이 문제는 배열의 나머지 여부를 확인 후 조건에 해당되는 값만 배열로 받은 후 오름차순으로 정렬하는 문제이다.

array와 Arrays.sort()로 해결할 수 있으나, 또 사실 기존의 문제가 int[]형으로 돌려주기 때문에 array로 푸는것이 맞으나 

array의 경우 배열이 추가될 때 값의 수정이 아닌 복사 후 새로 만들기 때문에 메모리와 성능적인 관점에서 동적으로 조정이 가능한 ArrayList를 써보고 싶었다.

그리고 array의 경우 초기화가 필수이기 때문에 초기화값(0)이 남을 수 있고, 쓰레기값을 버리기 위해 오름차순으로 정리 후 다시 배열을 생성해야하는 번거로움이 있다고 생각했다.

1. 반환타입 고치기 int[] -> ArrayList

2. 향상된 for문으로 해당값만 answer.add() 하기

3. Collections.sort()를 이용하여 오름차순 정리하기

* Collections.sort()
List 인터페이스를 구현한 모든 컬렉션에 사용할 수 있다.
ArrayList, LinkedList, Vector 등과 같은 자바의 내장 컬렉션 클래스뿐만 아니라, Stack, Queue 등과 같은 컬렉션 인터페이스를 구현한 사용자 정의 컬렉션 클래스에도 Collections.sort()를 적용할 수 있다.

Collections.sort()는 컬렉션의 요소를 정렬하기 위해 자바의 정렬 알고리즘을 활용합니다. 따라서 요소들이 정렬 가능한 객체여야 한다.
정렬 가능한 객체는 Comparable 인터페이스를 구현한 객체이거나, Comparator를 제공하여 비교 로직을 지정한 객체이다.
이에 따라 컬렉션의 요소가 정렬 가능한 객체인 경우 Collections.sort()를 사용하여 정렬할 수 있다.

4. answer.size()로 공배열 여부를 확인 후 공배열일 경우 .add(-1)를 진행하기

👉정답 도출 확인완료

📌 StringBuffer / StringBuilder 설명참조

[프로그래머스(java)] 문자열 뒤집기 (StringBuffer, StringBuilder)

문제: https://school.programmers.co.kr/learn/courses/30/lessons/181942

✅ 내 코드

import java.util.*;

class Solution {
    public String solution(String str1, String str2) {
        StringBuilder sb = new StringBuilder();

        for (int i=0; i<str1.length(); i++) {
            sb.append(str1.charAt(i)).append(str2.charAt(i));
        }
        return sb.toString();
    }
}

<풀이>

이 문제는 String 문자열을 한 단어씩 번갈아 조합하여 새로운 문자열을 만드는 것이다.
.charAt()을 사용하여 문자열을 한개씩 꺼내올 수 있으며, 그렇게 추출한 문자들을 한 문장으로 만들기 위해 반복문 for을 사용했다.
return문으로 돌려주는 형태를 String으로 선언해도 동일한 값은 나오지만  String의 경우 불변(immutable)한 클래스이기 때문에 비용이 증가하여 비효율적이다. 그래서 가변 클래스인 StringBuilder()/ StringBuffer()를 사용하는게 좋다.

<비교>

문제:https://school.programmers.co.kr/learn/courses/30/lessons/12931

✅ 내 코드_나머지값을 활용함

class Solution {
    public int solution(int n) {
        int answer = 0;

        while(n>0){
            answer+=n%10;
            n/=10;
        }

        return answer;
    }
}

조건: n > 0
활용방안: 나머지 수

<풀이>

n = 1234일 때 
n % 10 = 123.4  즉, 값 4를 반환함
n / = 10으로 반복 진행
n의 진행값 : (123.4 (123) -> 12.3 (12)-> 1.2 (1) -> 0.1 (0) ) 반복종료

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120817

✅ 내 풀이

class Solution {
    public double solution(int[] numbers) {
        double answer = 0;
        int sum = 0;
        for(int i: numbers){
            sum+=i;
        }
        answer = sum/(double)numbers.length;
        return answer;
    }
}

// 다른풀이 stream()
import java.util.Arrays;

class Solution {
    public double solution(int[] numbers) {
        return Arrays.stream(numbers).average().orElse(0);
    }
}

📌stream()

average()와 orElse(0)는 스트림을 활용하여 평균 값을 계산하고 반환할 때 유용한 명령어이다.

stream()은 데이터의 연속적인 흐름을 나타내는 기능이며 컬렉션(Collection)과 배열 등의 데이터 소스로부터 데이터를 받아들이고, 다양한 중간 연산과 최종 연산을 통해 데이터를 처리하는 기능을 제공한다.

🔻 특징

1. 데이터 소스: 스트림은 컬렉션, 배열, I/O 채널 등 다양한 데이터 소스로부터 데이터를 받아들일 수 있다.
2. 연속적인 흐름: 스트림은 데이터를 순차적으로 한 번에 하나씩 처리합니다. 이는 데이터를 메모리에 모두 로드하지 않고 필요한 데이터만 처리할 수 있게 해준다.
3. 중간 연산: 스트림은 중간 연산을 통해 데이터를 변환, 필터링, 정렬 등의 작업을 수행할 수 있습니다. 이러한 중간 연산은 지연(lazy) 연산이며, 최종 연산이 호출될 때에만 실제로 수행된다.
4. 최종 연산: 스트림은 최종 연산을 통해 데이터를 처리하고 결과를 반환합니다. 최종 연산은 스트림 파이프라인을 종료시키는 역할을 수행하며, 스트림의 요소를 수집하거나 결과를 반환하는 역할을 할 수 있다.
5. 내부 반복: 스트림은 내부적으로 반복을 처리하므로 개발자가 직접 반복 코드를 작성할 필요가 없다.

💬 스트림을 사용하기 위해 다음과 같은 일련의 단계를 따를 수 있다.

1. 스트림 생성: 데이터 소스로부터 스트림을 생성 후 Stream 인터페이스의 정적 메서드를 사용하거나, 컬렉션의 stream() 메서드를 호출하여 스트림을 생성할 수 있다.
2. 중간 연산: 생성된 스트림에 대해 중간 연산을 적용한다. 이 단계에서 데이터를 변환, 필터링, 정렬 등의 작업을 수행할 수 있고, 중간 연산은 여러 개를 연결하여 체인 형태로 작성할 수 있다.
3. 최종 연산: 최종 연산을 통해 스트림의 요소를 처리하고 결과를 반환한다. 이 단계에서 스트림의 파이프라인이 종료되며, 결과를 수집하거나 반환할 수 있다.

✅ 스트림(stream) 예시

import java.util.Arrays;
import java.util.List;
public class StreamExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "orange", "kiwi", "grape");

        fruits.stream()  // 스트림 생성
                .filter(fruit -> fruit.length() > 5)  // 중간 연산: 길이가 5보다 큰 과일만 필터링
                .map(String::toUpperCase)  // 중간 연산: 모든 과일을 대문자로 변환
                .sorted()  // 중간 연산: 과일을 알파벳순으로 정렬
                .forEach(System.out::println);  // 최종 연산: 결과 출력
    }
}

예시에서는 fruits 리스트를 스트림으로 변환하고, 중간 연산과 최종 연산을 사용하여 데이터를 처리하고 결과를 출력하고 있다.
filter(), map(), sorted() 등의 중간 연산을 체인 형태로 연결하고, forEach()를 통해 최종 연산을 수행하여 각 과일을 대문자로 변환하고 알파벳순으로 정렬한 결과를 출력한다.
스트림은 데이터 처리 작업을 간결하고 효율적으로 수행할 수 있는 강력한 기능으로, 함수형 프로그래밍 스타일의 코드를 작성할 수 있으며, 스트림은 병렬 처리 등 다양한 기능을 지원하므로 대량의 데이터를 처리할 때 효과적으로 사용할 수 있다.

❗ 자주 사용되는 몇 가지 스트림 연산

1. 중간 연산 (Intermediate Operations):

• filter(Predicate predicate): 주어진 조건에 맞는 요소만을 선택합니다.
• map(Function<T, R> mapper): 요소를 다른 형태로 변환합니다.
• flatMap(Function<T, Stream> mapper): 요소를 다른 형태의 스트림으로 변환한 후 펼쳐서 결합합니다.
• sorted(): 요소를 정렬합니다.
• distinct(): 중복 요소를 제거합니다.
• limit(long maxSize): 요소의 개수를 제한합니다.
• skip(long n): 처음 n개의 요소를 건너뜁니다.
• peek(Consumer action): 요소를 소비하면서 중간 결과를 확인합니다.

2. 최종 연산 (Terminal Operations):

• forEach(Consumer action): 각 요소를 소비하여 작업을 수행합니다.
• count(): 요소의 개수를 반환합니다.
• collect(Collector<T, A, R> collector): 요소를 수집하여 컬렉션, 맵, 문자열 등의 형태로 반환합니다.
• min(Comparator comparator) / max(Comparator comparator): 최소값 또는 최대값을 반환합니다.
• anyMatch(Predicate predicate): 주어진 조건을 만족하는 요소가 하나라도 있는지 확인합니다.
• allMatch(Predicate predicate): 모든 요소가 주어진 조건을 만족하는지 확인합니다.
• noneMatch(Predicate predicate): 모든 요소가 주어진 조건을 만족하지 않는지 확인합니다.
• findFirst(): 첫 번째 요소를 반환합니다.
• findAny(): 임의의 요소를 반환합니다.

✅ average() // orElse(0): 예제

import java.util.stream.IntStream;
public class StreamAverageExample {
    public static void main(String[] args) {
        IntStream numbers = IntStream.of(1, 2, 3, 4, 5);
        double average = numbers.average().orElse(0);
        System.out.println("Average: " + average);
    }
}

🔹 average():

• average()는 스트림의 요소들의 평균 값을 계산하는 최종 연산이다.
• double 타입의 OptionalDouble 객체를 반환한다.
• 스트림이 비어있는 경우 OptionalDouble.empty()를 반환한다.
• 예를 들어, IntStream에서 average()를 호출하면 평균 값을 계산하여 반환한다.
• 위의 예시에서는 IntStream에 대한 평균 값을 계산하고 있습니다. average()를 호출한 후 orElse(0)을 사용하여 평균 값이 존재하지 않는 경우에는 0을 반환하도록 처리되었다.

🔹 orElse(0):

• orElse(0)는 Optional 객체가 비어있는 경우 대체 값을 반환하는 메서드이다.
• Optional 객체가 비어있는 경우, 대체 값을 반환하며, 비어있지 않은 경우 Optional 객체의 값을 반환한다.
• 위 예시 코드에서 average() 메서드의 결과는 OptionalDouble 객체이므로, orElse(0)를 호출하여 평균 값이 존재하지 않는 경우 0을 반환하도록 처리되었다.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120847

✅ 내 풀이

import java.util.Arrays;
class Solution {
    public int solution(int[] numbers) {
        Arrays.sort(numbers);               // 오름차순 정렬 후 
        return numbers[numbers.length-1] * numbers[numbers.length-2];  // 인덱스값으로 곱하기
    }
}

📌  sort()
java.util.Arrays 클래스에는 배열을 정렬하는 데 사용할 수 있는 sort() 메서드가 있다.

이 메서드를 사용하면 배열의 요소를 오름차순으로 정렬할 수 있다.

public static void sort(int[] a)  // a : 정렬하려는 배열

✅ sort() 예시코드

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 8, 1, 6};

        Arrays.sort(array);             // array를 오름차순으로 정렬함

        // 정렬된 배열 출력               
        System.out.print(Arrays.toString(array));      
    }
}

// 출력값 : [1, 2, 5, 6, 8]

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120854

✅ 내 코드

class Solution {
    public int[] solution(int[] numbers, int num1, int num2) {
        int index = 0;
        int[] answer = new int[num2 - num1 + 1];     // 배열의 크기 지정
        for (int i = num1; i <= num2; i++) {
            answer[index] = numbers[i];                // 여기서 값을 받기 위해 새로운 배열을 생성했음
            index++;                                

          }
        return answer;
    }
}

✅ 다른풀이(1) (코드 간결화)

class Solution {
    public int[] solution(int[] numbers, int num1, int num2) {
        int[] answer = new int[num2 - num1 + 1];
        for (int i = num1; i <= num2; i++) {
            answer[i -num1] = numbers[i];
        }

        return answer;
    }
}

✅ 다른풀이(2) 

import java.util.*;
class Solution {
    public int[] solution(int[] numbers, int num1, int num2) {
        return Arrays.copyOfRange(numbers, num1, num2 + 1);
    }
}

📌 copyOfRange()

java.util.Arrays.copyOfRange() 메서드는 Java에서 배열의 특정 구간을 복사하여 새로운 배열을 생성하는 기능을 제공하는 메서드이다.

public static T[] copyOfRange(T[] original, int from, int to)

• original: 복사할 원본 배열
• from: 복사할 구간의 시작 인덱스 (포함)
• to: 복사할 구간의 끝 인덱스 (포함하지 않음)

✔ original 배열에서 from 인덱스부터 to 인덱스까지의 구간을 새로운 배열로 복사하여 반환하며, 반환되는 배열의 길이는 (to - from)

이다.

from = 이상 ( from(인덱스 값) <= x)to = 미만( x < to(인덱스 값))

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120824

✅ 내 풀이

class Solution {
    public int[] solution(int[] num_list) {
        int even = 0, odd = 0;
        int[] answer = new int[2];

                for (int i=0; i< num_list.length; i++){
            if(num_list[i] % 2 == 0) {
                even++;
            }
            else odd++; 
            answer[0] = even;
            answer[1] = odd;
        }
        return answer;
    }
}

✅ 1. 다른풀이 (코드 간결화)

// 1. 다른풀이 (코드 간결화)
class Solution {
    public int[] solution(int[] num_list) {
        int[] answer = new int[2];

        for(int i = 0 ; i < num_list.length ; i++){
            if(num_list[i]%2==0){
                answer[0]++;
            }else{
                answer[1]++;
            }
        }

        return answer;
    }
}

📄 내 코드보다 깔끔한 이유 ❓
: 출력값이 [짝수, 홀수]로 나오기 때문에 굳이 변수를 선언하는게 아니라 if문에 맞춰서 answer[0], [1]값을 바로 카운팅하면 된다.

✅ 2. 다른풀이

class Solution {
    public int[] solution(int[] num_list) {
        int[] answer = new int[2];
        for(int i = 0; i < num_list.length; i++)
            answer[num_list[i] % 2]++;

        return answer;
    }
}

📄 풀이)

num_list = {1, 2, 3, 4, 5}; 일때
num_list[0] % 2 = 1;
num_list[1] % 2 = 0;
num_list[2] % 2 = 1;
num_list[3] % 2 = 0;
num_list[4] % 2 = 1;
answer[1]++;
answer[0]++;
answer[1]++;
answer[0]++;
answer[1]++;

// 결과값 형태: [짝수의 개수, 홀수의 개수]
// 짝수 = 나머지가 0임 = answer의 0번째 인덱스에 카운팅됨

// 즉, answer[num_list[i] % 2]++; 코드로 짝수 or 홀수 판별 후 카운팅까지 가능함

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120825

✅ 내 풀이

class Solution {
    public String solution(String my_string, int n) {
        String answer = "";

        for(int i=0; i<my_string.length();i++){
            for (int j=0; j<n; j++){
                answer += my_string.charAt(i);
            }
        }
        return answer;
    }
}

🔻 1. 다른풀이

class Solution {
    public String solution(String my_string, int n) {
        String answer = "";
        String[] str = my_string.split("");       // 문자열을 한글자씩 분리 후 배열저장
        for(int i=0; i<my_string.length(); i++){  
            answer += str[i].repeat(n);               // 반복 후 String으로 저장    
        }
        return answer;
    }
}

📌split () : 자바의 split() 메서드는 문자열을 특정 구분자(delimiter)를 기준으로 분리하여 문자열 배열로 반환하는 기능을 제공함.

ex) abcdef -> split("c")

split("") -> 모든 단어를 끊어서 배열에 저장한다.

🔻 2. 다른풀이

class Solution {
    public String solution(String my_string, int n) {
        StringBuilder sb = new StringBuilder();
        for(char c : my_string.toCharArray()){
            sb.append((c + "").repeat(n));  // c배열값 하나씩 돌리면서 반복을 함께 진행
        }
        return sb.toString();
    }
}

📌 toCharArray()는 자바 문자열을 문자 배열(char array)로 변환하는 메서드이다.

이 메서드는 문자열의 각 문자를 개별적인 배열 요소로 만들어 새로운 char 배열을 반환한다.

String originalString = "Hello";
char[] charArray = originalString.toCharArray();
for (char ch : charArray) {
    System.out.println(ch);
}

// 출력값
// H
// e
// l
// l
// o

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120826

✅ 내 풀이

class Solution {
    public String solution(String my_string, String letter) {
        String answer = "";

        answer = my_string.replace(letter, "");

        return answer;
    }
}

📌 replace() 

: 문자열에서 특정 문자 또는 문자열을 다른 문자 또는 문자열로 대체하는 기능을 제공한다.

// 단일 문자 대체
String originalString = "Hello, World!";
String replacedString = originalString.replace('o', 'x');
System.out.println(replacedString);  // "Hellx, Wxrld!"

// 문자열 대체 
// target과 일치하는 모든 문자열을 변경한다.
String originalString2 = "Hello, Java!";
String replacedString2 = originalString2.replace("Java", "Python");
System.out.println(replacedString2);  // "Hello, Python!"

❌ replace() 메서드는 원본 문자열을 변경하지 않고 대체된 새로운 문자열을 반환한다.

따라서 원본 문자열을 변경하고자 한다면 StringBuilder 또는 StringBuffer를 사용하여 문자열을 조작해야 한다.

참고) https://velog.io/@yes_jihyeon/%EC%9E%90%EB%B0%94JAVA-%EB%AC%B8%EC%9E%90%EC%97%B4-%EB%92%A4%EC%A7%91%EA%B8%B0-StringBuffer-StringBuilder

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120822

✅ 내 코드

class Solution {
    public String solution(String str) {
        String answer = "";

        for(int i=str.length()-1; i >= 0; i--){
            answer+=str.charAt(i);
        }
        return answer;
    }
}

📌 다른풀이(1) : StringBuilder() 사용

class Solution {
    public String solution(String my_string) {

        StringBuilder sb = new StringBuilder(my_string);
        String answer = sb.reverse().toString();

        return answer;
    }
}

📌  다른풀이(2) : StringBuffer() 사용

class Solution {
    public String solution(String my_string) {

        StringBuffer sb = new StringBuffer(my_string);
        String answer = sb.reverse().toString();

        return answer;
    }
}

📘 String , StringBuilder, StringBuffer의 차이점

1. 불변성(Immutability)
2. 스레드 안전성(Thread Safety)
3. 성능

1. 💬 불변성(Immutability)

        🔸 String - 불변(immutable)한 클래스

          : 한 번 생성된 String 객체는 변경할 수 없기 때문에 문자열을 수정하거나 조작할 때마다 새로운 String 객체가 생성   된다.

          : String의 값이 변경된것처럼 보이는 이유는 기존 문자열을 수정하는것이 아니라 내부적으로 변경된 문자열을 새롭게 만들어내기 때문이다.

          : 즉, String은 문자열을 할당한 후에는 수정하지 말고 읽기만 하려는 목적을 가지고 있다. 

        🔸StringBuilder, StringBuffer - 가변(mutable)한 클래스

          : 내부적으로 가변 크기의 문자 배열을 사용하여 문자열 조작하기 때문에 문자열을 변경할 때마다 새로운 객체를 생성하지 않고 내부 배열을 조작한다.

2. 💬 스레드 안전성(Thread Safety)

⭐ 스레드 안전성(Thread Safety)이란❓
: 멀티스레드 환경에서 여러 스레드가 동시에 하나의 공유된 자원을 접근하더라도 원하는 동작을 안전하게 보장하는 것을 말한다.

        🔸 StringBuilder - 멀티스레드 환경에서 동시에 접근할 경우 동기화 문제가 발생할 수 있기 때문에 안전하지 않다.

        🔸 StringBuffer - 여러 스레드에서 동시에 접근하더라도 안전하게 조작할 수 있도록 동기화 메커니즘을 내부적으로 제공하기 때문에 안전하다.

   1. 정확성:

        - 멀티스레드 환경에서도 올바른 결과를 산출한다.

        - 여러 스레드가 동시에 자원에 접근하더라도 데이터 불일치, 잘못된 결과를 생성하지 않고 의도한 대로 동작한다.

    2. 일관성:

        - 동일한 입력과 상태에서 여러 번 실행되더라도 실행 결과가 스레드 간에 일관성을 유지하여 항상 일관된 결과를 제공한다.

    3. 동기화:

        - 스레드 간의 동기화를 통해 자원의 동시 접근 문제를 제어한다.

        - 동기화 메커니즘을 사용하여 스레드가 상호 배타적으로 접근하도록 보장한다.

스레드 안전성을 보장하기 위해서는 공유 자원에 대한 접근을 동기화해야 합니다. 동기화 메커니즘으로는 락(lock), 세마포어(semaphore), 모니터(monitor) 등이 사용될 수 있습니다. 이를 통해 한 번에 하나의 스레드만이 공유 자원에 접근할 수 있도록 보장하고, 일관성과 정확성을 유지할 수 있습니다.

스레드 안전성은 멀티스레드 환경에서 동시성 문제를 해결하고, 데이터 불일치와 같은 오류를 방지하는 데 중요한 역할을 합니다. 스레드 안전한 코드를 작성하여 프로그램의 안정성과 성능을 유지하고, 예기치 않은 동작을 방지할 수 있습니다.

3. 💬 성능

        🔸 String 

          : 불변성으로 인해 문자열을 변경할 때마다 새로운 객체를 생성해야한다.

          : 문자열을 연결하거나 수정할 때마다 새로운 String 객체가 생성되므로 메모리 사용이 늘어나서 조작이 빈번할 경우 메모리 할당과 가비지 컬렉션 비용이 증가할 수 있다.

        🔸 StringBuilder 

          : 내부적으로 가변 크기의 문자 배열을 사용하여 문자열 조작을 수행한다.

          : 문자열을 변경할 때마다 새로운 객체를 생성하지 않고 내부 배열을 조작하여 성능을 향상시킨다.

        🔸 StringBuffer 

          : 내부 배열을 조작하므로 객체 생성 비용이 들지 않기 때문에 문자열 조작이 많은 경우 성능상 이점이 있다.

          : 다만, 동기화 메커니즘을 내부에서 처리하기 때문에 오버헤드가 조금 더 발생할 수 있다.

일반적으로 단일 스레드 환경 + 문자열 조작이 필요한 경우 StringBuilder를 사용하는 것이 가장 효율적이다.
멀티스레드 환경에서 스레드 안전성이 요구되는 경우 StringBuffer를 사용한다.
String은 문자열이 변경되지 않는 경우나 스레드 안전성이 보장된 단일 스레드 환경에서 주로 사용한다.

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120909

✅ 내 풀이

class Solution {
    public int solution(int n) {
        return Math.sqrt(n) % 1 == 0 ? 1 : 2;
    }
}

📌Math.sqrt() : 숫자의 제곱근을 반환하는 함수 

ex) 14의 제곱근 

출력값

n이 어떤수의 제곱이라면 출력값이 정수로 나옴

즉, 출력값 % 1 = 0이므로 아래와 같이 사용할 수 있다.

return Math.sqrt(n) % 1 == 0 ? 1 : 2;

문제: https://school.programmers.co.kr/learn/courses/30/lessons/120830

✅ 내 풀이

class Solution {
    public int solution(int n, int k) {
        int price1 = 12000 * n;              // 양꼬치 총 몇 인분인지
        int freeCount = (n / 10);            // 양꼬치 10인분당 음료서비스 1개 산출
        int price2 = 2000 * (k - freeCount); // 총 음료에서 서비스 제외

        int answer = price1 + price2;
        return answer;
    }
}

✅ 다른풀이

class Solution {
    public int solution(int n, int k) {
        int answer = 0;
        answer= n*12000 + (k-n/10)*2000;
        return answer;
    }
}

값은 똑같지만 내 풀이의 코드가 더 길다. 그래서 이유를 살펴보았다.

[풀이의 코드가 길어진 이유]

1) 매개변수 선언시 데이터 타입(int)을 이미 설정했기 때문에 int price1,2를 선언할 필요가 없음 2) 단순연산만 필요하기 때문에 굳이 연산식을 따로 정의할 필요가 없음

결론: 쉬운문제라도 변수의 활용을 줄이고 코드의 비용이 가장 적게드는 방법을 연구해보자!

시도

- **로그 분석**: 카카오 유저의 로그인 흐름을 파악하기 `JwtAuthenticationFilter`와 `KakaoService` 에 log.info를 추가하여 분석하였고, 카카오 소셜로그인의 경우에는 해당 필터를 거치지 않는 것을 확인함.
- **원인 파악**: 카카오 소셜 로그인은 클라이언트와 카카오 서버 간의 직접적인 통신이 진행된다. 따라서 JwtAuthenticationFilter를 타지 않는 것으로 추정함
- **로그인 처리 시 유저 상태 확인 추가**:

    ```java
    if (kakaoMember != null && kakaoMember.getRole().equals(UserRoleEnum.BLOCK)) {
        throw new DisabledException("차단된 계정입니다.");
    }
    ```

    • `KakaoService`의 `registerKakaoUserIfNeeded` 메소드 내에서 이미 존재하는 카카오 사용자인 경우, 사용자의 상태를 확인하고 차단된 사용자인 경우 로그인을 허용하지 않는 로직을 추가.

- **예외 처리 및 응답 로직 추가**:

    ```java
    public Map<String, Object> registerKakaoUserIfNeeded(KakaoUserInfoDto kakaoUserInfo) {
        // ... 기존 코드 ...
        Member kakaoMember = memberRepository.findByKakaoId(kakaoId).orElse(null);
        // 기존 사용자가 BLOCK 상태인지 확인
        if (kakaoMember != null && kakaoMember.getRole() == UserRoleEnum.BLOCK) {
            throw new CustomKakaoBlockException("BLOCK 상태의 계정으로 로그인할 수 없습니다.");
        }
        // ...
        return result;
    }
    ```

- `KakaoService`에서 예외가 발생한 경우를 적절히 처리하고 클라이언트에게 적절한 응답을 반환할 수 있도록 예외 처리 로직 추가.
- **커스텀 예외 및 전역 예외 처리 추가**:

    ```java
    public class CustomKakaoBlockException extends RuntimeException {
        public CustomKakaoBlockException(String message) {
            super(message);
        }
    }
    ```

    ```java
            @RestControllerAdvice
    public class GlobalExceptionHandler {
        @ExceptionHandler(CustomKakaoBlockException.class)
        public ResponseEntity<MsgResponse> handleCustomException(CustomKakaoBlockException ex) {
            MsgResponse errorResponse = new MsgResponse(ex.getMessage());
            return new ResponseEntity<>(errorResponse, HttpStatus.FORBIDDEN);
        }
    }
    ```

    • `CustomKakaoBlockException` 클래스를 생성하여 커스텀 예외를 정의하고, 이를 전역에서 처리할 수 있도록 `GlobalExceptionHandler`에 예외 핸들러를 추가.


해결

- **문제 해결**: 카카오 소셜로그인 사용자도 계정이 차단된 경우에는 로그인이 차단되고, 클라이언트에게는 적절한 응답이 전달되도록 수정됨.