데이터 타입
기본 - int, long, double, boolean, char
참조 - Integer, Long, Double, Character, String
ArrayList
List<Integer> list = new ArrayList<>();
list.add(1); // 맨 뒤에 추가
list.add(0, 5); // 특정 인덱스에 추가
list.get(0); // 인덱스로 조회
list.set(0, 10); // 인덱스 값 변경
list.remove(0); // 인덱스로 제거
list.remove(Integer.valueOf(10)); // 값으로 제거 (int면 인덱스로 오해되니 주의)
list.contains(10); // 포함 여부
list.size(); // 크기
list.isEmpty(); // 비었는지 확인정렬(배열, 리스트)
// 배열 정렬
int[] arr = {3, 1, 2};
Arrays.sort(arr); // 오름차순
// 내림차순은 int[]는 직접 안됨 → Integer[]로 쓰거나 정렬 후 뒤집기
Integer[] arr2 = Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.sort(arr2, Collections.reverseOrder());
// 리스트 정렬
List<Integer> list = new ArrayList<>();
Collections.sort(list); // 오름차순
Collections.sort(list, Collections.reverseOrder()); // 내림차순
list.sort(null); // 오름차순 (null = 기본순서)
list.sort(Comparator.reverseOrder());// 내림차순
// 커스텀 정렬
list.sort((a, b) -> a - b); // 오름차순
int[][] arr2D = {{3,1},{1,2},{2,5}};
Arrays.sort(arr2D, (a, b) -> a[0] - b[0]); // 2차원 배열 정렬
Arrays.sort(arr2D, (a, b) -> { // 다중 기준
if (a[0] != b[0]) return a[0] - b[0];
return b[1] - a[1];
});Dequeue(Stack/Queue)
Deque<Integer> dq = new ArrayDeque<>();
// 큐로 사용 (FIFO)
dq.offer(1); // 삽입
dq.poll(); // 맨 앞 꺼내면서 제거
dq.peek(); // 맨 앞 확인, 제거X
// 스택으로 사용 (LIFO)
dq.push(1); // 맨 앞에 삽입
dq.pop(); // 맨 앞 꺼내면서 제거
dq.peek(); // 맨 앞 확인, 제거X (스택으로 써도 peek는 동일)
// 공통
dq.isEmpty(); // 비었는지 확인
dq.size(); // 크기PriorityQueue(Heap)
// 최소힙 (기본)
PriorityQueue<Integer> pq = new PriorityQueue<>();
// 최대힙
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
pq.offer(3);
pq.offer(1);
pq.offer(2);
pq.poll(); // 1 (최소값 꺼내면서 제거)
pq.peek(); // 2 (최소값 확인, 제거X)
pq.size();
pq.isEmpty();
Hash (HashMap, HashSet)
// HashMap
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.get("a"); // 1
map.getOrDefault("b", 0); // 없으면 기본값 0
map.containsKey("a");
map.remove("a");
for (String key : map.keySet()) { }
for (int val : map.values()) { }
for (Map.Entry<String, Integer> e : map.entrySet()) {
e.getKey(); e.getValue();
}
// HashSet
Set<Integer> set = new HashSet<>();
set.add(1);
set.contains(1);
set.remove(1);
set.size();
for (int val : set) {
System.out.println(val);
}TreeMap
키가 자동 정렬되는 Map
TreeMap<Integer, Integer> map = new TreeMap<>();
//삽입
map.put(key, n); // 있으면 개수를 n으로 갱신
map.merge(k, val, (a, b) -> Math.max(a, b)); // 기존값과 새값 중 큰 것
map.merge(k, 1, (a, b) -> a + b); // 기존값+새값
map.firstKey(); // 최솟값
map.lastKey(); // 최댓값
map.get(key); // 그 키의 개수 확인
map.remove(key); // 그 키 자체를 삭제
map.isEmpty(); // 비었는지 확인
//Iterator로 반복문(안전)
Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) { // 다음 원소가 있으면
Map.Entry<Integer, Integer> e = it.next(); // 꺼내기
System.out.println(e.getKey() + " -> " + e.getValue());
}
//내림차
Iterator<Integer> it = map.descendingKeySet().iterator();
while (it.hasNext()) {
int key = it.next();
if (map.get(key) == 1) it.remove();
}문자열 다루기
String
// String은 불변(immutable)
// → 모든 메서드는 원본을 바꾸지 않고 "새 문자열을 반환"만 함
// → 반드시 s = s.xxx() 처럼 반환값을 다시 받아야 반영됨
String s = "hello";
// 조회 (원본 변화 없음)
s.length(); // 5
s.charAt(0); // 'h' (인덱스 문자)
s.substring(1); // "ello" (1부터 끝까지)
s.substring(1, 3); // "el" (1 이상 3 미만)
s.indexOf("l"); // 2 (첫 등장 위치, 없으면 -1)
s.contains("ell"); // true
s.equals("hello"); // true (문자열 비교는 == 아니라 equals!)
s.compareTo("abc"); // 사전순 비교 (음수: s가 앞 / 0: 같음 / 양수: s가 뒤)
// 변환 (새 문자열 반환! 원본 s는 그대로)
s.toUpperCase(); // "HELLO" 반환만 하고 버려짐, s는 여전히 "hello"
s = s.toUpperCase(); // 이렇게 다시 담아야 s가 바뀜
s = s.toLowerCase(); // "hello"
s = s.replace("l", "L"); // "heLLo" (모든 l 교체)
s = s.trim(); // 앞뒤 공백 제거
s = s.repeat(3); // 문자열 3번 반복
// 나누기 / 합치기
String[] arr = "1 2 3".split(" "); // ["1","2","3"]
String joined = String.join(",", "a", "b", "c"); // "a,b,c"StringBuilder
// StringBuilder는 가변(mutable)
// → 원본 객체 자체를 바꿈 (반환값 안 받아도 반영됨)
// → 문자열을 반복해서 이어붙일 땐 + 대신 StringBuilder 필수 (성능)
StringBuilder sb = new StringBuilder("hello");
sb.append("!"); // sb 자체가 "hello!"로 바뀜
sb.append(1); // 숫자도 자동 문자열화
sb.insert(0, "x"); // 특정 위치 삽입
sb.deleteCharAt(0); // 인덱스 문자 삭제
sb.reverse(); // sb 자체가 뒤집힘
sb.length(); // 길이
String result = sb.toString(); // 최종 String으로 변환형변환
// int[] ↔ Integer[]
int[] arr = {3, 1, 2};
Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new); // int[] → Integer[]
int[] unboxed = Arrays.stream(boxed).mapToInt(Integer::intValue).toArray(); // Integer[] → int[]
// int[] → String[] (mapToObj로 원하는 타입 지정)
String[] strs = Arrays.stream(arr).mapToObj(String::valueOf).toArray(String[]::new);
// boxed()는 mapToObj(Integer::valueOf)의 축약형
// 배열 → 리스트
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList()); // int[] → List
List<Integer> list2 = Arrays.asList(boxed); // Integer[] → List (고정크기, add/remove 불가 주의)
List<Integer> list3 = new ArrayList<>(Arrays.asList(boxed)); // 수정 가능한 List
// 리스트 → 배열
Integer[] a1 = list.toArray(new Integer[0]); // List → Integer[]
int[] a2 = list.stream().mapToInt(Integer::intValue).toArray(); // List → int[]
// 문자열 ↔ 숫자
int n = Integer.parseInt("123"); // String → int
long l = Long.parseLong("123"); // String → long
String s = String.valueOf(123); // int → String
String s2 = Integer.toString(123); // int → String
// 문자열 ↔ 문자배열
char[] chars = "abc".toCharArray(); // String → char[]
String str = new String(chars); // char[] → String
String str2 = String.valueOf(chars); // char[] → String
// 문자 ↔ 숫자 (아스키)
char c = '7';
int num = c - '0'; // char '7' → int 7
char c2 = (char)(num + '0'); // int 7 → char '7'
int ascii = (int) 'A'; // 65
char c3 = (char) 65; // 'A'
studying