[Java] 자바 문법

🤜 라이브러리

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

🤜 입력

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[][] times = new int[n][2];
for (int i = 0; i < n; i++) {
    times[i][0] = sc.nextInt();
    times[i][1] = sc.nextInt();
}
String s = sc.next();

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int num = Integer.parseInt(br.readLine());
int[][] points = new int[num][2];
        StringTokenizer st;
        for(int i = 0; i < num; i++){
            st = new StringTokenizer(br.readLine(), " ");
            points[i][0] = Integer.parseInt(st.nextToken());
            points[i][1] = Integer.parseInt(st.nextToken());
        }

🤜 Character 관련 메소드

String str = "abcde";
Character.isLetter(str.charAt(1)) // char 값이 문자이면 true 아니면 false로 리턴
Character.isDigit(str.charAt(1)) // char 값이 숫자이면 true 아니면 false
Character.isLetterOrDigit(str.cahrAt(1)) // char 값이 문자 혹은 숫자 인지
Character.isAlphabetic(str.charAt(1)) // char 값이 알파벳이면 true 아니면 false

// 대소문자 확인
Character.isLowerCase('a') // true
Character.isUpperCase('A') // true

// 대소문자 변경
Character.toUpperCase('a') // A
Character.toLowerCase('A') // a 

// 문자 그대로 숫자를 얻을 때
char c = '1';
int n = Character.getNumericValue(c) // 1

🤜 아스키 코드

// 알파벳
대문자 'A': 65 ~ 'Z': 90, 소문자 'a': 97 ~ 'z': 122
대소문자 차이는 32 -> 소문자 - 32 = 대문자

// 숫자
'0' : 48 ~ '9': 57

// int 와 char 연산할 때는 char는 숫자(아스키 번호)로 연산함 
public int solution(String str){
      int answer = 0;
      for(char x : str.toCharArray()){
          if( x >= '0' && x <= '9') answer = answer * 10 + (x-'0'); 
          // if( x >= 48 && x <= 57) answer = answer * 10 + (x-48); 두개 동일
      }
      return answer;
 }

// int형에 char형을 넣으면 아스키 넘버가 됨
char c = '1';
int n = c; // int n = (int) c; 같음 n은 49

// char형 int 형 넣으면 아스키 코드
int n = 49;
char c = n; // '1'

// 숫자 + '0' => 문자
int a = 3;
char b = a + '0'; // b는 '3'

// 문자 - '0' => 숫자
int c = b - '0' // c는 3 

🤜 String 관련 메소드

String str = "abcde";

str.length() // str의 길이 반환
str.isEmpty() // str의 길이가 0이면 true, 아니면 false

str.charAt(2) // 인덱스로 문자 찾기, c 반환
str.indexOf("c") // 문자로 첫번째 인덱스 찾기, 2 반환
str.lastIndexOf("c") // 문자의 마지막 인덱스 찾기, 2 반환

str.substring(2, 4) // 2~3 위치의 문자열 "cd" 반환
str.substring(3) // 3부터 끝까지의 문자열 "de" 반환

str.replace('b', 'k') // b를 k로 변경 (akcde)
str.replaceAll(변환하고자 하는 문자열 또는 정규식, 변환할 문자 값)
str.replaceAll("[^A-Z]", "") // 알파벳이 아닌 것들은 ""로 치환

str.equals("abcde") // str과 abcde를 비교해서 같으면 true, 다르면 false
str.equalsIgnoreCase("ABcde") // true 대소문자 무시하고 비교 
str.contains("bc") // str에 bc가 포함되어 있으면 true, 아니면 false

str.trim() // str의 앞뒤 공백 제거, 문자열 사이 공백은 제거 X

str.toLowerCase() // 대문자를 모두 소문자로 변경
str.toUpperCase() // 소문자를 모두 대문자로 변경

/*
str과 abcdd가 같으면 0
str이 abcdd보다 사전순으로 앞이면 -1
str이 abcdd보다 사전순으로 뒤면 1
str과 abcdd가 마지막 문자만 다르면 마지막 문자의 사전순 차이 반환 (여기선 1)
*/
str.compareTo("abcdd")

// 숫자 or 문자 + ""(빈 문자열) => 문자열
String a = 3 + "" ; // "3"
String a = '3' + ""; // ""

// 문자열 -> 기본형
Integer.parseInt("300") // 문자열을 숫자로 변환
Integer.parseInt("10011", 2) // 문자열을 숫자 2진수로 생각하고 십진수로 변환 19

// 기본형 -> 문자열
Integer.toString(300) // 숫자를 문자열로 변환
String.valueOf(300) // 문자열로 변환
char[] s = {'a','b','c'}
String.valueOf(s) // char배열 문자열로 변환 "abc"

// 문자열을 배열로 만들고 싶을 때
String str = "12345";
String[] Arr = str.split(""); // {1,2,3,4,5}

// 문자열을 char 배열로 만들 때
char[] charArr = str.toCharArray();

🤜 정규식

[A-Z]
[a-z]
[^A-Z]

[0-9]
[^0-9]

🤜 StringBuilder 관련 메소드

String은 한 번 만들어지면 문자를 추가하거나 삭제할 수 없는 변경 불가한 타입, StringBuilder는 변경 가능한 타입이므로 문자열을 변경해야 하는 문제에서는 StringBuilder를 사용한다. (String Buffer는 동기화 가능 StringBuilder는 불가능. 동기화가 필요 없을 시 StringBuilder를 사용 하는 것이 더 효율적 )

StringBuilder sb = new StringBuilder();
StringBuilder sb2 = new StringBuilder("abc");

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로 늘림 (→ 뒤가 공백으로 채워짐)

sb.toString() // String으로 변환

🤜 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. 제곱 제곱근
double a = Math.pow(2, 3);		// 2^3 = 8 => double형
int a = (int) Math.pow(2, 3);
Math.sqrt(4);		// 2

🤜 Array 관련 메소드

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

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

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

// 배열을 ArrayList로 변환
List list = Arrays.asList(arr1); // 읽기 전용
ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(arr1));

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

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

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

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

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

// 2차원 배열 행 정렬
Arrays.sort(times, new Comparator<int[]>() {
						// 정렬 기준 함수만 원하는대로 변경
            @Override
            public int compare(int[] o1, int[] o2) { // 행이 들어옴
                if(o1[1] == o2[1]) return o1[0] - o2[0];
                else return o1[1] - o2[1];
            }
}); 
/* 
반환 값이 양수이면 자리를 바꿔주고, 음수이면 자리를 바꿔주지 않음 
-> 위의 예시는 두번째 열을 기준으로 오름차순, 값이 같다면 첫번째 열을 기준으로 오름차순
*/

// Arrays 클래스의 sort static method
static void sort(Object[] objArr, Comparator c){
	for(int i = 0; i < objArr.length-1; i++){
		for(int j = 0; j < objArr.length-1; j++){
				Object tmp = null;
				if(c.compare(objArr[j], objArr[j+1]) > 0){ // 비교
						tmp = objArr[j]; // 자리바꿈
						objArr[j] = objArr[j+1];
						objArr[j+1] = tmp;
				}
		}	
	}
}

// 객체를 생성하고 나서 복제
int[] tmp = arr.clone();

// 배열에서 최대값
int max = Arrays.stream(arr).max().getAsInt();

// 배열에서 최솟값
int min = Arrays.stream(arr).min().getAsInt();

// 배열 모든 값 합
int sum = Arrays.stream(arr).sum();

🤜 ArrayList 관련 메소드

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

list.add("서울") // list의 가장 뒤에 서울 삽입
list.add(1, "대전") // 1 위치에 대전 삽입
list.addAll(list2) // list의 뒤에 list2의 모든 값 삽입

list.get(0) // 0 위치의 값 반환 (서울)
list.set(0, "대구") // 0 위치의 값을 대구로 변경

list.indexOf("대구") // 대구의 첫번째 인덱스 반환
list.lastIndexOf("대구") // 대구의 마지막 인덱스 반환

list.remove(0) // 0 위치의 값 삭제
list.remove("대구") // 첫번째 대구 삭제
list.removeAll(list2) // list에서 list2에 들어있는 모든 값을 삭제
list.retainAll(list2) // list에서 list2에 들어있는 값을 제외한 모든 값을 삭제

list.clear() // 전체 값 삭제
list.isEmpty() // 길이가 0이면 true, 아니면 false
list.size() // 길이

list.contains("서울") // 서울이 list에 있으면 true, 없으면 false
list.containsAll(list2) // list에 list2의 모든 값이 포함되어 있으면 true

list.removeIf(k -> k % 2 != 0) // 람다식으로 홀수를 list에서 모두 제거

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

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

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

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

🤜 Collections 관련 메소드

int[] arr = { 1123, 1412, 23, 44, 512132 };
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(arr));

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

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

Collections.reverse(list) // list 역순 정렬 { 512132, 44, 23, 1412, 1123 }

Collections.frequency(list, 23) // list 내의 23의 갯수 반환

Collections.binarySearch(list, 44)
// 최초로 검색된 44의 인덱스 1 반환
// 없으면 44보다 큰 최초의 위치 2를 찾아서 -1을 곱하고 1을 빼서 반환 (-3)

🤜 Stack

Stack<Integer> stack = new Stack<>();

stack.push(1) // 값 추가
stack.pop() // Stack top 꺼내고 반환
stack.clear() // 값 전체삭제
stack.size() // 크기 반환
stack.isEmpty() // 비어있으면 true, 아니면 false
stack.contains(1) // 1을 포함하고 있으면 true, 아니면 false
stack.peek() // Stack top 출력 (제거 X), 비어있으면 null 반환
stack.get(0) // stack은 배열, get으로 접근 가능 -> 첫번째 데이터 반환 1 

🤜 Queue

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

queue.add(1) // 값 추가
queue.offer(2) // 값 추가
queue.poll() // 첫 번째 값 꺼내고 반환, 비어있으면 null 반환
queue.remove() // 첫 번째 값 제거
queue.clear() // 값 모두 삭제
queue.peek() // 첫 번째 값 출력 (제거 X)
queue.contains(1) // 1을 포함하고 있으면 true, 아니면 false

🤜 PriorityQueue

PriorityQueue<Integer> pq = new PriorityQueue<>();
// 기본은 낮은 숫자가 우선순위를 갖는다.
// 높은 숫자가 우선되게 하려면 () 안에 Collections.reverseOrder() 작성

pq.add(1) // 값 추가
pq.offer(1) // 값 추가
pq.poll() // 첫 번째 값 반환, 비어있으면 null 반환
pq.remove() // 첫 번째 값 제거
pq.clear() // 값 모두 삭제
pq.peek() // 첫 번째 값 출력 (제거 X)

🤜 HashSet

중복 허용하지 않을 때는 Set 사용

• HashSet : 중복을 허용하지 않는 구조. 순서가 없고 정렬도 안 함.
• LinkedHashSet : 중복을 허용하지 않는 구조. 삽입된 순서대로 순서를 관리함.
• TreeSet : 중복을 허용하지 않는 구조. 이진탐색트리 형태로 데이터를 저장하므로 정렬 함.

HashSet<Integer> set = new HashSet<>();

set.add(1) // 값 추가
set.remove(1) // 값이 1인 데이터 삭제
set.removeAll(set2) // set의 데이터 중 set2에 들어있는 데이터를 모두 삭제
set.retainAll(set2) // set의 데이터 중 set2에 들어있지 않은 데이터를 모두 삭제 (set2 데이터만 남기기)
set.clear() // 모든 데이터 삭제
set.size() // 크기 반환
set.contains(1) // 값 1이 있으면 true, 없으면 false

// 값 출력
// 방법 1: get 메소드가 없으므로 원소에 접근하려면 이터레이터 사용
Iterator iter = set.iterator();
while (iter.hasNext())
	System.out.println(iter.next());

// 방법 2: for-each문으로 원소에 접근
for (String item: set)
	System.out.println(item);

🤜 TreeSet

중복 허용하지 않고 정렬 필요할 때 사용

// 선언
TreeSet<Integer> ts = new TreeSet<>(); // 오름차순 정렬
TreeSet<Integer> ts = new TreeSet<>(Collections.reverseOrder()); // 내림차순 정렬

// 추가
ts.add(5);
ts.add(2);
ts.add(1); 
ts.add(3); // [1,2,3,5]

// 값 반환
ts.first(); // 첫 데이터 반환 1
ts.last(); // 마지막 데이터 반환 5

// 삭제
ts.remove(5); // 5 삭제 [1,2,3]
ts.pollFirst(); // 첫 데이터 삭제 [2,3]
ts.pollLast(); // 마지막 데이터 삭제 [2]
ts.clear(); // 전체 삭제 []

// 크기
ts.size()

// 출력 (위 HashSet참고)
1. iterator 사용
2. for-each 문으로 원소에 접근

🤜 HashMap

• HashMap: <key, value>쌍. 특정 규칙 없이 출력됨.
• LinkedHashMap: <key, value>쌍. 키값이 입력순으로 정렬되어 출력됨.
• TreeMap: <key, value>쌍. 키값이 알파벳순(오름차순)으로 정렬된 상태로 출력됨.

// 선언
HashMap<Integer, String> map = new HashMap<>();
HashMap<String, String> map = new HashMap<>();

// 입력 (key, value)
map.put(1, "사과")
map.put(2, "바나나")
map.put(1, "포도") // key 1이 이미 존재하면 key 1의 value가 "포도"로 대체
/* 
getOrDefult(Object key, V defaultValue)
key: 값을 가져와야 하는 요소의 키
defaultValue: 지정된 키로 매핑된 값이 없는 경우 반환되어야 하는 기본 값
반환값: 찾는 key가 존재하면 해당 key에 매핑되어 있는 값을 반환, 아니는 dfaultValue를 반환
*/
hm.put(key, hm.getOrDefault(key,0)+1)

// key로 value가져오기
map.get(1) // "사과"

// 삭제
map.remove(1) // key 값으로만 요소 삭제 가능
map.clear() // 전체 삭제

// 존재 유무 확인
map.containsKey(1) // key 값 중 1이 있으면 true, 없으면 false
map.containsValue("사과") // value 중 "사과"가 있으면 true, 없으면 false

// 크기
map.size() // 3

// equals
map1.equals(map2) // map1과 map2는 동일한 (key, value)쌍을 가지면 true, 아니면 false

// 값 출력
// 방법 1
for (Integer key: map.keySet())
	System.out.println(i + map.get(key)); // 1 사과

// 방법 2: key와 value가 모두 필요할 때 주로 사용
for (Entry<Integer, String> entry: map.entrySet())
	System.out.println(entry.getKey() + entry.getValue()); // 1 사과

 

---

source

https://velog.io/@hygge/Java-%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8-%EB%AC%B8%EB%B2%95-%EC%86%8D%EC%84%B1-%EC%A0%95%EB%A6%AC

[Java] 코딩테스트 문법 속성 정리 (1)