[JAVA] 자바 코딩 테스트 문법 정리

 

 

 

코테 풀 때마다 계속 까먹어서 이번 기회에 정리하고자 합니다. 

 

 

0. import

 

자바에서 기본적으로 많이 사용하는 패키지. 미리 선언해두고 들어가면 편합니다. 

import java.io.*;    // 입출력 관련 (BufferedReader, InputStream 등)
import java.util.*;  // 컬렉션, Scanner, Arrays, List, Map, Set 등

 

 

 

1. String

String str = "hello";

// 길이
str.length();             // 5

// 특정 문자
str.charAt(1);            // 'e'

// 부분 문자열
str.substring(1, 4);      // "ell"

// 찾기
str.indexOf("l");         // 2 (첫 번째 l 위치)
str.contains("he");       // true

// 문자 배열 변환 
str.toCharArray();         // {'h', 'e', 'l', 'l', 'o'} (char[] 배열로 변환)

// 대소문자 변환
str.toUpperCase();        // "HELLO"
str.toLowerCase();        // "hello"

// 분리 & 합치기
String[] arr = str.split("");  // {"h","e","l","l","o"}
String joined = String.join("-", arr); // "h-e-l-l-o"


// 문자열 비교 (문자열 비교는 ==으로 하면 안됨)
str.equals("값");               // 값 비교
str.equalsIgnoreCase("HELLO");  // 대소문자 무시 비교
str.compareTo("hello");         // 0 (같음)
str.compareTo("world");         // 음수 / 양수 (사전순 비교)

// 문자열 치환
str.replace("l", "x");           // "hexxo"
str.replaceFirst("l", "X");      // "heXlo"
str.replaceAll("[aeiou]", "*");  // 정규식 사용 → "h*ll*"

// 문자열 시작 / 끝 검사
str.startsWith("he");            // true
str.endsWith("lo");              // true

// 빈 문자열 체크
str.isEmpty();                   // false (길이 == 0)

// 문자열 반복 (Java 11+)
"ab".repeat(3);                  // "ababab"


// 문자 ↔ 아스키(유니코드)
char c = 'a';
int code = c;                    // 97
char next = (char)(c + 1);       // 'b'


// 문자열 포맷팅
String fmt = String.format("이름:%s 나이:%d", "철수", 20);
// "이름:철수 나이:20"


// 문자열 → 숫자 변환
Integer.parseInt("123");         // 123
Long.parseLong("123");           // 123L
Double.parseDouble("3.14");      // 3.14
Integer.parseInt("1010", 2);     // 10 (2진수 → 10진수)


// 문자열 정렬
char[] chArr = str.toCharArray();
Arrays.sort(chArr);
String sorted = new String(chArr); // "ehllo"


//문자열 변환
str.toString();           
// 자기 자신("hello")을 그대로 반환
// (String 객체라면 의미 없음, 다른 객체에서 주로 사용)

String.valueOf(123);      
// "123" (int → String)
String.valueOf(true);     
// "true" (boolean → String)
String.valueOf(str);      
// "hello" (String 그대로 반환)
String.valueOf(null);     
// "null" (toString()은 NullPointerException 터지지만 valueOf는 안전)


// StringBuilder (문자열 문제 핵심)
StringBuilder sb = new StringBuilder("abc");
sb.append("d");                  // "abcd"
sb.insert(1, "X");               // "aXbcd"
sb.delete(1, 3);                 // "acd"
sb.reverse();                    // "dca"
sb.setCharAt(0, 'Z');            // "Zca"
sb.length();                     // 길이

 

 

 

2. Array (배열)

 

import java.util.Arrays;

int[] arr = {5, 2, 9, 1};

// 길이
arr.length;              // 4

// 정렬
Arrays.sort(arr);        // {1,2,5,9}

// 문자열 변환
Arrays.toString(arr);    // "[1, 2, 5, 9]"

// 채우기
Arrays.fill(arr, 7);     // {7,7,7,7}

// 복사
int[] arr2 = Arrays.copyOf(arr, 2); // {7,7}


// 부분 복사 (범위 복사)
int[] sub = Arrays.copyOfRange(arr, 1, 3);
// index 1 ~ 2까지 복사 (end 미포함)

// 배열 비교
Arrays.equals(arr, arr2);   // true / false

// 배열 전체 같은 값인지 확인할 때 많이 씀


// 배열 깊은 비교 (2차원 이상)
int[][] a = {{1,2},{3,4}};
int[][] b = {{1,2},{3,4}};
Arrays.deepEquals(a, b);    // true

// 2차원 배열 출력
Arrays.deepToString(a);     // "[[1, 2], [3, 4]]"


// 배열에서 값 찾기 (이진 탐색)
// ⚠ 정렬된 배열에서만 가능
Arrays.sort(arr);
int idx = Arrays.binarySearch(arr, 9); // index 반환
int idx2 = Arrays.binarySearch(arr, 100); // 없으면 음수 반환


// 배열을 리스트로 변환 (Integer 배열만 가능)
Integer[] nums = {1, 2, 3};
Arrays.asList(nums);        // List<Integer>


// 배열 스트림 변환 (합, 최대값 구하기 가능)
int sum = Arrays.stream(arr).sum();         // 합
int max = Arrays.stream(arr).max().getAsInt(); // 최대
int min = Arrays.stream(arr).min().getAsInt(); // 최소


// 배열 출력 반복 (디버깅용)
for (int x : arr) {
    System.out.print(x + " ");
}


// 배열 뒤집기 (직접 구현 필요)
for(int i = 0; i < arr.length / 2; i++){
    int temp = arr[i];
    arr[i] = arr[arr.length - 1 - i];
    arr[arr.length - 1 - i] = temp;
}


// 배열에 값 추가하기 (새 배열 생성 필요)
int[] newArr = new int[arr.length + 1];
for(int i=0;i<arr.length;i++){
    newArr[i] = arr[i];
}
newArr[arr.length] = 10;   // 마지막에 추가


// 배열에서 특정 조건 필터링 (stream 활용)
int[] evenArr = Arrays.stream(arr)
                      .filter(x -> x % 2 == 0)
                      .toArray();


// 배열 합치기 (stream 활용)
int[] arrA = {1,2};
int[] arrB = {3,4};

int[] merged = Arrays.stream(
                    new int[][]{arrA, arrB})
                    .flatMapToInt(Arrays::stream)
                    .toArray();
// {1,2,3,4}


// 배열 값 변경 (map 활용)
int[] doubled = Arrays.stream(arr)
                      .map(x -> x * 2)
                      .toArray();


// 배열 초기화 (2차원 배열)
int[][] board = new int[3][4];
for(int i=0;i<3;i++){
    Arrays.fill(board[i], 1);
}
// 모든 값을 1로 초기화

 

 

 

3. List / ArrayList

 

// 1. 선언
ArrayList<String> list = new ArrayList<>();

// 2. 삽입
list.add("java");         // {"java"}
list.add(0, "ryu");       // {"ryu", "java"}

// 3. 수정
list.set(1, "c++");       // {"ryu", "c++"}

// 4. 삭제
list.remove(1);           // {"ryu"}

// 5. 값 존재 유무
list.contains("java");    // false
list.indexOf("ryu");      // 0

// 6. 순회 (Iterator)
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

 

 

 

4. Collections

 

ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(5, 1, 4, 2));

// 정렬
Collections.sort(nums);      // {1,2,4,5}

// 역순 정렬
Collections.sort(nums, Collections.reverseOrder()); // {5,4,2,1}

// 최대/최소
Collections.max(nums);       // 5
Collections.min(nums);       // 1

// 이진 탐색 (정렬된 상태 필요)
Collections.sort(nums);      // {1,2,4,5}
Collections.binarySearch(nums, 4); // 2

 

 

 

 

5. Stack

 

Stack<Integer> stack = new Stack<>();

stack.push(10);   // {10}
stack.push(20);   // {10,20}
stack.pop();      // 20 제거, {10}
stack.peek();     // 10 (맨 위 확인)
stack.isEmpty();  // false

 

 

6. Queue (LinkedList 사용)

 

Queue<String> q = new LinkedList<>();

q.add("A");
q.add("B");
q.offer("C");      // 추가

q.poll();          // "A" 꺼내고 제거
q.peek();          // "B" (맨 앞 원소 확인)
q.isEmpty();       // false

 

7. HashMap

 

 

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

map.put("apple", 3);
map.put("banana", 5);
map.put("apple", 7);   // Key 중복 시 Value 덮어씀

map.get("apple");      // 7
map.containsKey("banana"); // true
map.containsValue(5);  // true
map.remove("banana");  // {"apple"=7}

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

 

 

 

 

8. HashSet

 

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

set.add("A");
set.add("B");
set.add("A");      // 중복 저장 X

set.contains("A"); // true
set.remove("B");   // {"A"}

// 순회
for (String s : set) {
    System.out.println(s);
}

 

 

 

 

9. Math

 

Math.PI      // 3.141592653589793
Math.E       // 2.718281828459045


Math.abs(-10);     // 10
Math.abs(3.14);    // 3.14
Math.max(5, 10);   // 10
Math.min(5, 10);   // 5
Math.ceil(3.14);   // 4.0 (올림)
Math.floor(3.99);  // 3.0 (내림)
Math.round(3.5);   // 4   (반올림, long 리턴)
Math.round(3.49);  // 3
Math.pow(2, 3);    // 8.0 (2의 3제곱)
Math.sqrt(16);     // 4.0 (제곱근)
Math.random();     // 0.0 이상 1.0 미만의 double 난수
// 예: 1~10 랜덤 정수
int r = (int)(Math.random() * 10) + 1;
Math.random();     // 0.0 이상 1.0 미만의 double 난수
// 예: 1~10 랜덤 정수
int r = (int)(Math.random() * 10) + 1;
Math.log(Math.E);    // 1.0 (자연로그)
Math.log10(100);     // 2.0 (밑 10 로그)
Math.exp(1);         // e^1 = 2.718...

 

 

 

 

---

 

 

Collection 관련 정리 

 

 

 

Collection 인터페이스는 List, Set, Queue로 크게 3가지 상위 인터페이스로 분류할 수 있다. Map의 경우 Collection 인터페이스를 상속받고 있지 않지만 Collection으로 분류된다

 

 

 ⭐ 1. Collection 인터페이스의 특징

인터페이스	구현	클래스
Set	HashSet TreeSet	순서를 유지하지 않는 데이터의 집합으로, 데이터의 중복을 허용하지 않는다.
List	ArrayList LinkedList Vector Stack	순서가 있는 데이터의 집합으로, 데이터의 중복을 허용한다.
Queue	LinkedList PriorityQueue	List와 유사
Map	Hashtable HashMap TreeMap	키(Key), 값(Value)의 쌍으로 이루어진 데이터의 집합. 순서는 유지되지 않으며 Key는 중복 불가, Value는 중복 허용.

 

 

 

 ⭐ 2. Collection 인터페이스 주요 메소드

 

int size()	컬렉션에 포함된 원소(요소)의 개수를 반환
boolean isEmpty()	컬렉션이 비어 있는지 확인
boolean contains(Object o)	특정 원소가 컬렉션에 포함되어 있는지 확인
Iterator<E> iterator()	컬렉션을 순회할 수 있는 Iterator 객체 반환
boolean add(E e)	원소를 컬렉션에 추가 (성공 시 true 반환)
boolean remove(Object o)	특정 원소를 컬렉션에서 제거
void clear()	컬렉션의 모든 원소 제거
Object[] toArray()	컬렉션을 배열로 변환
<T> T[] toArray(T[] a)	지정된 타입의 배열로 컬렉션을 변환
boolean containsAll(Collection<?> c)	주어진 컬렉션의 모든 원소가 포함되어 있는지 확인
boolean addAll(Collection<? extends E> c)	주어진 컬렉션의 모든 원소를 추가
boolean removeAll(Collection<?> c)	주어진 컬렉션의 모든 원소 제거
boolean retainAll(Collection<?> c)	주어진 컬렉션에 있는 원소만 남기고 나머지는 제거

 

*E는 컬렉션에 들어 있는 요소의 타입

 

 

 

 

 

 ⭐  3. Iterator 인터페이스 주요 메소드

 

boolean hasNext()	다음 원소가 있는지 확인
E next()	다음 원소 반환 (커서 이동)
void remove()	마지막으로 반환된 원소 제거

 

 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // ArrayList는 Collection 인터페이스를 구현한 클래스
        Collection<String> list = new ArrayList<>();

        // 1. add() : 요소 추가
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 2. size(), isEmpty()
        System.out.println("크기: " + list.size());        // 3
        System.out.println("비었는가? " + list.isEmpty()); // false

        // 3. contains()
        System.out.println("Banana 포함? " + list.contains("Banana")); // true

        // 4. toArray()
        Object[] arr = list.toArray();
        System.out.println("배열[0]: " + arr[0]); // Apple

        // 5. remove()
        list.remove("Banana");
        System.out.println("Banana 제거 후: " + list);

        // 6. iterator() 사용
        Iterator<String> it = list.iterator();
        System.out.print("Iterator 순회: ");
        while (it.hasNext()) {
            String fruit = it.next();
            System.out.print(fruit + " ");
        }
        System.out.println();

        // 7. clear()
        list.clear();
        System.out.println("모두 삭제 후 크기: " + list.size()); // 0
    }
}