자료형

1-0. 기본 골격 (공통 유틸 클래스)

import java.math.BigDecimal;
import java.util.*;
import java.util.regex.Pattern;

public final class CoreTypesAndCollections {

    private CoreTypesAndCollections() { }

1-A. String 템플릿 (파싱 · 검증 · 포맷팅)

1️⃣ split + trim 파싱 (가장 많이 씀)

public static List<String> splitByComma(String input) {
    validateNotBlank(input, "입력은 비어 있을 수 없습니다.");

    String[] parts = input.split(",");
    List<String> result = new ArrayList<>();

    for (String p : parts) {
        String token = p.trim();
        validateNotBlank(token, "빈 값이 포함될 수 없습니다.");
        result.add(token);
    }
    return result;
}

사용 예

// "a, b, c" → ["a", "b", "c"]
List<String> tokens = splitByComma(input);

2️⃣ String 기본 API 체크리스트

public static void stringBasicsDemo(String s) {
    validateNotNull(s, "문자열 null 불가");

    String trimmed = s.trim();
    int length = trimmed.length();

    char first = trimmed.charAt(0);
    String sub = trimmed.substring(0, 2);

    boolean has = trimmed.contains("abc");
    boolean starts = trimmed.startsWith("[");
    String replaced = trimmed.replace(" ", "");

    // 정규식 치환
    String onlyDigits = trimmed.replaceAll("\\D", "");
}

3️⃣ replace vs replaceAll

public static String normalizeSpaces(String s) {
    validateNotNull(s, "문자열 null 불가");
    return s.trim().replaceAll("\\s+", " ");
}

4️⃣ join (컬렉션 → 문자열)

public static String joinWithComma(List<String> items) {
    return String.join(",", items);
}

5️⃣ 출력 메시지 포맷

public static String formatScore(String name, int score) {
    return String.format("이름=%s, 점수=%d", name, score);
}

6️⃣ 문자열 검증 템플릿 (프리코스 필수)

public static void validateNotNull(Object obj, String message) {
    if (obj == null) {
        throw new IllegalArgumentException(message);
    }
}

public static void validateNotBlank(String s, String message) {
    if (s == null || s.trim().isEmpty()) {
        throw new IllegalArgumentException(message);
    }
}

7️⃣ 정수 문자열 검증

private static final Pattern NUMERIC_PATTERN =
        Pattern.compile("^-?\\d+$");

public static void validateIntegerString(String s, String message) {
    validateNotBlank(s, message);
    if (!NUMERIC_PATTERN.matcher(s.trim()).matches()) {
        throw new IllegalArgumentException(message);
    }
}

1-B. 기본형 · 래퍼 · 숫자 템플릿

1️⃣ 파싱

public static int parseIntStrict(String s) {
    validateIntegerString(s, "정수가 아닙니다.");
    return Integer.parseInt(s.trim());
}

public static long parseLongStrict(String s) {
    validateIntegerString(s, "정수가 아닙니다.");
    return Long.parseLong(s.trim());
}

2️⃣ 문자열 변환

String.valueOf(10);

3️⃣ Math 유틸

public static int clamp(int value, int min, int max) {
    return Math.max(min, Math.min(max, value));
}

public static int absDiff(int a, int b) {
    return Math.abs(a - b);
}

4️⃣ BigDecimal (돈 / 정확한 소수)

public static BigDecimal addMoney(String a, String b) {
    BigDecimal x = new BigDecimal(a.trim());
    BigDecimal y = new BigDecimal(b.trim());
    return x.add(y);
}

1-C. 컬렉션 템플릿

1️⃣ List / ArrayList

List<String> list = new ArrayList<>();
list.add("A");
list.contains("A");
list.remove("A");
list.get(0);
list.size();

2️⃣ Set / HashSet (중복 제거)

Set<Integer> set = new HashSet<>();
set.add(1);
set.contains(1);
set.remove(1);

3️⃣ Map / HashMap

Map<String, Integer> map = new HashMap<>();
map.put("apple", 3);
map.get("apple");
map.containsKey("apple");

for (Map.Entry<String, Integer> e : map.entrySet()) {
    e.getKey();
    e.getValue();
}

4️⃣ LinkedHashMap (입력 순서 유지)

Map<String, Integer> ordered = new LinkedHashMap<>();

5️⃣ EnumMap (enum 키 전용)

enum Grade { BRONZE, SILVER, GOLD }

EnumMap<Grade, Integer> map = new EnumMap<>(Grade.class);
map.put(Grade.BRONZE, 10);

6️⃣ Map 카운팅 패턴 (빈출)

public static Map<String, Integer> count(List<String> items) {
    Map<String, Integer> freq = new HashMap<>();
    for (String s : items) {
        freq.put(s, freq.getOrDefault(s, 0) + 1);
    }
    return freq;
}

1-D. 일급 컬렉션 템플릿

예시: 이름 목록 일급 컬렉션

public final class Names {
    private final List<String> values;

    private Names(List<String> values) {
        this.values = List.copyOf(values);
    }

    public static Names from(List<String> raw) {
        validateNoBlank(raw);
        validateNoDuplicate(raw);
        return new Names(raw);
    }

    public boolean contains(String name) {
        return values.contains(name);
    }

    public int size() {
        return values.size();
    }

    public Names add(String name) {
        if (values.contains(name)) {
            throw new IllegalArgumentException("중복 이름");
        }
        List<String> next = new ArrayList<>(values);
        next.add(name);
        return new Names(next);
    }

    private static void validateNoBlank(List<String> list) {
        for (String s : list) {
            if (s == null || s.trim().isEmpty()) {
                throw new IllegalArgumentException("빈 이름");
            }
        }
    }

    private static void validateNoDuplicate(List<String> list) {
        if (new HashSet<>(list).size() != list.size()) {
            throw new IllegalArgumentException("중복 이름");
        }
    }

    @Override
    public String toString() {
        return String.join(", ", values);
    }
}