자바 코테용 문법 정리

자바 코테용 문법 정리

 

라이브러리 땡겨오기

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

배열 선언

String[] arr1 = new String[5];
int[] arr2 = {1, 2, 3};

int N = 3;
int[] arr3 = new int[N];

Arrays

int arr[] = {10, 8, 11, 2, 3, 0};

// 오름차순 {0, 2, 3, 8, 10 ,11}
Arrays.sort(arr); 

// 내림차순 {11, 10 , 8, 3, 2, 0}
Arrays.sort(arr, Collections.reverseOrder());

// int 타입 배열 내림차순(Integer로 변경 필요)
Integer arr2[] = Arrays.stream(arr).boxed().toArray(Integer::new);
Arrays.sort(arr2, Collections.reverseOrder());

// 일부 인덱스만 정렬 -> 0, 4까지 정렬 {2, 8, 11, 10, 3, 0}
Arrays.sort(arr, 0, 4);

// binary search(단, 오름차순 정렬 먼저 해야함)
Arrays.binarySearch(arr, 2);

// 배열을 ArrayList로 변환
List list = Arrays.asList(arr);

// 배열의 특정 범위 잘라서 다른 배열 변수에 할당
int tmp[] = Arrays.copyOfRange(arr, 0, 3);

// 배열 복사
int []tmp = arr.clone();

length / length()/ size()

length - 배열 길이

length() - 문자열 길이

size() - Collection object (list) 길이

int[] arr = new arr[3];
System.out.println(arr.length);

String str = "java";
System.out.println(str.length());

ArrayList<Integer> list = new ArrayList<>();
System.out.println(list.size());

List vs ArrayList

https://yoon-dailylife.tistory.com/7

List가 ArrayList보다 상위 개념임. List를 사용해 ArrayList를 선언하는 방식은 LinkedList 또는 Vector와 같은 List 인터페이스의 구현을 사용하여 변수를 참조할 수 있으므로 향후 더 많은 유연성을 제공할 수 있음.

ArrayList <Object> list = new ArrayList<>();
List <Object> list = new ArrayList<>();

String

String str = "hello world";
String[] splitStr = str.split(" "); // 구분자를 기준으로 문자열을 나눠서 배열 형태로 반환
        for (String s : splitStr) System.out.println(s);
//hello
//world

String[] splitStr = str.split(); // 띄어쓰기 없는 문자열을 한 문자씩 분리해서 Array로 반환
List<String> charList = Arrays.asList(str.split("")); // 한 문자씩 분리해서 List로 반환

String subStr = str.substring(0, 5); // 시작 인덱스부터 끝 인덱스 미만까지 자르고 반환

for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i); // 문자열에서 특정 인덱스의 문자 하나를 반환
            System.out.println(c);
}

str = str.toUpperCase(); // 대문자로 변경
str = str.toLowerCase(); // 소문자로 변경

str.trim() // str 앞뒤 공백 제거. 문자열 사이 공백 제거 아님
str.equals("abc"); // str과 abc를 비교해서 같으면 true or false
str.contains("bc"); // str에 bc 포함되었으면 true or false
str.compareTo("abc"); // str과 abc가 같으면 0, 사전순으로 str이 앞이면 -1 뒤면 1

Integer.parseInt("300"); // 문자열을 숫자로 변환
Integer.toString(300); // 문자열로 변환. 단, 패러미터가 null이면 에러 발생
String.valueOf(300); // 문자열로 변환. 단, 패러미터가 null이면 "null" 반환

StringBuilder

String은 선언 이후 문자 추가나 삭제가 안되는 타입이다.

따라서 문자열을 변경해야하는 문제에서는 StringBuilder를 사용한다.

StringBuilder sb = new StringBuilder();
sb.append("abc") // 문자열 추가
sb.insert(2, "kk") // 2 위치에 kk 삽입 "abkkc"

sb.delete(0, 2) // 0~1 위치의 문자열 삭제 "c"
sb.deleteCharAt(2) // 2 위치의 문자 삭제 "ac"

sb.setCharAt(0, 'h') // 0 위치의 문자를 h로 변경 "hbc"
sb.reverse() // 문자열 거꾸로 뒤집기 "cba"

sb.setLength(2) // 문자열 길이를 2로 줄임 "ab"
sb.setLength(4) // 문자열 길이를 4로 늘림. 모자란 부분이 공백으로 채워짐
.toString(); // String으로 형변환

BuffredReader

Enter를 경계로 입력 값을 인식.

readLine()은 Enter를 포함한 String 형식으로 입력을 받아옴.

int 형으로 readLine()을 받아오려면 Integer.parseInt()로 형변환이 필요하다.

public class InputOutputTest {
	public static void main(String args[])throws IOException {

		BufferedReader br = new BuffredReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		System.out.print(N);
	}
}

공백으로 구분된 정수 입력을 리스트로 받기

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        List<Integer> list = Arrays.stream(input.split(" "))
                .map(Integer::valueOf)
                .collect(Collectors.toList());
    }

공백으로 구분된 문자열 입력을 리스트로 받기

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        List<String> list = List.of(input.split(" "));
        for(String i : list) System.out.println(i);
    }

StringTokenizer

지정한 형식에 따라 문자열을 쪼개주는 클래스

특정 문자에 따라 문자열을 나눌 수 있다.

public class InputOutputTest {
	public static void main(String args[])throws IOException {
		BufferedReader br = new BuffredReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine()); // enter를 기준으로 쪼
		int N = Integer.parseInt(st.nextToken());
		int M = Integer.parseInt(st.nextToken());
	}
}

Collections 관련 메서드

int[] arr = {1123, 1412, 23, 44, 512132};
List<Integer> list = new ArrayList<>(Arrays.asList(arr)); // array를 List로 변환

Collections.max(list); // list중 가장 큰 값 반환
Collections.min(list); // list의 원소 중 가장 작은 값 반환

Collections.sort(list); // 오름차순 정렬
Collections.sort(list, Collections.reverseOrder()); // 내림차순 정렬

Collections.reverse(list) // 역순 정렬
Collections.frequency(list, 23) // list내의 23의 개수 반환
Collections.binarySearch(list, 44) // 최초로 검색된 44의 인덱스를 반

HashMap

중복 허용X, key나 value에 null 허용

HashMap<Object, Object> map = new HashMap<>();

위와 같이 작성하게 되면 map Object는 오직 HashMap에 대한 Object만 담을 수 있어서 유지보수성이 떨어진다.

Map<Object, Object> map = new HashMap<>(); 위와 같이 선언할 경우 TreeMap 또는 LinkedHashMap과 같은 Map에 대한 다양한 인터페이스 개체를 참조할 수 있으므로 유지보수가 쉽다.

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

// key-value 넣기
map.put("java", 0);

// key로 value 가져오기
map.get("java"); // 0

// 특정 key 존재 유무 확인
if (!map.containsKey("java")) ...

// 특정 key 값이 없으면 값을 설정하고, 있으면 기존 값을 가져옴
map.put("java", map.getOrDefault("java", 3)); 

// keySet()으로 Map의 모든 value값 순회
for(String key: map.KeySet()) {
	map.get(key);
}

// entrySet()으로 key, value 모두 조회
for (Map.Entry<String, String> entry : map.entrySet()) {
	System.out.println("[key]:" + entry.getKey() + ", [value]:" + entry.getValue());
}

// 람다로 key, value 모두 조회
map.forEach((key, value) -> {
	System.out.println("[key]:" + key + ", [value]:" + value);
});

// stream 사용
map.entrySet().stream().forEach(entry-> {
	System.out.println("[key]:" + entry.getKey() + ", [value]:"+entry.getValue());
});

Set

중복X, 순서 유지X

Set<String> set = new HashSet<>();
set.add("abc");
set.remove("abc");
set.size();

List

List<String> list = new ArrayList<>(); 

list.add("java"); // 단순 삽입 {"java"}
list.add(0, "c++"); // 특정 인덱스에 삽입 {"c++", "java"}
list.set(1, "c#"); // 특정 인덱스 값을 수정 {"c++", "c#"}
list.remove(1); // 특정 인덱스 값 삭제 {"c++"}
list.contains("java"); // 값 존재 확인 true/false
list.indexOf("java"); // 값에 해당하는 첫번째 인덱스를 반환.(특정 값이 중복되어 있을 경우 첫번째 인덱스만 반환) 없으면 -1 반환

// get(index)로 특정 인덱스 값 조회
for (int i = 0; i < list.size(); i++) System.out.println(list.get(i)); 

list.addAll(list2) // list 뒤에 list2 전체 값 삽입
list.removeAll(list2) // list에서 list2에 들어있는 모든 값 삭제
list.retainAll(list2) // list에서 list2에 들어있는 값 제외한 모든 값을 삭제
list.clear() // 전체 값 삭제
list.isEmpty() // 길이가 0이면 true, 아니면 false
list.size() // 길이
list.containsAll(list2) // list에 list2의 모든 값이 포함되어 있으면 true or false

List<String> list = new ArrayList<>();
list.add("서울");
list.add("대구");
list.add("부산");
list.add("대구");
System.out.println(list.indexOf("대구")); // 1 첫번째 인덱스
System.out.println(list.lastIndexOf("대구")); // 3 마지막 인덱스

list.removeIf(k -> k % 2 != 0) // 람다로 특정 조건 만족하는 수를 list에서 모두 제거 (홀수 제거)

List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3"));
List<String> list2 = new ArrayList<>();
list2.addAll(list); // 깊은 복사 1, 2, 3
List<String> list3 = new ArrayList<>(list); // 깊은 복

리스트로 변환, 배열로 변환, 문자를 문자열로 변환

// 문자열 배열 -> List
String[] temp = "abcde";
List<String> list = new ArrayList<>(Arrays.asList(temp));

// List를 문자열 배열로 변환
List<String> list = new ArrayList<>();
String[] temp = list.toArray(new String[list.size()]);

// 정수 배열을 List로 변환
int[] temp = { 1123, 1412, 23, 44, 512132 };
List<Integer> list = new ArrayList<>(Arrays.asList(temp));

// List를 정수 배열로 변환
List<Integer> list = new ArrayList<>();
int[] temp = list.stream().mapToInt(i->i).toArray();

// char 문자를 String 문자열로 변환
char c = 'a';
String str = String.valueOf(c);

Iterator

ArrayList, HashMap, HashSet과 같은 Collection을 반복하는 데 사용할 수 있는 객체.

반복문 써도 되는데 굳이 사용하는 이유?

1. 인덱스가 없는 Set에서 순회하기가 용이함.
2. 반복하는 동안 요소들을 보다 유연하게 제어할 수 있음.(반복 중에 특정 요소 제거, 더 많은 요소가 있는지 확인, 특정 요소 건너뛰기 등)
3. 양방향으로 순회 가능.(next(), previous())
4. LinkedList 사용할 경우 list.get(i)는 특정 요소 검색할 때마다 처음부터 목록을 반복해야 함.할 수 있음.(이전 요소를 반복할 필요 없이 원하는 요소로 직접 이동할 수 있어서 효율적임.)
5. Iterator를 사용하면 원하는 요소에 도달할 때까지 next() 메서드를 반복적으로 호출해 특정 요소를 검색

List<String> list = new ArrayList<>();
list.add("java");
list.add("c++");
list.add("c#");

// iterator 사용
Iterator<String> it = list.iterator();

// 인덱스 오름차순 순회
while (it.hasNext()) {
    System.out.println(it.next());
}

Iterator와 ListIterator의 차이

기능 Iterator ListIterator

양방향 순회 지원	X	O
순회 중 수정 지원	X	O
다른 컬렉션 유형과의 호환성	O	X(list만 가능)

List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
        list.add("date");

        ListIterator<String> iterator = list.listIterator();

        // 정방향 순회 조회
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 역방향으로 조회하면서 요소 수정하는 예시
				// iterator의 위치는 유지되므로 현재 맨 끝에 iterator가 위치함.
				// 만약 위의 정방향 순회 조회 코드가 없었다면
				// list.listIterator(list.size()); <- iterator의 위치를 맨 끝으로 위치해야함.
        while (iterator.hasPrevious()) {
            String element = iterator.previous();
            if (element.equals("banana")) {
                iterator.set("orange");
            } else if (element.equals("date")) {
                iterator.remove();
            }
        }

        // Output list elements backward
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

/**
apple
banana
cherry
date
orange
cherry
banana
apple
**/

// 중복없이 값을 넣으려는 경우
if (list.indexOf(value) < 0) { // indexOf()는 해당 값에 해당하는 인덱스가 없으면 -1을 반환함.
	list.put(value);
}

Queue

Queue<Integer> q = new LinkedList<>();
q.add(1); // 1 추가
q.offer(2); // 2 추가

add()

큐 맨 뒤에 값 삽입

추가 성공 시 true 반환

꽉 찬 경우 IllegalStackException 에러 발생

offer()

큐 맨 뒤에 값 삽입

값 추가 성공 시 true, 실패 시 false 반환

queue.poll(); // 첫번째 값 반환하고 제거. 비어 있으면 null 반환.
queue.remove(); // 첫번째 값 제거. 비어 있으면 NoSuchElementException 에러
queue.clear(); // 초기화

queue.element(); // 맨 앞 값 반환. 비었으면 NoSuchElementException 에러 발생
queue.peek(); // 큐의 맨 앞에 있는 값 반환. 비었으면 null 반환
queue.isEmpty(); // 큐 비었는지 확인 true/false

큐에 pair 값들을 넣고 첫번째 값을 기준으로 오름차순 출력하기

*자바는 c++처럼 pair<int, int> 같은 것이 제공되지 않는다. 따라서 직접 구현해야함.

import java.util.*;

public class Main {
	static class Node {
		int x; int y; 
		Node(int x, int y) {
			this.x = x; this.y = y;
		}
	}

	public static void main(String[] args) {
		Queue<Node> queue = new LinkedList<>();
		queue.add(new Node(x:1, y:2));
		queue.add(new Node(x:3, y:2));
		queue.add(new Node(x:5, y:1));
		queue.add(new Node(x:2, y:4));
	
		List<Node> list = new ArrayList<>(queue);
		list.sort(Comparator.comparingInt((Node node) -> node.x));
		// list.sort(Comparator.comparingInt((Node node) -> node.x).reversed()); 내림차순
		queue = new LinkedList<>(list);
	
		while (!queue.isEmpty()) {
			Node node = queue.poll();
			System.out.println("(" + node.x + "," + node.y + ")");
		}
	}
}
/**
오름차순
(1,2)
(2,4)
(3,2)
(5,1)

내림차순
(5,1)
(3,2)
(2,4)
(1,2)
**/

두번째 값 기준으로 오름차순 하되, 두번째 값이 같을 경우 첫번째 값을 기준으로 오름차순 하기
...

Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(1, 2));
        queue.add(new Node(3, 2));
        queue.add(new Node(5, 1));
        queue.add(new Node(2, 4));
        queue.add(new Node(5, 3));
        queue.add(new Node(3, 1));

				List<Node> list = new ArrayList<>(queue);
				list.sort(Comparator.comparingInt((Node node) -> node.y)
						.thenComparingInt((Node node) -> node.x));
				// thenComparingInt(): 1차 비교함수를 기준으로 두 객체가 같다고 판단될 때 2차 비교 함수를 제공
				queue = new LinkedList<>(list);

while (!queue.isEmpty()) {
            Node node = queue.poll();
            System.out.println("(" + node.x + "," + node.y + ")");
        }
}

/**
(3,1)
(5,1)
(1,2)
(3,2)
(5,3)
(2,4)
**/

Math 라이브러리

Math.max(10, 2); // 10
Math.min(10, 2); // 2

Math.abs(-1) // 1 절댓값

// 올림, 내림, 반올림
Math.ceil(-3.2); // -3
Math.floor(-3.2); // -4
Math.round(-3.26); // -3

// 소수 둘째, 셋쨰 자리에서 반올림 할 경우
double a = 1.23456;
String b = String.format("%.1f", a); // 둘째자리에서 반올림하여 첫째짜리까지 나타냄

Math.pow(2, 2); // 2^2 = 4
Math.sprt(4); // root 4 = 2

각 자리 숫자를 더하기

sumOfDigits(n);

String 배열을 int 배열로 변환하기.

import java.util.stream.Stream;

import java.util.*;

int[] newArr = Arrays.Stream(arr).mapToInt(Integer::parseInt).toArray();

String 리스트를 int 배열로 변환하기

List<String> stringList = Arrays.asList("1", "2", "3", "4", "5");

int[] intArray = stringList.stream().mapToInt(Integer::parseInt).toArray();

String 리스트를 String 배열로 변환하기

String[] stringArray = stringList.stream().toArray(String[]::new);

Integer 리스트를 int 배열로 변환하기

int[] intArray = intList.stream().mapToInt(i->i).toArray();

String배열을 charArray로 변경

String str = "badec"; 
char[] charArr = str.toCharArray(); // String to Char Array

 

문자열에서 특정 문자 제거하기.

String[] arr = my_string.replaceAll("[a-z]", "");
// a~z까지의 문자를 제거하고 ""으로 대체한 문자열을 반환.

 

숫자 형태의 char를 int형으로 변환

int val = Character.getNumericValue('3'); // 3

 

char값이 숫자인지 판단

if(Character.isDigit('3')) { ... }

 

 

 

 

문자열 내 문자 사전 순 정렬

String str = "badec"; 
char[] charArr = str.toCharArray(); // String to Char Array
Arrays.sort(charArr); // Char Array 알파벳 순 정렬
// Char Array to String
String result = new String(charArr); // 또는 String.valueOf(charArr);