[JAVA] 기본 문법 정리

1. 문자열과 char

• String은 수정할 수 없음 → StringBuilder 사용

char ch = 'A';
String str = "Apple";

str.length(); // 5
str.charAt(2); // p
str.substring(1, 3); // pp: 1번부터 2번까지
str.contains("pp"); // true
str.toLoserCase() // apple

// 모든 문자 하나씩 확인
for (int i = 0; i < text.length(); i++) {
    char ch = text.charAt(i);
    System.out.println(ch);
}

// 문자열 내용 비교 vs 객체 비교
String a = new String("java");
String b = new String("java");

System.out.println(a.equals(b)); // true: 내용이 같음
System.out.println(a == b);      // false: 서로 다른 객체

int number = Integer.parseInt("123");
String text = String.valueOf(123); // toString대신 null값 처리 가능

2. BufferedReader

• 입력을 한 줄씩 읽는 도구

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

String line = br.readLine();

// 숫자로 변환
int age = Integer.parseInt(br.readLine());

// 전체 기본 구조
import java.io.*;

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

        int number = Integer.parseInt(br.readLine());
        System.out.println(number + 1);
    }
}

3. StringTokenizer

• 문자열을 공백 같은 구분자를 기준으로 나누는 도구
• br이 한 줄을 읽고, st가 그 줄을 나누는 형식

StringTokenizer st = new StringTokenizer("10 20 30");

int a = Integer.parseInt(st.nextToken()); // 10
int b = Integer.parseInt(st.nextToken()); // 20
int c = Integer.parseInt(st.nextToken()); // 30

// 입력: 10 20
StringTokenizer st = new StringTokenizer(br.readLine());

int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());

// 조각 개수 모를 때
while (st.hasMoreTokens()) {
    System.out.println(st.nextToken());
}

4. StringBuilder

• 문자열을 수정, 연결할 때

StringBuilder sb = new StringBuilder();

sb.append("hello");
sb.append(" ");
sb.append("java");

String result = sb.toString(); // "hello java"

// 자주 쓰는 기능
StringBuilder sb = new StringBuilder("abcd");

sb.append("e");       // "abcde"
sb.setCharAt(0, 'A');  // "Abcde"
sb.deleteCharAt(1);    // "Acde"
sb.reverse();         // "edcA"
sb.length();          // 4

// 반복문으로 한 글자씩 출력
for (int i = 1; i <= 3; i++) {
    sb.append(i).append('\n');
}

5. ArrayList

• 크기가 자동으로 늘어나는 배열 같은 자료구조
• 일반 배열은 만들 때 크기를 정함
• ArrayList는 원소를 추가하면서 크기가 늘어남

// 일반 배열
int[] arr = new int[3];

// ArrayList
ArrayList<Integer> list = new ArrayList<>();

list.add(10);
list.add(20);
list.add(30);

// 사용 가능한 메소드
list.get(0);      // 10: 조회
list.set(1, 99);  // [10, 99, 30]: 변경
list.remove(0);   // [99, 30]: 0번 원소 삭제
list.size();      // 2: 원소 개수
list.isEmpty();   // false
list.contains(99); // true

// 정수리스트 원소 삭제
list.remove(1);                  // 1번 인덱스 삭제
list.remove(Integer.valueOf(99)); // 값이 99인 첫 원소 삭제

6. HashMap

• 키와 값을 짝지어 저장하는 자료구조
• 키는 중복되지 않아서 같은 키로 다시 저장하면 값이 바뀜

HashMap<String, Integer> scores = new Hashmap<>();

scores.put("민수", 90);
scores.ut("영희", 85);

scores.get("민수"); // 90

scores.put("민수", 100);
scores.get("민수"); // 100

// 자주 쓰는 기능
scores.containsKey("민수");     // true
scores.getOrDefault("영희", 0); // 없으면 0
scores.remove("지수");          // 해당 키와 값 삭제
scores.size();                 // 저장된 쌍의 개수

// 코테에서는 등장 횟수 세기에 자주 사용
String[] fruits = {"apple", "banana", "apple"};

HashMap<String, Integer> counts = new HashMap<>();

for (String fruit : fruits) {
    counts.put(fruit, counts.getOrDefault(fruit, 0) + 1);
}

// apple → 2
// banana → 1

// 전체 순회
for (String key : counts.keySet()) {
    System.out.println(key + ": " + counts.get(key));
}

7. HashSet

• 중복 없이 값만 저장

HashSet<Integer> set = new HashSet<>();

set.add(10);
set.add(20);
set.add(10);

System.out.println(set.size()); // 2

// 10을 2번 넣어도 1번만 저장됨
set.contains(10); // true
set.remove(20);   // 20 삭제
set.isEmpty();    // false

 

이름별 점수, 단어별 개수	HashMap
중복 제거, 이미 등장했는지 확인	HashSet

8. ArrayDeque

• 앞 뒤 양쪽에서 원소를 넣고 뺄 수 있는 자료구조
• 큐: BFS 같은 탐색에서 사용
• 스택: 괄호 검사, 최근 작업 처리 등에 사용
• peek: 확인만 함
• poll/pop: 꺼내면서 삭제
• 빈 상태에서 pollFirst()는 널 반환, pop은 예외 발생

// 큐로 사용하면 먼저 들어간 것이 먼저 나옴
ArrayDeque<Integer> deque = new ArrayDeque<>();

deque.offerFirst(10); // [10]
deque.offerLast(20);  // [10, 20]
deque.offerFirst(5);  // [5, 10, 20]

deque.peekFirst();   // 5: 앞 조회
deque.peekLast();    // 20: 뒤 조회
deque.pollFirst();   // 5를 꺼내고 삭제
deque.pollLast();    // 20을 꺼내고 삭제

// 스택으로 사용하면 나중에 들어간 것이 먼저 나옴
ArrayDeque<Integer> stack = new ArrayDeque<>();

stack.push(10);
stack.push(20);

stack.pop(); // 20
stack.pop(); // 10

9. PriorityQueue

• 우선순위가 높은 원소부터 꺼냄
• 정수는 기본적으로 작은 수부터
• 큰 수부터로 바꾸고 싶으면 Comparator.reverseOrder()

PriorityQueue<Integer> pq = new PriorityQueue<>();

pq.offer(30);
pq.offer(10);
pq.offer(20);

pq.peek(); // 10: 확인만 함

pq.poll(); // 10
pq.poll(); // 20
pq.poll(); // 30

PriorityQueue<Integer> pq =
        new PriorityQueue<>(Comparator.reverseOrder());

10. sort

배열	Arrays.sort()
ArrayList 같은 리스트	Collections.sort()

// 배열 정렬
int[] arr = {30, 10, 20};

Arrays.sort(arr);
// arr: [10, 20, 30]

// 리스트 정렬
ArrayList<Integer> list = new ArrayList<>();

list.add(30);
list.add(10);
list.add(20);

Collections.sort(list);
// list: [10, 20, 30]

11. Comparator

• 정렬 기준을 직접 정하는 도구
  • 오름차순/내림차순
  • 문자열 길이 순..

Collections.sort(list, Comparator.reverseOrder()); // 내림차순

// 문자열 길이 순
String[] words = {"banana", "cat", "apple"};

Arrays.sort(
    words,
    (a, b) -> Integer.compare(a.length(), b.length())
);

// ["cat", "apple", "banana"]