(아마도 코딩테스트를 위한) Java 기초 문법 훑어보기

읽기 전에

해당 포스트는 Java 문법을 깊게 다루고 있지 않습니다! Java 언어를 완전히 처음 접하는 분들껜 크게 도움이 되지 않을 수 있습니다. 간단하게 여러 곳을 참고하면서 정리 및 추가하고 있기 때문에, 부족하거나 잘못된 정보가 있을 수 있습니다.

 

Java 자료형

원시 타입 (Primitive Type)

원시 타입은 값 자체를 저장하며, 스택 영역에 저장된다. ==을 사용해서 값을 비교할 수 있다.

정수형 - byte, short, int, long

• byte (1바이트, 8비트) : -128 ~ 127 범위
• short (2바이트, 16비트) : -32,768 ~ 32,767 범위
• int (4바이트, 32비트) : -2,147,483,648 ~ 2,147,483,647 범위
• long (8바이트, 64비트) : -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 범위
  • L 접미사를 붙여서 사용 (long num = 10000000000L;)

실수형 - float, double

• float (4바이트, 32비트) : 부동 소수점 방식, 소수점 7자리 정도의 정밀도 가짐
  • f 또는 F 접미사를 붙여서 사용 (float pi = 3.14f;)
• double (8바이트, 64비트) : 부동 소수점 방식, 소수점 15자리 정도의 정밀도 가짐
  • 자바에서 기본 실수형으로 사용 (double pi = 3.14;)

문자형 - char

• char (2바이트, 16비트) : 유니코드 문자 저장, 작은 따옴표(') 사용 ('A', '한', '\uAC00')

논리형 - boolean

• boolean (1비트) : true 또는 false 값만 저장 가능

 

참조 타입 (Reference Type)

참조 타입은 객체의 주소를 저장하는 타입으로 기본적으로 null 값을 가질 수 있다. 힙 영역에 저장된다. ==을 사용하면 주소를 비교할 수 있고, equals()를 사용하면 값을 비교할 수 있다.

클래스 (Class)

• String, Integer, ArrayList 등 사용자 정의 객체 포함

String name = "Java";

인터페이스 (Interface)

• 특정 동작을 정의하는 추상적인 타입

Runnable task = new Task();

배열 (Array)

• 같은 타입의 여러 개의 값을 저장하는 자료구조
• 초기화 방법

int[] arr = new int[5];  // {0, 0, 0, 0, 0}
double[] dArr = new double[3]; // {0.0, 0.0, 0.0}
boolean[] bArr = new boolean[2]; // {false, false}


int[] numbers = {1, 2, 3, 4, 5};
String[] strings = {"Java", "Python", "C++"};

// 메서드 내부에서 배열을 생성해서 인자로 넘길 때는 반드시 new 키워드 사용
printArray(new int[]{1, 2, 3, 4, 5});


// Stream을 이용한 초기화
import java.util.stream.IntStream;

int[] arr = IntStream.range(0, 5).toArray();  // {0, 1, 2, 3, 4}

래퍼 클래스

• 원시 타입을 객체로 감싸는 클래스로, 원시 타입을 객체로 다룰 때 사용
• Byte, Short, Integer, Long, Float, Double, Character, Boolean

 

형변환

문자(char) → 숫자

char ch = 'S';
int num = Character.getNumericValue(ch);

System.out.println(num); // 5

문자열(String) → 숫자

• Integer.parseInt(), Double.parseDouble(), Float().parseFloat() 등 사용 → 변환할 문자열이 숫자가 아닌 경우 NumberFormatException 발생

String str1 = "123";
String str2 = "45.67";
String str3 = "8.9";

int num1 = Integer.parseInt(str1);
double num2 = Double.parseDouble(str2);
float num3 = Float.parseFloat(str3);

System.out.println(num1); // 123
System.out.println(num2); // 45.67
System.out.println(num3); // 8.9

• Integer.valueOf(), Double.valueOf(), Float.valueOf() 등 사용 → 객체 형태로 반환하지만 필요한 경우 자동 언박싱 통해 기본형으로 변환

String str1 = "123";
String str2 = "45.67";
String str3 = "8.9";

int num1 = Integer.valueOf(str1);
double num2 = Double.valueOf(str2);
float num3 = Float.valueOf(str3);

System.out.println(num1); // 123
System.out.println(num2); // 45.67
System.out.println(num3); // 8.9

숫자 → 문자(char)

• 더하기 연산을 사용하여 유니코드 값 활용 → 직관적이고 효율적

int num = 5;
char ch = (char) (num + '0');

System.out.println(ch); // '5'

• Character.forDigit() 사용 → 보통 여러 진법의 숫자를 문자로 바꿀 때 사용

int num = 10;
char ch = Chacter.forDigit(num, 16);

System.out.println(ch); // 'a'

• 문자열로 변환 후 문자 추출 → 비효율적이지만, 숫자가 여러 자리일 때 유용

int num = 5;
char ch = Integer.toString(num).charAt(0);

System.out.println(ch); // '5'

숫자 → 문자열(String)

• String.valueOf() 사용

int num = 123;
double dNum = 45.67;
float fNum = 8.9f;

System.out.println(String.valueOf(num)); // "123"
System.out.println(String.valueOf(dNum)); // "45.67"
System.out.println(String.valueOf(fNum)); // "8.9"

• Integer.toString(), Double.toString(), Float.toString() 등 사용

int num = 123;
double dNum = 45.67;
float fNum = 8.9f;

System.out.println(Integer.toString(num)); // "123"
System.out.println(Double.toString(dNum)); // "45.67"
System.out.println(Float.toString(fNum)); // "8.9"

• 문자열 연결 연산자 사용 → 간단하지만 성능상 비효율적

int num = 123;
double dNum = 45.67;
float fNum = 8.9f;

System.out.println(num + ""); // "123"
System.out.println(dNum + ""); // "45.67"
System.out.println(fNum + ""); // "8.9"

---

 

 

컬렉션 프레임워크(Collection)

컬렉션이란?

데이터(객체)를 효율적으로 저장하고 관리하는 자료구조로, 데이터를 어떻게 저장하고 다룰지를 정의하는 개념이다. 자바에서 제공하는 컬렉션은 java.util 패키지에 포함되어 있다.

 

List (순서 O, 중복 O)

• 데이터를 순서대로 저장하며 중복 허용
• 배열과 비슷하지만 크기 변경 가능
• 주요 구현체: ArrayList, LinkedList, Vector

add(E e)	리스트 끝에 요소 추가
add(int index, E e)	특정 위치에 요소 삽입
remove(int index)	특정 위치 요소 제거
remove(Object o)	특정 요소 제거
get(int index)	특정 위치 요소 가져오기
set(int index, E e)	특정 위치 요소 변경
contains(Object o)	특정 요소 포함 여부 확인
size()	리스트 크기 반환
isEmpty()	리스트가 비어있는지 확인
clear()	모든 요소 제거
indexOf(Object o)	특정 요소의 첫 번째 인덱스 반환
lastIndextOf(Object o)	특정 요소의 마지막 인덱스 반환
toArray()	리스트를 배열로 변환

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple"); // 중복 허용
System.out.println(list); // [Apple, Banana, Apple]

// 특정 인덱스 값 가져오기
System.out.println(list.get(1)); // "Banana"

// 값이 존재하는지 확인
System.out.println(list.contains("Cherry")); // false

// 특정 값의 인덱스 찾기
System.out.println(list.indexOf("Banana")); // 1

 

Set (순서 X, 중복 X)

• 중복된 데이터를 허용하지 않음
• 순서를 보장하지 않음 (특정 정렬이 필요한 경우 TreeSet 사용)
• 주요 구현체: HashSet, TreeSet, LinkedHashSet

add(E e)	요소 추가 (중복된 값이면 추가되지 않음)
remove(Object o)	특정 요소 제거
contains(Object o)	특정 요소 포함 여부 확인
size()	Set 크기 반환
isEmpty()	Set이 비어있는지 확인
clear()	모든 요소 제거
toArray()	Set을 배열로 변환
iterator()	Set의 요소를 순회할 수 있는 Iterator 반환

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 중복이므로 무시됨
System.out.println(set); // [Apple, Banana] (출력 순서 다를 수 있음)


// 특정 값이 존재하는지 확인 (O(1))
System.out.println(set.contains("Cherry")); // false

// HashSet은 인덱스가 없기 때문에 특정 위치의 값을 직접 가져올 수 없음!
// System.out.println(set.get(1)); ❌ 에러 발생

// Set을 리스트로 변환 후 접근 가능
ArrayList<String> listFromSet = new ArrayList<>(set);
System.out.println(listFromSet.get(1)); // "Banana" (출력 값은 순서가 보장되지 않음)

 

Map (키-값 저장, 키 중복 X, 값 중복 O)

• Key-Value 형태로 저장
• 키는 중복 불가능, 값은 중복 가능
• 주요 구현체: HashMap, TreeMap, LinkedHashMap

put(K key, V value)	키-값 추가 (이미 존재하는 키면 값 변경)
get(K key)	특정 키의 값 가져오기
remove(K key)	특정 키 제거
containsKey(K key)	특정 키 포함 여부 확인
containsValue(V value)	특정 값 포함 여부 확인
size()	Map 크기 반환
isEmpty()	Map이 비어있는지 확인
clear()	모든 요소 제거
keySet()	모든 키 반환 (Set<K> 형태)
values()	모든 값 반환 (Collection<V> 형태)
entrySet()	코든 키-값 쌍 반환 (Set<Map.Entry<K,V>> 형태)

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 5);
map.put("Cherry", 20);
map.put("Apple", 20); // 기존 "Apple" 키의 값이 덮어쓰기됨
System.out.println(map); // {Apple=20, Banana=5}
System.out.println(map.get("Apple")); // 10 (O(1) 조회)

// 특정 키 존재 여부
System.out.println(map.containsKey("Apple")); // true

// 특정 값 존재 여부
System.out.println(map.containsValue(30)); // false

// 삭제
map.remove("Cherry");

// 모든 키 출력
System.out.println(map.keySet()); // [Apple, Banana]

// 모든 값 출력
System.out.println(map.values()); // [10, 5]

 

Queue

• 데이터를 먼저 넣은 순서대로 꺼내는 구조(FIFO: First In First Out)
• 주요 구현체: LinkedList, PriorityQueue

offer(E e)	요소 추가 (성공 시 true 반환)
poll()	큐에서 요소 제거 및 반환 (비어있으면 null 반환)
remove()	큐에서 요소 제거 (비어있으면 예외 발생)
peek()	큐의 첫 번째 요소 조회 (제거 X, 비어있으면 null 반환)
element()	큐의 첫 번째 요소 조회 (제거 X, 비어있으면 예외 발생)
size()	큐 크기 반환
isEmpty()	큐가 비어있는지 확인
clear()	모든 요소 제거

// 일반 큐
Queue<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);
System.out.println(queue.poll()); // 1 (먼저 들어온 값이 먼저 나감)

// 맨 앞 요소 확인
System.out.println(queue.peek()); // 2

// 현재 큐 상태
System.out.println(queue); // [2, 3]



// 우선순위 큐
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);
System.out.println(pq.poll()); // 10 (가장 작은 값부터 출력)

// 우선순위 큐를 활용한 최대 힙
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
maxHeap.offer(30);
maxHeap.offer(10);
maxHeap.offer(20);
System.out.println(maxHeap.poll()); // 30 (가장 큰 값부터 출력)

 

Deque

• 양쪽에서 삽입/삭제가 가능한 큐
• 스택을 구현할 때도 Deque을 사용하기도 함

offerFirst(E e)	앞쪽에 요소 추가
offerLast(E e)	뒤쪽에 요소 추가
pollFirst()	앞쪽 요소 제거 및 반환
pollLast()	뒤쪽 요소 제거 및 반환
peekFirst()	앞쪽 요소 조회 (제거 X)
peekLast()	뒤쪽 요소 조회 (제거 X)
size()	크기 반환
isEmpty()	비어있는지 확인
clear()	모든 요소 제거

Deque<Integer> deque = new ArrayDeque<>();
deque.offerFirst(10); // 앞쪽에 추가
deque.offerLast(20);  // 뒤쪽에 추가
System.out.println(deque.pollFirst()); // 10 (앞쪽에서 제거)

 

---

 

입출력 및 문자열 관련 클래스

BufferedReader, InputStreamReader (입력 관련)

• InputStreamReader: System.in 같은 입력에서 바이트 단위로 읽어온 데이터(바이트 기반 스트림)를 문자 기반 스트림으로 변환
• BufferedReader: 입력을 버퍼링하여 한 줄씩 읽을 수 있도록 돕는 클래스
• Scanner보다 빠르게 입력을 처리할 때 사용

import java.io.*;

public class Main {
  public static void main(String[] args) throw IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
    // 한 줄 입력받기
    String input = br.readLine();
    System.out.println("입력 값: " + input);
    
    br.close();
  }
}

 

StringBuffer, StringBuilder (문자열)

• Java의 String은 불변(immutable)이기 때문에, 값을 변경하면 새로운 객체를 생성해서 성능이 저하될 수 있음
• StringBuffer와 StringBuilder는 String과 달리 가변(mutable) 문자열을 다룸
• StringBuffer는 멀티스레드 환경에서 안전하지만 느리고, StringBuilder는 싱글스레드 환경에서 동작하며 빠름

public class Main {
    public static void main(String[] args) {
        // StringBuffer 사용
        StringBuffer sb = new StringBuffer("Hello");
        sb.append(" World"); // 문자열 추가
        System.out.println(sb.toString()); // "Hello World"

        // StringBuilder 사용
        StringBuilder sb2 = new StringBuilder("Java");
        sb2.append(" Programming");
        System.out.println(sb2.toString()); // "Java Programming"
    }
}

• StringBuilder 메서드

메서드	설명	예제
append(String s)	문자열 끝에 추가	sb.append("World");
insert(int offset, String s)	특정 위치에 문자열 삽입	sb.insert(5, "Hello");
delete(int start, int end)	특정 범위의 문자 삭제	sb.delete(0, 5);
deleteCharAt(int index)	특정 범위를 새로운 문자열로 변경	sb.deleteCharAt(2);
replace(int start, int end, String s)	특정 범위를 새로운 문자열로 변경	sb.replace(0, 5, "Hi");
reverse()	문자열 뒤집기	sb.reverse();
length()	문자열 길이 반환	sb.length();
charAt(int index)	특정 위치 문자 반환	sb.charAt(3);
setCharAt(int index, char c)	특정위치 문자 변경	sb.setCharAt(0, 'H');
substring(int start)	특정위치 문자 변경	sb.substring(3);
substring(int start, int end)	특정위치 문자 변경	sb.substring(2, 6);
toString()	String 객체로 변환	sb.toString();
capacity()	현재 저장할 수 있는 문자 수 반환	sb.capacity();
ensureCapacity(int minimumCapacity)	최소 저장 공간 보장	sb.ensureCapacity(50);

 

StringTokenizer (문자열 분할)

• 문자열을 특정 구분자(Delimiter) 기준으로 나눌 때 사용
• 공백, 쉼표(,), 탭, 줄바꿈 등으로 문자열을 토큰화할 때 유용

import java.util.*;

public class Main {
  public static void main(String[] args) {
    String data = "Apple,Banana,Cherry";
    
    StringTokenizer st = new StringTokenizer(data, ",");
    
    while (st.hasMoreTokens()) {
      System.out.println(st.nextToken());
    }
  }
}

 

---

 

메서드 알아보기

배열 관련 메서드

import java.util.*;

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

// 1. 배열 정렬 및 출력
Arrays.sort(arr);  
System.out.println(Arrays.toString(arr));  // [1, 2, 3, 5, 8]


Integer[] arrI = {5, 3, 8, 1, 2}; // 기본형 int[]는 reverseOrder() 사용 불가
Arrays.sort(arrI, Collections.reverseOrder());
System.out.println(Arrays.toString(arrI));  // [8, 5, 3, 2, 1]


// 2. 2차원 배열 출력
int[][] arr2D = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(arr2D));  // [[1, 2], [3, 4]]


// 3. 배열 복사
int[] newArr = Arrays.copyOf(arr, 3);  
System.out.println(Arrays.toString(newArr));  // [1, 2, 3]

int[] newArr2 = Arrays.copyOfRange(arr, 1, 4);  
System.out.println(Arrays.toString(newArr2));  // [2, 3, 4]  (index 1~3)


// 4. 배열 채우기
int[] arr7 = new int[5];
Arrays.fill(arr, 7);
System.out.println(Arrays.toString(arr));  // [7, 7, 7, 7, 7]

int[][] arr7_3x3 = new int[3][3];
for (int[] row : arr) {
    Arrays.fill(row, 7);
}
System.out.println(Arrays.deepToString(arr));  // [[7, 7, 7], [7, 7, 7], [7, 7, 7]]


// 5. 배열 비교
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(Arrays.equals(arr1, arr2));  // true

int[][] arr1_2x2 = {{1, 2}, {3, 4}};
int[][] arr2_2x2 = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepEquals(arr1, arr2));  // true


// 6. 배열에서 특정 값 찾기 (이진 탐색 기반, 정렬되어 있어야 함)
int[] arr = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(arr, 5);
System.out.println(index);  // 2 (5는 2번째 인덱스)


// 7. 배열을 리스트로 변환
String[] strArr = {"Java", "Python", "C++"};
List<String> list = Arrays.asList(strArr);
System.out.println(list);  // [Java, Python, C++]

// Arrays.asList()로 만든 리스트는 크기 변경이 불가 => add(), remove() 불가
// 대신 new ArrayList<>(Arrays.asList(arr)) 사용
List<String> arrList = new ArrayList<>(Arrays.asList(strArr));
arrList.add("JavaScript");
System.out.println(arrList); // [Java, Python, C++, JavaScript]


// 8. 배열 합치기
int[] arrA = {1, 2, 3};
int[] arrB = {4, 5, 6};
int[] merged = IntStream.concat(Arrays.stream(arrA), Arrays.stream(arrB)).toArray();

System.out.println(Arrays.toString(merged));  // [1, 2, 3, 4, 5, 6]

 

문자, 문자열 관련 메서드

문자 관련 (Character 클래스)

메서드	설명	예제
Character.isDigit(char c)	숫자인지 확인	Character.isDigit('5') // true
Character.isLetter(char c)	문자인지 확인	Character.isLetter('𝐀') // false (수학기호)
Character.isLetterOrDigit(char c)	문자 또는 숫자인지 확인	Character.isLetterOrDigit('A') // true
Character.isAlphabetic(char c)	문자인지 확인 (isLetter()보다 더 넓은 범위)	Character.isAlphabetic('𝐀') // true
Character.isWhitespace(char c)	공백인지 확인	Character.isWhitespace(' ') // true
Character.toUpperCase(char c)	대문자로 변환	Character.toUpperCase('a') // 'A'
Character.toLower(char c)	소문자로 변환	Character.toLowerCase('A') // 'a'

 

문자열 관련 (String 클래스)

• 문자열 길이 & 문자 접근

메서드	설명	예제
length()	문자열 길이 반환	"hello".length() // 5
charAt(int index)	특정 위치 문자 반환	"hello".charAt(1) // 'e'

 

• 문자열 변경(새 문자열 반환)

메서드	설명	예제
toUpperCase()	대문자로 변환	"hello".toUpperCase() // "HELLO"
toLowerCase()	소문자로 변환	"hello".toLowerCase() // "hello"
trim()	앞뒤 공백 제거	" hello ".trim() // "hello"
replace(char old, char new)	특정 문자 변경	"java".replace('a', 'o') // "javo"
replaceAll(String regex, String str)	정규식 기반 치환	"abc123".replaceAll("\\d", "*") // "abc***"

 

• 문자열 검색

메서드	설명	예제
indexOf(String s)	문자열의 첫 번째 위치 반환	"hello".indexOf("l") // 2
lastIndexOf(String s)	마지막 위치 반환	"hello".lastIndexOf("l") // 3
contains(String s)	문자열 포함 여부 확인	"hello".contains("ll") // true
startsWith(String s)	특정 문자로 시작하는지 확인	"hello".startsWith("he") // true
endsWith(String s)	특정 문자로 끝나는지 확인	"hello".endsWith("o") // true

 

• 문자열 자르기

메서드	설명	예제
substring(int start)	특정 위치부터 끝까지 문자열 반환	"hello".substring(2) // "llo"
substring(int start, int end)	특정 범위 문자열 반환	"hello".substring(1, 4) // "ell"

 

• 문자열 분할

메서드	설명	예제
split(String str)	문자열을 배열로 분할	"a,b,c".split(",") // ["a", "b", "c"]
split(String str, int limit)	특정 개수만큼 분할	"a,b,c".split(",", 2) // ["a", "b,c"]

 

• 문자열 비교

메서드	설명	예제
equals(String s)	문자열이 같은지 비교	"hello".equals("hello") // true
equalsIgnoreCase(String s)	대소문자 무시하고 비교	"hello".equalsIgnoreCase("HELLO") // true
compareTo(String s)	사전순 비교 (같으면 0)	"apple".compareTo("banana") // -1

 

 

정렬 관련

lambda를 활용한 정렬

// 배열
Integer[] arr = {1, 2, 3, 4, 5};
Arrays.sort(arr, (a, b) -> b - a); // 오름차순 정렬
Arrays.sort(arr, (a, b) -> a - b); // 내림차순 정렬


// Map
Map<String, Integer> map = new HashMap<>();
map.put("a", 3);
map.put("b", 2);
map.put("c", 1);

List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet()); // [("a", 3), ("b", 2), ("c", 1)]
entryList.sort((o1, o2) -> map.get(o1.getKey()) - map.get(o2.getKey())); // 값 기준 오름차순 정렬 -> [("c", 1), ("b", 2), ("a", 3)]

// 위 코드 대신 comparingInt 사용도 가능
entryList.sort(Comparator.comparingInt((Map.Entry<String, Integer> o) -> map.get(o.getKey())));

 

Comparator를 활용한 사용자 정의 정렬

class Student {
    String name;
    int score;

    Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 85));
students.add(new Student("Bob", 90));
students.add(new Student("Charlie", 80));

// 점수 오름차순 정렬
students.sort(Comparator.comparingInt(s -> s.score));

for (Student s : students) {
    System.out.println(s.name + ": " + s.score);
}
// 출력: Charlie: 80, Alice: 85, Bob: 90

 

여러 조건으로 정렬하려면 thenComparing() 사용

students.sort(Comparator.comparingInt((Student s) -> s.score).thenComparing(s -> s.name));

 

---

예제

n x m 배열 입력받아 출력하기

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

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine(), " ");
    
    int n = Integer.parseInt(st.nextToken());
    int m = Integer.parseInt(st.nextToken());
    
    int[][] arr = new int[n][m];
    
    for (int i = 0; i < n; i++) {
      st = new StringTokenizer(br.readLine(), " ");
      for (int j = 0; j < m; j++) {
        arr[i][j] = Integer.parseInt(st.nextToken());
      }
    }
    
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        sb.append(arr[i][j] + " ");
      }
      sb.append('\n');
    }
    System.out.println(sb);
  }
}