For Programming Test

코테를 위한 자바

Collections

List
- ArrayList : 메모리상에 연속적으로 존재함
- LinkedList
Set
- HashSet : 중복을 허용하지 않고 순서가 없음
- LinkedHashSet : 중복을 허용하지 않고 순서가 있음
- TreeSet : 중복을 허용하지 않는 Binary Search Tree

List

public static void main(String[] args) throws InterruptedException {
    int[] array = {1,2,3,4,5};
    int[] array1 = new int[] {1,3,5,7,9};
    int[] array2 = new int[5];
 
    // 2차원 배열
    int[][] array3 = {{1,2,3,4}, {5,6,7,8}};
}

int[] -> Integer[] 변환

int[] list = {4,2,2,1,3,4};
Integer[] result = Arrays.stream(list)
        .boxed() // 레퍼런스 타입으로 변환
        .distinct() // 중복제거
        .toArray(Integer[]::new); // Integer형 배열로 변환
Arrays.sort(result, Collections.reverseOrder());
int[] result2 = Arrays.stream(result).mapToInt(Integer::intValue).toArray();

ℹ️

sort() 함수는 T 타입을 인자로 받는데 Java에서 Generic은 primitive type을 지원하지 않기 때문에 boxed()를 사용하여 reference type으로 변환해야 한다.

Arrays

Arrays.sort(a)

배열을 정리한다.

char[] c = new char[]{'c','b','d','a'};
Arrays.sort(c);
System.out.println(c);

Set

List to Set

String[] str = new String[]{"hihi"};
Set<String> set = new HashSet<>(Arrays.asList(str));

Set.contains(a)

Set이 a를 포함하고 있는지 확인한다.

if(!ban.contains(w)) {}

.sort(a, b)

1 : b가 앞으로 와야함
0 : 순서 바꾸지 않음
-1 : b가 뒤로 가야함

Stack

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(5);
		System.out.println(stack.size()); // 스택 사이즈 출력
		System.out.println(stack.peek()); // 가장 최근에 넣은 항목 출력
		System.out.println(stack.pop()); // 가장 최근에 넣은 항목 뽑음
		System.out.println(stack.isEmpty()); // 비었는지 확
	}
}

String

a.compareTo(b)

두 문자열을 비교한다.

0 : 같음
양수 : a가 더 큼
음수 : b가 더 큼

// 문자열 길이로 정렬, 만약에 같으면 사전순으로 정렬
letterList.sort((a,b) -> {
    if (a.length() == b.length()) {
        return a.compareTo(b);
    } else {
        return a.length() - b.length();
    }
});

chartAt()

문자열에서 특정 인덱스에 있는 문자를 반환한다.

String s = "Hello";
char c = s.charAt(1); // e

replace()

문자열에서 특정 문자를 다른 문자로 바꾼다.

String s = "Hello";
String s2 = s.replace('e', 'a'); // Hallo

split()

첫 번째 인자 기준으로 나눈다. 2번째 인자가 있으면 그만큼 나눈다.

String s = "abc def ghi jkl hml nop";
String[] s2 = s.split(" "); // [abc, def, ghi, jkl, hml, nop]
s2 = s.split(" ", 2); // [abc, def ghi jkl hml nop]
s2 = s.split(" ", 3); // [abc, def, ghi jkl hml nop]

위는 2가 들어갔으므로 2개가 될 때까지 나누는데 처음에 들어간 abc에서 한 번 나눴을 때 두 개의 문자열이 되므로 더 이상 나누지 않는다.

.replaceAll(a, b)

a를 모두 b로 변경

// 정규표현식 \\W는 문자, 숫자, 밑줄(_)을 제외한 모든 문자를 나타낸다. (공백, 구두점도 포함)
String[] words = paragraph.replaceAll("\\W+", " ").toLowerCase().split(" ");

substring(x, y)

String의 x 이상 인덱스부터 y 미만 인덱스까지 반환한다.

String s = "Hello";
String s2 = s.substring(1, 3); // el

.toCharArray()

String s = "abcdefg";
char[] c = s.toCharArray();
char a = "c"; // 컴파일 에러
char b = 'c';

StringBuilder

StringBuilder("Some String").reverse()

문자열을 뒤집는다.

String s = "Hello";
String s2 = new StringBuilder(s).reverse().toString(); // olleH

Character

Character.toLowerCase()

문자를 소문자로 변환한다.

String s = "Hello";
char c = Character.toLowerCase(s.charAt(1)); // e

Character.toUpperCase()

문자를 대문자로 변환한다.

String s = "Hello";
char c = Character.toUpperCase(s.charAt(1)); // E

Character.isLetterOrDigit()

문자 또는 숫자인지 확인한다.

String s = "Hello";
boolean b = Character.isLetterOrDigit(s.charAt(1)); // true

Map

디폴트 밸류가 있는지 확인하고 없으면 0 반환

HashMap<String, Integer> map = new HashMap<>();
int value = map.getOrDefault("hi", 0);

가장 높은 밸류를 가진 키 찾기

Map<String, Integer> counts = new HashMap<>(
) {{
    put("hi", 1);
    put("im", 2);
    put("fine", 3);
    put("and", 4);
}};
String maxValue = Collections.max(counts.entrySet(), Map.Entry.comparingByValue()).getKey();

밸류 순으로 정렬된 키 리스트

Map<String, Integer> counts = new HashMap<>() {{
    put("hi", 1);
    put("im", 2);
    put("fine", 3);
    put("and", 4);
}};
 
List<String> sortedKeys = counts.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue()) // value를 기준으로 오름차순 정렬
        .map(Map.Entry::getKey)               // key 추출
        .collect(Collectors.toList());        // List로 수집

Java란?자바 문법