Java 문법 총 정리

java로 알고리즘 공부를 하며 정리하고자 하는 메서드들 총 정리한 글입니다!

java.util.Arrays

int[] , String[] 같이 Array 타입에 사용 가능한 메서드.

Arrays.copyOfRange(배열, start, end - 1); // start ~ end-1 까지 subArray 리턴
Arrays.asList(컨테이너 타입) -> // 컨테이너를 List타입으로 변환.
Arrays.stream(배열).sum(); // 배열의 합
Arrays.stream(intArray).max().getAsInt() // 배열의 최대
Arrays.stream(intArray).min().getAsInt() // 배열의 최소
Arrays.stream(arr).map(i -> 각 item에 적용).toArray(); // map 속성
Arrays.sort(arr ,[Collections.reverseOrder()]) // [] 있으면 내림차순, 없으면 오름차순. 단 Integer[] 에서만 사용 가능

Arrays.sort(arr, Comparator.comparingInt(o -> o[0])); // int[][]일 때, int[][0]을 기준으로 정렬

---

java.util.Collections

ArrayList, HashSet 등 컬렉션 타입에 사용가능한 메서드

배열의 최대, 최솟값

• Collections.max(arr) : List 타입 배열의 최대값
• Collections.min(arr) : List 타입 배열의 최솟값

배열의 특정 값 count

1. Collections.frequency 사용

int[] arr = {1,2,3,4};
Collections.frequency(Arrays.asList(arr, 1));

2. Arrays.stream.filter().count() 사용하기!

Arrays.stream(array).filter(value -> value == targetValue).count();

컨테이너 타입 정렬

1. Collections.sort() 사용

Collections.sort(list, String.CASE_INSENSITIVE_ORDER) 대소문자 구분 없이 오름차순 정렬.

 

 

2. Comparator를 통해 사용자 정의 정렬 - Comparable 인터페이스 구현

해당 인터페이스는 객체의 Comparable을 구현한 compareTo() 메소드를 참조한다.

static class Pair implements Comparable<Pair> {
    int first, second;
    Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public int compareTo(Pair other) {
        if(this.second != other.second) { // second 기준으로 비교!
            return Integer.compare(this.second, other.second);
        } else if(this.second == other.second) { // second이 같으면 first를 기준으로 비교!
            return Integer.compare(this.first, other.first);
        }
        return 0;
    }
}

ArrayList<Pair> arr = new ArrayList<>();
Collections.sort(arr); // 정렬 시 compareTo() 기준으로 정렬!

---

java.util.List

ArrayList와 LinkedList 등 다양한 List 컨테이너가 존재한다.

arr.get(int index) // 특정 인덱스 값 접근하기
arr.add(값) // 값 넣기
arr.set(index, value) // 값 변경
arr.remove(index) // index에 해당하는 값 삭제
arr.contains(value) // 값 존재 여부 (boolean)
arr.indexOf(value) // 앞에서부터 value에 대한 index 추출
arr.lastIndexOf(value) // 뒤에서부터 value에 대한 index 추출
arr.size() // list 길이

Arrays.stream(arr).boxed().collect(Collectors.toList()); // array -> list로 변환.

ArrayList를 배열로 변환

// List<Integer> -> int[] 변형
ArrayList<Integer> arr = new ArrayList<>();
int[] answer = arr.stream().mapToInt(Integer::intValue).toArray();

// List<String> -> String[]
ArrayList<String> arr = new ArrayList<>();

arr.toArray(new String[0]);

 

---

java.util.Map

Map interface를 기반으로 하는 Map 자료구조 중 기본적으로 HashMap과 입력된 순서대로 데이터를 저장하는 LinkedHashMap, 입력된 key의 오름차순으로 정렬하는 TreeMap이 있다.

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

map.put(key, value); // 값 추가, 키 중복 시 value 대체

map.get(key) // value 가져오기.

map.containsKey(key) // value가 있으면 true, 없으면 false

map.remove(key) // 값 제거

map.size() // map 사이즈 리턴

map.keySet() // 키만 모아서 리턴

map.values() // value만 모아서 리턴

ArrayList<String> keyList = new ArrayList<>(map.keySet()); // List로 리턴 가능

keySet을 array로 보여주기

Map<String, String> hashMap = new HashMap<>();
 
hashMap.put("RED", "#FF0000");
hashMap.put("BLUE", "#0000FF");
 
// 어레이로 반환된 `HashMap`의 키를 가져옵니다.
String[] key = hashMap.keySet().toArray(new String[0]);
 
System.out.println(Arrays.toString(key)); // [RED, BLUE]

value array

Map<String, String> hashMap = new HashMap<>();
 
hashMap.put("RED", "#FF0000");
hashMap.put("BLUE", "#0000FF");
 
// 어레이로 반환된 `HashMap`의 값을 가져옵니다.
String[] values = hashMap.values().toArray(new String[0]);
 
System.out.println(Arrays.toString(values)); // [#FF0000, #0000FF]

Key, value쌍 array 접근하기

Map<String, String> hashMap = new HashMap<>();
 
hashMap.put("RED", "#FF0000");
hashMap.put("BLUE", "#0000FF");
 
Object[] objectArray = hashMap.entrySet().toArray();
 
System.out.println(Arrays.toString(objectArray)); // [RED=#FF0000, BLUE=#0000FF]

// 반복문 돌리기
for (Map.Entry<Integer, Integer> entry : hashMap.entrySet()) {
    entry.getValue(); // value 접근
    entry.getKey(); // key 접근.
}

 

---

java.util.Set

Set 인터페이스를 구현하는 구현체 중, 넣은 순서대로 정렬이 되는 TreeSet, 일반적인 HashSet, 넣은 순서대로 유지가 되는 LinkedHashSet이 있다.

 

문법

Set<Integer> set = new HashSet<>(); // TreeSet, LinkedHashSet 존재

set.add(9) // 값 추가
set.remove(9) // 값 제거

set을 배열로 변환

Integer[] arr = { 1, 1, 2, 3, 4 }; // 배열 -> Set
Set<Integer> set = new HashSet<Integer>(Arrays.asList(arr));

 

배열을 set으로 전환

Set<Integer> set = Sets.newHashSet(1, 2, 3, 4);
Integer[] arr = set.toArray(new Integer[0]); // 참조값 넣기.

 

HashSet <-> ArrayList

ArrayList를 HashSet으로 또는 반대로 변환하고 싶으면 생성자에서 처리해도 된다.

ArrayList<String> list = new ArrayList<>(set);
HashSet<String> set = new HashSet<>(list);

 

---

Queue

자바의 queue는 LinkedList와 같이 사용해야 한다.

import java.util.LinkedList;
import java.util.Queue;

Queue<Integer> queue = new LinkedList<>();

queue.add(1); // 값 삽입에 성공하면 true를 반환, 실패 시 에러 발생
queue.offer(3); // 값 삽입

queue.poll();       // queue에 첫번째 값을 반환하고 제거, 비어있다면 null
queue.remove();     // queue에 첫번째 값 제거

queue.peek();       // queue의 첫번째 값 참조

queue.clear();      // queue 초기화

queue.isEmpty(); // 비어있으면 true 반환

 

 

Deque

 

 

 

Priority Queue

**PriorityQueue**를 사용하기 위해선 우선순위 큐에 저장할 객체는 필수적으로 ```Comparable Interface```를 구현해야한다.

기본적으로 Integer 타입의 PrioirityQueue에서는 ```maxheap``` 구현 시 ```Collections.reverseOrder()```를 사용하면 된다.

우선순위의 기준을 따로 설정하려면 **Comparable Interface**를 구현해야 한다. ```compareTo``` method를 override 하게 되고 해당 객체에서 처리할 우선순위 조건을 리턴해주면 PriorityQueue 가 알아서 우선순위가 높은 객체를 추출 해준다.

**PriorityQueue**는 Heap을 이용하여 구현하는 것이 일반적이다.

데이터를 삽입할 때 우선순위를 기준으로 **최대 힙 혹은 최소 힙을 구성**하고 데이터를 꺼낼 때 루트 노드를 얻어낸 뒤 루트 노드를 삭제할 때는 빈 루트 노드 위치에 맨 마지막 노드를 삽입한 후 아래로 내려가면서 적절한 자리를 찾아 옮기는 방식으로 진행된다.
최대 값이 우선순위인 큐 = 최대 힙, 최소 값이 우선순위인 큐 = 최소 힙

## Priority Queue 특징
1. 높은 우선순위의 요소를 먼저 꺼내서 처리하는 구조이다.
우선순위 큐에 들어가는 원소는 비교가 가능한 기준이 있어야한다.

2. 내부 요소는 힙으로 구성되어 이진트리 구조로 이루어져 있다.

3. 내부구조가 힙으로 구성되어 있기에 시간 복잡도는 O(NLogN)이다.

4. 우선순위를 중요시해야 하는 상황에서 주로 쓰인다.

## Priority Queue 선언
Priority Queue를 사용하려면 ```java.util.PriorityQueue```를 import해야 한다.

```
import java.util.PriorityQueue;
import java.util.Collections;

//낮은 숫자가 우선 순위인 int 형 우선순위 큐 선언
PriorityQueue<Integer> priorityQueueLowest = new PriorityQueue<>();

//높은 숫자가 우선 순위인 int 형 우선순위 큐 선언
PriorityQueue<Integer> priorityQueueHighest = new PriorityQueue<>(Collections.reverseOrder());
```

## <중요> 사용자 지정 comparable

Queue의 Type을 사용자 지정 클래스로 선언해준 뒤, 해당 클래스에 compareTo() 메서드를 오버라이딩하여 우선순위를 결정해준다. 

compareTo에서 ```1을 리턴하는 경우```는 this.n의 값이 우선순위가 더 높은 경우(즉, Queue에서 가장 먼저 뽑힘)이며, ```-1을 리턴하는 경우```는 other.n의 값이 우선순위가 더 높다는 뜻이다.

```
static class Int implements Comparable<Int> {
    int n;

    public Int(int n) {
        this.n = n;
    }

    @Override
    public int compareTo(Int other) {
        if (Math.abs(this.n) > Math.abs(other.n)) {
            return 1;  // 작은 절댓값이 먼저 나옴
        } else if (Math.abs(this.n) < Math.abs(other.n)) {
            return -1; //
        } else {
            return Integer.compare(this.n, other.n);
        }
    }
}
```

## PrioirityQueue 사용
- 값 추가
기존의 Queue 모듈과 동일.

- 제거
```
// 첫번째 값을 반환하고 제거 비어있다면 null
priorityQueueLowest.poll();

// 첫번째 값 제거 비어있다면 예외 발생
priorityQueueLowest.remove(); 

// 첫번째 값을 반환만 하고 제거 하지는 않는다.
// 큐가 비어있다면 null을 반환
priorityQueueLowest.peek();

// 첫번째 값을 반환만 하고 제거 하지는 않는다.
// 큐가 비어있다면 예외 발생
priorityQueueLowest.element();

// 초기화
priorityQueueLowest.clear();    
```

---
# java.util.StringTokenizer
```
StringTokenizer st = new StringTokenizer(문자열, 구분자, boolean flag);
```
- ```flag``` : 구분자까지도 토큰으로 처리할 것인지 여부. 
- 문자열을 구분자 기준으로 쪼개 토큰처리할 수 있다.

---

# java.lang.String
String 클래스는 빌트인 클래스이므로 따로 import 필요 없이 사용 가능하며, 문자열과 관련된 작업을 할 때 유용하게 사용할 수 있는 다양한 메소드가 포함되어 있다.

```
1. s.substring(start, [end-1]) // 문자열을 설정한 index를 토대로 slice해주는 메서드

ex>
String s = "asdf";
s.substring(1,2); // s
s.substring(2); // as

2. s.slice(char) // string을 char 기준으로 slice하여 배열을 리턴해주는 메서드

ex>
s.slice('s'); // ['a', 'df'] 

3. str.repeat(n) // 문자열 반복 -> str을 n번 반복한다.
4. str.replaceAll(before, after) // before을 전부 after로 바꿈

ex>
s.replaceAll("[^\\w+]", ""); // [ ^ \ \ w + ] 를 전부 공백으로!
```


## 문자열 반복
- ```str.repeat(n)```

---

# java.lang.StringBuilder

sString 클래스는 인스턴스를 생성할 때 지정된 문자열을 변경할 수 없지만 StringBuilder 클래스는 변경이 가능하다!

## 주요 메서드
- .append( ) : StringBuffer 인스턴스가 저장하고 있는 문자열 뒤에 덧붙인다

- .delete(int start, int end) : 시작위치(start) 부터 끝 위치(end) 사이에 있는 문자를 제거한다 (단, 끝 위치의 문자는 제외!)

- .deleteCharAt(int index) : 지정된 위치(index)의 문자를 제거한다.

- .insert(int pos, String str) : 두번째 매개변수로 받은 값을 문자열로 변환하여 지정된 위치(pos)에 추가한다. (pos는 0부터 시작)

- .replace(int start, int end, string str) : 지정된 범위(start ~ end)의 문자들을 주어진 문자열로 바꾼다. (end 위치의 문자는 범위에 포함 되지않는다!)

- .reverse( ) : 문자열의 순서를 거꾸로 나열한다.

- .setCharAt(int index, char ch) : 지정된 위치의 문자를 주어진 문자(ch)로 바꾼다

- .toString( ) : StringBuffer 인스턴스의 문자열을 String으로 반환한다.

- .subString(int start) or .subString(int start, int end)
: 지정된 범위 내의 문자열을 String으로 뽑아서 반환한다.