[백준] 1920번 수 찾기

https://www.acmicpc.net/problem/1920

문제

N개의 정수 A[1], A[2], …, A[N]이 주어져 있을 때, 이 안에 X라는 정수가 존재하는지 알아내는 프로그램을 작성하라

입력 :

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들이 A안에 존재하는지 알아내면 된다. 모든 정수의 범위는 -231 보다 크거나 같고 231보다 작다.

출력 :

M개의 줄에 답을 출력. 존재하면 1, 존재하지 않으면 0을 출력

나의 답안

import java.util.*;

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

        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        StringBuilder sb = new StringBuilder();

        for (int i=0; i<N; i++) {
            sb.append(sc.next());
        }
        String str = sb.toString();

        int M = sc.nextInt();
        for (int i=0; i<M; i++) {
            System.out.println(str.contains(sc.next())? 1 : 0);
        }
    }
}

처음엔 StringBuilder를 사용하여 답을 출력하는 코드를 작성했으나 시간초과되었다.

contains() 메서드를 사용했는데,

찾아보니 해당 메서드는 O(N*M)의 시간 복잡도(여기서는 O(5*5)를 가져 시간 초과를 유발한 것으로 보인다.

import java.util.*;

public class Main {

    static int[] A;
    public static int binarySearch(int start, int end, int target) {
        int mid = (start + end) / 2;
        if (mid > end || mid < start) return 0;
        if (A[mid] == target) return 1;
        if (A[mid] < target) return binarySearch(mid+1, end, target);
        if (A[mid] > target) return binarySearch(start, mid-1, target);
        return 0;
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        A = new int[N];

        for (int i=0; i<N; i++) {
            A[i] = sc.nextInt();
        }
        Arrays.sort(A);

        int M = sc.nextInt();
        for (int i=0; i<M; i++) {
            System.out.println(binarySearch(0, N-1, sc.nextInt()));
        }
    }
}

이진탐색 방법을 사용하여 구했다.

입력을 A배열에 담고, 오름차순 정렬한 후,

입력받은 값과 A배열의 중간값을 비교하여 더 크면

중간값 이후의 값들과 비교, 작으면 중간값 이전의 값들과 비교해가며

탐색 영역을 반씩 줄여나가는 방법.

첫 번째 코드의 시간 복잡도는 contains메서드를 사용해 O(5*5)정도라고 하면,

이진탐색의 시간복잡도는 O(5*log5) 이기 때문에,

두번째 코드가 시간 초과를 면할 수 있던 것으로 보인다.

개선 사항

import java.util.*;

public class Main {

    static int[] A;

    public static int binarySearch(int start, int end, int target) {

        // while문으로 가독성 UP
        while (start <=end) {
            int mid = (start + end) / 2;
            if (A[mid] == target) return 1;
            if (A[mid] < target) start = mid + 1;
            else end = mid - 1;
        }
        return 0;
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        A = new int[N];

        for (int i=0; i<N; i++) {
            A[i] = sc.nextInt();
        }
        Arrays.sort(A);

        int M = sc.nextInt();
        for (int i=0; i<M; i++) {
            System.out.println(binarySearch(0, N-1, sc.nextInt()));
        }
    }
}

• 재귀호출 대신 while 조건문을 사용하여 가독성이 좋아진 듯하다.
• 성능 면에서는 차이가 크게 없을 것으로 보임

Arrays.sort를 사용하면 무조건 비효율적일 것이다 생각했는데,

오히려 contains메서드를 사용한 코드가 더 비효율적일 수 있다는 것을 깨달았던 문제이다.

자바에서 필드와 생성자는 모두 클래스의 구성 요소들이다.

클래스의 구성요소는 필드, 메소드, 생성자.

필드

• 객체의 고유 데이터, 속성, 객체의 현재 상태 데이터를 저장
• 변수 선언과 비슷하게 생김
• 클래스 필드와 인스턴스 필드로 나뉜다.
    - 클래스 필드 : 모든 객체가 공유하는 변수, 프로그램 종료 시 소멸
    - 인스턴스 필드 : 객체마다 별도로 가지는 변수, 인스턴스

public class Person {
    // 인스턴스 필드
    private String name;
    private int age;
    
    // 클래스 필드
    private static int population = 0;
}

생성자

• 객체 생성 시에만 호출하는 특수한 메서드
• new 연산자가 객체 생성자를 이용해 객체를 생성
• 클래스의 이름과 동일
• 반환형 없음

public class Person {
    private String name;
    private int age;
    
    // 기본 생성자
    public Person1() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 매개변수가 있는 생성자
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 메서드
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public static void main(String[] args) {
        // 기본 생성자를 사용하여 객체 생성
        Person person1 = new Person();
        System.out.println(person1.getName()); // 출력: Unknown
        System.out.println(person1.getAge());  // 출력: 0

        // 매개변수가 있는 생성자를 사용하여 객체 생성
        Person person2 = new Person("Alice", 30);
        System.out.println(person2.getName()); // 출력: Alice
        System.out.println(person2.getAge());  // 출력: 30

생성자 오버로딩

생성자는 같은 이름으로 여러 개를 생성할 수 있어 유연성 높임

받는 매개변수의 수를 조절해서 사용

public class Person {
    private String name;
    private int age;
    
    // 기본 생성자
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 매개변수가 1개인 생성자
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }

    // 매개변수가 2개인 생성자
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 메서드
    public String getName() {
        return name;
    }

    public static void main(String[] args) {
        // 각 생성자를 사용해 객체 생성
        Person person1 = new Person();
        Person person2 = new Person("Park");
        Person person3 = new Person("Lee", 20);

        System.out.println(person1.getName());    // 출력 : Unknown
        System.out.println(person2.getName());    // 출력 : Park
        System.out.println(person3.getName());    // 출력 : Lee
    }
}

[백준] 9012번 괄호

https://www.acmicpc.net/problem/9012

문제

괄호 문자열(Parenthesis String, PS)은 두 개의 괄호 기호인 ‘(’ 와 ‘)’ 만으로 구성되어 있는 문자열이다. 그 중에서 괄호의 모양이 바르게 구성된 문자열을 올바른 괄호 문자열(Valid PS, VPS)이라고 부른다. 한 쌍의 괄호 기호로 된 “( )” 문자열은 기본 VPS 이라고 부른다. 만일 x 가 VPS 라면 이것을 하나의 괄호에 넣은 새로운 문자열 “(x)”도 VPS 가 된다. 그리고 두 VPS x 와 y를 접합(concatenation)시킨 새로운 문자열 xy도 VPS 가 된다. 예를 들어 “(())()”와 “((()))” 는 VPS 이지만 “(()(”, “(())()))” , 그리고 “(()” 는 모두 VPS 가 아닌 문자열이다. 

여러분은 입력으로 주어진 괄호 문자열이 VPS 인지 아닌지를 판단해서 그 결과를 YES 와 NO 로 나타내어야 한다. 

입력 :

입력 데이터는 표준 입력을 사용한다. 입력은 T개의 테스트 데이터로 주어진다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터의 첫째 줄에는 괄호 문자열이 한 줄에 주어진다. 하나의 괄호 문자열의 길이는 2 이상 50 이하이다. 

출력 :

출력은 표준 출력을 사용한다. 만일 입력 괄호 문자열이 올바른 괄호 문자열(VPS)이면 “YES”, 아니면 “NO”를 한 줄에 하나씩 차례대로 출력해야 한다. 

나의 답안

1. counter=0 변수 선언

2. 맨 앞글자부터 '(' 일 때 counter + 1      ')' 일 때 counter - 1 해준다.

3. counter값이 0이면 YES, 아니면 NO 출력

4. 도중에 counter값이 음수가 될 경우 반복문 종료 후 NO 출력

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
       
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());    // 입력 개수 입력

        for (int i=0; i<N; i++) {        
            String str = br.readLine(); 
            int counter = 0;
            for (int j=0; j<str.length(); j++){
                if (str.charAt(j) == '(') {
                    counter += 1;
                } else {
                    counter -= 1;
                    if (counter < 0) {
                        break;
                    }
                }
            }
            System.out.println(counter==0 ? "YES" : "NO");
        }
    }
}

삼항연산자를 사용하여 작성해봤다.

짧지만 가독성은 좋지 않다.

다른 답안

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        Stack<Character> stack = new Stack<>();

        for(int i=0; i<N; i++) {
            String str = br.readLine();
            int length = str.length();

            for(int j=0; j<length; j++) {
                char ch = str.charAt(j);

                if(ch == '(') {
                    stack.push(ch);
                }
                else {
                    int size = stack.size();
                    if(size == 0) {
                        stack.push(ch);
                        break;
                    }
                    else {
                        stack.pop();
                    }
                }
            }

            if(stack.isEmpty()) {
                System.out.println("YES");
            }
            else {
                System.out.println("NO");
            }

            stack.clear();
        }
    }
}

• stack구조를 사용해 좀 더 간단하게 구현했다.
• '(' 일 때 stack.push()를, ')'일 때 stack.pop()을 사용
• ')'일 때 stack에 요소가 없으면 반복문 빠져나와 NO 출력

stack 구조를 사용해야겠다는 생각을 하지 못했다.

stack을 사용하기에 아주 좋은 문제였던 것 같다...

다만, counter변수를 사용하는 것이  메모리 사용량이 더 적고 연산이 간단하며,

stack을 사용하는 것은  코드의 길이를 늘리고 복잡성을 증가시킬 수 있으므로 주의

[백준] 2525번 오븐 시계

https://www.acmicpc.net/problem/2525

문제

KOI 전자에서는 건강에 좋고 맛있는 훈제오리구이 요리를 간편하게 만드는 인공지능 오븐을 개발하려고 한다. 인공지능 오븐을 사용하는 방법은 적당한 양의 오리 훈제 재료를 인공지능 오븐에 넣으면 된다. 그러면 인공지능 오븐은 오븐구이가 끝나는 시간을 분 단위로 자동적으로 계산한다.

또한, KOI 전자의 인공지능 오븐 앞면에는 사용자에게 훈제오리구이 요리가 끝나는 시각을 알려 주는 디지털 시계가 있다.

훈제오리구이를 시작하는 시각과 오븐구이를 하는 데 필요한 시간이 분단위로 주어졌을 때, 오븐구이가 끝나는 시각을 계산하는 프로그램을 작성하시오.

입력 :

첫째 줄에는 현재 시각이 나온다. 현재 시각은 시 A (0 ≤ A ≤ 23) 와 분 B (0 ≤ B ≤ 59)가 정수로 빈칸을 사이에 두고 순서대로 주어진다. 두 번째 줄에는 요리하는 데 필요한 시간 C (0 ≤ C ≤ 1,000)가 분 단위로 주어진다.

출력 :

첫째 줄에 종료되는 시각의 시와 분을 공백을 사이에 두고 출력한다. (단, 시는 0부터 23까지의 정수, 분은 0부터 59까지의 정수이다. 디지털 시계는 23시 59분에서 1분이 지나면 0시 0분이 된다.)

나의 답안

분이 60분이 넘을 때, 60으로 나눈 몫만큼 '시' 부분을 높여주되,

'시' 부분이 24이상일 경우에는 0부터 표현해줘야 한다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();

        System.out.println(a+(b+c)/60 > 23 ? a+(b+c)/60-24 + " " + (b+c)%60 : a+(b+c)/60 + " " + (b+c)%60);
    }
}

삼항연산자를 사용하여 작성해봤다.

짧지만 가독성은 좋지 않다.

모범 답안

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

int A = sc.nextInt();
int B = sc.nextInt();
int C = sc.nextInt();

B += C;

A = (A + B/60)%24;
B = B%60;

System.out.println(A+" "+B);
}
}

• B에 C를 더한 값으로 B에 다시 할당함
• 나는 if문을 사용해 '시'가 24 이상일 경우 24를 빼도록 작성했지만,
  해당 답안에서는 if문 사용 없이 답을 도출할 수 있도록 작성되었다.

B에 바로 C값을 더해주는 부분과 A값을 if문 없이 표현했다는 점이 인상 깊다.

내 코드에 비해 가독성과 효율성 측면에서 더 좋은 코드라는 생각이 든다.

[백준] 2388번 곱셈

https://www.acmicpc.net/problem/2588

문제

(세 자리 수) × (세 자리 수)는 다음과 같은 과정을 통하여 이루어진다.

(1)과 (2)위치에 들어갈 세 자리 자연수가 주어질 때 (3), (4), (5), (6)위치에 들어갈 값을 구하는 프로그램을 작성하라

입력 :

첫째 줄에 (1)의 위치에 들어갈 세 자리 자연수가, 둘째 줄에 (2)의 위치에 들어갈 세자리 자연수가 주어진다.

출력 :

첫째 줄부터 넷째 줄까지 차례대로 (3), (4), (5), (6)에 들어갈 값을 출력한다.

나의 답안

일단 (6)은 그냥 A*B 해주면 되고..

100의 자리 수는 100으로 나눠주면 몫이 그것이고,

1의 자리는 A를 10으로 나눈 나머지로 하면 되겠네? 생각했다.

그리고 10의 자리가 조금 고민이었다.

그러다 결국 10으로 나누면, 100의 자리와 10의 자리만 남을 것이고, 거기에 10을 나눈 나머지가

10의 자리 수가 되겠다는 생각을 하고 코드를 작성했다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int A = sc.nextInt();
        int B = sc.nextInt();


        System.out.println(A*(B%10));
        System.out.println(A*((B/10)%10));
        System.out.println(A*(B/100));
        System.out.println(A*B);
    }
}

모범 답안

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
         int a = sc.nextInt();
         int b = sc.nextInt();

         int c = (b % 10) * a;
         int d = ((b % 100) / 10) * a;
         int e = (b / 100) * a;
         System.out.println(c);
         System.out.println(d);
         System.out.println(e);
         System.out.println(a * b);
    }
}

• 1의 자리 수와 100의 자리는 내 답안과 동일.
• 10의 자리는 100을 나눈 나머지에 10을 나눈 몫으로 추출

[프로그래머스] 도둑

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

문제

도둑이 어느 마을을 털 계획을 하고 있습니다. 이 마을의 모든 집들은 동그란 형태로 배치되어 있다.

각 집들은 서로 인접한 집들과 방범장치가 연결되어 있어 인접한 두 집을 연속으로 털면 경보가 울린다.

각 집에 있는 돈이 담긴 배열 money가 주어질 때, 도둑이 훔칠 수 있는 돈의 최댓값을 return 하는 메서드를 작성하라.

나의 답안

몇 시간을 헤맨 끝에 겨우 풀었다.

아래 코드들처럼 이것저것 시도해 보았으나 테스트케이스 및 효율성 검사에서 탈락.

첫 번째 코드(오답)

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        int[] dp = new int[money.length];

        dp[0] = money[0];
        dp[1] = Math.max(money[0], money[1]);

        for (int i=2; i<money.length; i++) {
            dp[i] = Math.max(money[i]+dp[i-2], dp[i-1]);
        }

        int answer = dp[dp.length-1];
        return answer;
    }
}

• n번째 집을 터는 경우와 털지 않는 경우 둘로 나누어 더 큰 값을 dp(n)의 값으로 결정하는 방법.
  집이 원형으로 배치되어 있다는 것을 망각하고 풀었다.
  따라서 맨 앞의 값과 뒤의 값을 둘 다 터는 경우가 발생하므로 오답이다.

두 번째 코드(오답)

class Solution {
    public int solution(int[] money) {
        int evenSum = 0, oddSum = 0;
        for (int i = 0; i < money.length; i++) {
            if (i % 2 == 0) {
                evenSum += money[i];
                System.out.println("evenSum :"+evenSum);
            } else {
                oddSum += money[i];
                System.out.println("oddSum :"+oddSum);
            }
        }

        if (money.length % 2 == 1) {
            evenSum -= Math.min(money[0], money[money.length - 1]);
        }

        return Math.max(evenSum, oddSum);
}

• 한 칸 건너뛰면서 더하는 거니까, 홀수 인덱스 값들의 합과 짝수 인덱스 값들의 합을 비교하면 되겠네? 생각하고 작성.
  꼭 한 칸씩만 건너뛰면서 더해야 최대가 되는 것은 아니다. 예를 들어,
  [1000, 1, 1, 1000, 2] 의 경우 2000이 최댓값이지만, 위의 코드대로 수행하면 1003이 반환될 것이다.

세 번째 코드(오답)

class Solution {
    public int solution(int[] money) {
        int[] dp1 = new int[money.length];
        int[] dp2 = new int[money.length];

        dp1[0] = money[0];
        dp1[1] = Math.max(money[0], money[1]);
        dp2[money.length-1] = money [money.length-1];
        dp2[money.length-2] = Math.max(money[0], money[1]);

        int idx2 = money.length-3;
        for (int i=2; i<money.length-1; i++) {
            dp1[i] = Math.max(money[i]+dp![i-2], dp1[i-1]);
            dp2[idx2] = Math.max(money[idx2]+dp2[idx_r+2], dp2[idx_r+1]);
            
            idx2--;
        }

        return Math.max(dp1[money.length-2], dp2[1]);
}

• 맨 앞과 뒤를 연속해서 털지 않도록  dp1과 dp2로 나누어
  dp1은 앞에서부터 n-1번째 값까지, dp2는 n번째 값부터 2번째 값까지 최댓값을 구하는 코드를 작성했다.
  이건 사실 왜 오답인지 아직도 모르겠다. 예외 케이스가 무엇인지 알려주실 선배님들 부탁드립니다..

모범 답안

1. 원형으로 되어있으므로 맨 앞집을 터는 경우와 털지 않는 경우로 나누어 dp1, dp2로 각각 분류
2. dp1에서는 맨 앞집부터 맨 끝집 직전 집까지 털 경우의 최대값을 구함
3. dp2에서는 두 번째 집부터 맨 끝집까지 털 경우의 최대값을 구함
4. dp1, dp2 중 최대값을 반환

class Solution {
    public int solution(int[] money) {
        int[] dp1 = new int[money.length];
        int[] dp2 = new int[money.length];

        dp1[0] = money[0];
        dp1[1] = Math.max(money[0], money[1]);
        dp2[0] = money[1];
        dp2[1] = Math.max(money[1], money[2]);

        for (int i = 2; i < money.length - 1; i++) {
            dp1[i] = Math.max(money[i] + dp1[i - 2], dp1[i - 1]);
            dp2[i] = Math.max(money[i+1] + dp2[i - 2], dp2[i - 1]);
        }

        return Math.max(dp1[money.length - 2], dp2[money.length - 2]);
    }
}

저녁시간 내내 이것만 고민하다가 끝났지만, 어느 정도 모범답안에 가까운 답을 도출해서 아주 뿌듯했다..

점점 발전하고 있는 것이 보인다!

[프로그래머스] 배열 조각하기

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

문제

정수 배열 arr와 query가 주어지며, query를 순회하면서 다음 작업을 반복한다.

• 짝수 인덱스에서는 arr에서 query[i]번 인덱스를 제외하고 배열의 query[i]번 인덱스 뒷부분을 잘라서 버림
• 홀수 인덱스에서는 arr에서 query[i]번 인덱스는 제외하고 배열의 query[i]번 인덱스 앞부분을 잘라서 버림

위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성하라

나의 답안

나는 문제에서 말하는 알고리즘대로 remove 메서드를 이용하여

짝수 인덱스에서는 뒷부분을 자르고,

홀수 인덱스에서는 앞부분을 잘라내고

배열로 변환하도록 코드를 작성했다.

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        ArrayList <Integer> list = new ArrayList<>();

        for(int i=0; i<arr.length; i++)
            list.add(arr[i]);

        for(int i=0; i<query.length; i++) {
            if(i%2 == 0) {
                int size = list.size() - query[i]-1;
                for(int j=0; j<size; j++)
                    list.remove(query[i]+1);
            }
            else {
                for(int j=0; j<query[i]; j++)
                    list.remove(0);
            }
        }

        int[] answer = new int [list.size()];
        for(int i=0; i<list.size(); i++)
            answer[i] = list.get(i);
        return answer;
    }
}

모범 답안

1. 실제로 배열 내 값을 제거하는 과정을 생략
2. start, end 변수를 이용하여 최종적으로 불러올 인덱스 범위를 조절
3. copyOfRange변수를 사용하여 변수 불러옴

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        int start = 0;
        int end = arr.length - 1;
        for (int i = 0; i < query.length; i++) {
            if (i % 2 == 0) {
                end = start + query[i] - 1;
            } else {
                start += query[i];
            }
        }

        return Arrays.copyOfRange(arr, start, end + 2);
    }
}

시작점과 끝점만 조정해가며 값을 불러올 수 있다는 생각을 못했다.

순진하게(?) 문제에서 얘기하는 대로 코드를 짰는데,

훨씬 효율적인 처리가 가능한 방법이 있었다.

더 효율적인 방법이 있다는 것을 항상 생각하자!

복습

Arrays.copyOfRange(arr, 시작인덱스, 끝인덱스):

arr배열의 시작인덱스부터 끝인덱스(미포함)의 앞까지 복사하여 반환

배열(Arrays 클래스) 주요 메서드

• toString(배열) : 배열을 문자열로 변한
  
      int[] arr = {1, 2, 3, 4, 5};
      String arrString = Arrays.toString(arr);
      System.out.println(arrString); // 출력: [1, 2, 3, 4, 5]
  
  
  
• sort(배열) : 해당 배열을 오름차순 정렬
  
       int[] arr = {3, 1, 4, 2, 5};
       Arrays.sort(arr);
       System.out.println(Arrays.toString(arr)); // 출력: [1, 2, 3, 4, 5]
  
  
  
• copyOf(배열, 길이): 배열을 0번째 인덱스부터 지정된 길이만큼 복사하여 반환
  
       int[] arr = {1, 2, 3, 4, 5};
       int[] copyArr = Arrays.copyOf(arr, 3);
       System.out.println(Arrays.toString(copyArr)); // 출력: [1, 2, 3]
  
  
• copyOfRange(배열, 시작인덱스, 끝인덱스): 배열의 시작인덱스부터 끝인덱스(미포함)를 복사하여 반환
  
       int[] arr = {1, 2, 3, 4, 5};
       int[] copyArr = Arrays.copyOfRange(arr, 2, 5);
       System.out.println(Arrays.toString(copyArr)); // 출력: [3, 4, 5]
  
  
  
• equals(): 두 배열의 길이와 요소가 모두 같은 경우에만 true 반환
  
       int[] arr1 = {1, 2, 3};
       int[] arr2 = {1, 2, 3};
       boolean isEqual = Arrays.equals(arr1, arr2);
       System.out.println("Arrays are equal: " + isEqual); // 출력: Arrays are equal: true
  
  
  
• deepEquals(): 다차원 배열에서 두 요소가 모두 동일한 경우에만 ture 반환
  
       int[][] arr1 = {{1, 2}, {3, 4}};
       int[][] arr2 = {{1, 2}, {3, 4}};
       boolean isEqual = Arrays.deepEquals(arr1, arr2);
       System.out.println("Arrays are equal: " + isEqual); // 출력: Arrays are equal: true

배열 ▶ 리스트

⊙ Arrays.asList() 사용

import java.util.Arrays;
import java.util.List;

public class ArrayToListExample {
    public static void main(String[] args) {
        // 배열 정의
        Integer[] myArray = {1, 2, 3, 4, 5};

        // 리스트로 변환
        List<Integer> myList = Arrays.asList(myArray);

        System.out.println(myList);  // 출력: [1, 2, 3, 4, 5]
    }
}

⊙ int[] 배열을 Integer리스트로 변환할 경우 type이 맞지 않아 원하는 변환을 할 수 없다.

    이 경우에는 반복문을 통해 일일이 값을 넣어주거나 Stream을 사용해야 한다.

    1) 반복문 사용

        // int 배열 정의
        int[] intArray = {1, 2, 3, 4, 5};

        // Integer 리스트로 변환
        List integerList = new ArrayList<>();
        for (int num : intArray) {
            integerList.add(num);  // 박싱(boxing)
        }

        System.out.println(integerList);  // 출력: [1, 2, 3, 4, 5]

    2) Stream 사용

        // int 배열 정의
        int[] intArray = {1, 2, 3, 4, 5};

        // Integer 리스트로 변환
        List<Integer> integerList = Arrays.stream(intArray)  // int 배열을 스트림으로 변환
                                          .boxed()          // int를 Integer로 박싱(boxing)
                                          .collect(Collectors.toList());  // 리스트로 수집

        System.out.println(integerList);  // 출력: [1, 2, 3, 4, 5]

리스트 ▶ 배열

⊙ toArray() 사용

       // 리스트 정의
        List<Integer> myList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

        // 배열로 변환
        Integer[] myArray = myList.toArray(new Integer[0]);

        for (Integer num : myArray) {
            System.print(num + " ");  // 출력: 1 2 3 4 5
        }

StringBuilder 특징

• 변수 선언 시 객체를 생성하며, 문자열을 자주 수정할 때 사용
• String과 다르게 가변적인 속성을 가져 문자열 수정이 빠르고 효율적임
• 단, 멀티스레드 환경에서는 안전하지 않음
• 크기를 지정하지 않고 객체 생성 시 초기 용량은 16으로 설정됨

        String str = "";
        StringBuilder sb = new StringBuilder();

        str = str + "a";
        str = str + "b";
        str = str + "c";    // String은 불변 : 문자열 수정할 때마다 새로운 문자열 객체 생성 >> 메모리 부담

        sb.append("a");
        sb.append("b");
        sb.append("c");    // StringBuilder은 가변 : 문자열 수정 시 기존 객체를 수정 >> 메모리 사용 효율적

StringBuilder 주요 메서드

• append(문자열) : 문자열 추가
  
       StringBuilder sb = new StringBuilder();
       sb.append("Hello");
       sb.append(" ");
       sb.append("world");
       String result = sb.toString();      // result = "Hello world"
  
  
  
• insert(인덱스, 문자열) :지정한 위치에 문자열 삽입
  
       StringBuilder sb = new StringBuilder("Hello");
       sb.insert(5, " world");       // " world"를 인덱스 5에 삽입
       String result = sb.toString(); // result = "Hello world"
  
  
  
• deleteCharAt(인덱스): 지정된 인덱스의 문자 삭제
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.deleteCharAt(5);       // ' ' 문자 삭제
       String result = sb.toString();      // result = "Helloworld"
  
  
  
• replace(시작인덱스, 끝인덱스, 문자열): 시작위치부터 끝 이전까지의 문자열을 대체
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.replace(6, 11, "Java");       // 인덱스 6부터 11 이전까지의 문자열을 "Java"로 대체
       String result = sb.toString();      // result = "Hello Java"
  
  
  
• reverse(): 문자열을 역순으로 뒤집음
  
       StringBuilder sb = new StringBuilder("Hello");
       sb.reverse();      // 문자열을 역순으로 변경
       String result = sb.toString();       // result = "olleH"
  
  
  
• length(): 현재 StringBuilder의 길이를 반환
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.replace(6, 11, "Java");      // 인덱스 6부터 11 이전까지의 문자열을 "Java"로 대체
       String result = sb.toString();      // result = "Hello Java"
  
  
  
• indexOf(문자열): 지정된 문자열이 처음으로 등장하는 인덱스 반환
  
       StringBuilder sb = new StringBuilder("Hello world");
       int index = sb.indexOf("world");       // index = 6