[자바 코테 준비] 1. 자주 쓰이는 라이브러리 문법 정리

import

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

변수 선언

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

라이브러리

Arrays 배열

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

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

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

// 3. 일부만 정렬 {2, 8, 11, 10, 3, 0} (0~4만 정렬)
Arrays.sort(arr1, 0, 4)

// 4. 오름차순 정렬하면 binary search로 특정 값을 찾을 수 있다.
Arrays.binarySearch(arr1, 2);

// 5. 배열을 어레이리스트로 변환할 때!
List list = Arrays.asList(arr1);

// 6. 배열의 특정 범위 자르기
int tmp[] = Arrays.copyOfRange(arr1, 0, 3);

String 스트링

String str = "hello world";

// 길이 반환
str.length();

// 1. 자르기
str.split(" ");
str.substring(0, 5);
for(int i = 0; i < str.length(); i++) str.charAt(i);

// 1-1. 문자열을 배열로 만들고 싶을 때
String str = "12345";
String[] Arr = str.split("");

// 대소문자 변경
str = str.toUpperCase();		// HELLO WORLD
str = str.toLowerCase();		// hello world

// 한번 쓴 문자열은 변경 불가. substring 이용해서 새로운 변수로 선언해야함
String name="starfucks";
String newname=name.substring(0,4)+'b'+name.substring(5);	// starbucks

HashSet 해시셋

// HashSet에 있는 원소 순회
HashMap<String> set = new HashSet<>();
for(String key : set) {
	..
}

HashMap 해시맵

// 1. 선언
HashMap<String, Integer> hm = new HashMap<>();

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

// 3. 키로 값 가져오기
hm.get("java");

// 4. containsKey()로 존재유무 확인
if (!hm.containsKey("java")) hm.put("java", 1);

// 5. 특정 키가 없으면 값 설정, 있으면 기존 값 가져오는 함수
hm.put("java", hm.getOrDefault("java", 3);	

// 6. keySet() 함수로 맵 순회
for(String key : hm.KeySet()) {				
	hm.get(key);
}

ArrayList

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

// 2. 삽입
list.add("java");			// {"java"}
list.add(0, "ryu");			// {"ryu", "java"} (0번째 인덱스에 삽입)

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

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

// 5. 값 존재 유무 확인
list.contains("java");		// false
list.indexOf("ryu");		// 0 존재하면 인덱스 리턴

// 6. iterator 사용
Iterator it = list.iterator();

// 6-1. 인덱스 오름차순 순회
while (it.hasNext()) {
	...
}

// 6-2. 인덱스 내림차순 순회
while (it.hasPrevious()) {
	...
}

// 7. 중복없이 값을 넣고 싶을 때
if (list.indexOf(value) < 0) {	// 없으면 -1을 리턴하기 때문에
	list.put(value);
}

// 8. 리스트 값 하나씩 가져올 때 (int 일 경우)
for(int i = 0; i < list.size(); i++) {
	list.get(i).intValue();
}

// 9. 오름차순 정렬
Collections.sort(list);

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

Collections

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

Collections.reverse(list); // List 뒤집기

Collections.frequency(list, 3); // List 내의 원소 개수 반환

Queue

// 1. 선언
Queue<Integer> q = new LinkedList<>();		// linked list로 선언해야함

// 2. 삽입
q.add(10);			// {10}
q.offer(2);			// {10, 2}

// 3. 프론트값 반환
q.peek();			// 10

// 4. 삭제
q.remove();
q.poll();

// 5. 초기화
q.clear();

// 6. 비었는지
q.isEmpty();

// 7. pair 같은 경우는 그냥 구현해서 사용
static class Node{
        int y;
        int x;
        int dist;
        
        Node(int y,int x,int dist){
            this.y=y;
            this.x=x;
            this.dist=dist;
       }
   }

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

Priority Queue

// 1. 선언
PriorityQueue<Integer> pq = PriorityQueue<Integer>();	// 최소힙
PriorityQeueu<Integer> pq = PriorityQueue<Integer>(Collections.reverseOrder());	// 최대힙

// 2. 삽입
pq.add(3);

// 3. 삭제
pq.remove();

// 4. root 값 추출
pq.peek();

// 5. pair 사용 시 
import java.io.IOException;
import java.util.PriorityQueue;

public class PQ {

    static class Node{
        int y;
        int x;

        Node(int y,int x){
            this.y=y;
            this.x=x;
        }
		
        // 비교 함수 만들어야함!!
        public int compareTo(Node p) {
            if(this.y < p.x) {
                return -1; // 오름차순
            }
            else if(this.y == p.y) {
                if(this.x < p.x) {
                    return -1;
                }
            }
            return 1;
        }
    }

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

        PriorityQueue<Node> pq1=new PriorityQueue<>(Node::compareTo);
        pq1.add(new Node(1,2));
        pq1.add(new Node(1,1));
        pq1.add(new Node(2,3));
        pq1.add(new Node(2,1));

        while(!pq1.isEmpty()){
            Node node=pq1.peek();
            System.out.println(node.y+" "+node.x);
            pq1.remove();
        }
    }
}

Math

// 1. 최대 최소
Math.max(10, 2);
Math.min(10, 2);

// 2. 절대값
Math.abs();

// 3. 올림 내림 반올림
Math.ceil(-3.2);		// -3
Math.floor(-3.2);		// -4
Math.round(-3.26);		// -3	첫째자리에서 반올림

// 3-1. 소수 둘째, 셋째 자리에서 반올림 하고 싶다면
double a = 1.23456;
String b = String.format("%.1f", a);	// .1f는 둘째자리에서 반올림

// 4. 제곱 제곱근
Math.pow(2, 2);		// 2^2 = 4
Math.sqrt(4);		// 2

정렬

// 배열
Arrays.sort(arr); // 오름차순
Arrays.sort(arr, Collections.reverseOrder()); // 내림차순


// 리스트
Collections.sort(list); // 오름차순
Collections.sort(list, Collections.reverseOrder()); // 내림차순
list.sort(Comparator.naturalOrder()); // 오름차순
list.sort(Comparator.reverseOrder()); // 내림차순

Comparable

• 자기 자신과 매개변수 객체를 비교(compareTo)

• 오름차순: 나-너, 내림차순:너-나

// x좌표가 증가하는 순(오름차순), x좌표가 같으면 y좌표가 감소하는 순(내림차순)으로 정렬하라.
class Point implements Comparable<Point> {
    int x, y;

    @Override
    public int compareTo(Point p) {
        if(this.x != p.x) {
            return this.x - p.x; // x에 대해서는 오름차순
        }
        else {
		        return p.y - this.y; // y에 대해서는 내림차순
        }
    }
}

기타

length / length() / size()

• length: 배열의 길이 (arr.length)

• length(): String related object (str.length())

• size(): Collections object (list.size())

// 1. length
int[] arr = new arr[3];
int len1 = arr.length;

// 2. length()
String str = "java";
int len2 = str.length();

// 3. size()
ArrayList<Integer> list = new ArrayList<>();
int len3 = list.size();

숫자 ↔ 문자열 변환

Integer.toString(num); // 숫자 -> 문자열 변환
Integer.parseInt("string"); // 문자열 -> 숫자 변환
Integer.toBinaryString(num); // 숫자 -> 이진수 문자열 변환

배열 ↔ 리스트 변환

// 배열 -> 리스트
String[] temp = {"a", "b", "c"};
List<String> list = new ArrayList<>(Arrays.asList(temp));

// 리스트 -> 배열
List<String> list = new ArrayList<>();
String[] temp = list.toArray(new String[list.size()]);

리스트 배열

static List<Integer>[] nodes;

nodes = new List[N+1];

for(int i = 0; i < N+1; i++) {
	nodes[i] = new ArrayList<>();
}