티스토리 뷰
라이브러리
/* 라이브러리 */
import java.util.*;
import java.io.*;
형 변환
- char
char var = '3';
// char 형을 Int 형으로
int result = Character.getNumericValue(var);
- String
//Int 형을 String 형으로
int val = 1;
String result = Integer.toString(val);
String result2 = "" + val;
//Double 형을 String 형으로
double val;
String result = Double.toString(val);
//long 형을 String 형으로
long val;
String result = Long.toString(val);
//float 형을 String 형으로
float val;
String result= Float.toString(val);
//char 형을 String 형으로
char val;
String result = Character.toString(val);
- Integer
//String 형을 Integer형으로
String val;
int result = Integer.parseInt(val);
int result2 = Integer.valueOf(val).intValue();
- Long
//String 형을 long 형으로
String val;
long result = Long.valueOf(val).longValue();
long result2 = Long.parseLong(val);
- Double
//String 형을 double 형으로
String val;
double result = Double.valueOf(val).doubleValue();
double result2 = Double.valueOf(val);
- Float
//String 형을 float 형으로
String val;
float result = Float.valueOf(val).floatValue();
float result2 = Float.parseFloat(val);
- List
//set => List 변경
Set<String> val = new HashSet<String>();
List<String> result = new ArrayList<>(val);
배열
- String
String[] val = new String[5];
//String배열을 int배열로 변환
int[] result = Arrays.stream(val).mapToInt(Integer::parseInt).toArray();
- Integer
int[] result = {1, 2, 3};
int val = 3;
int[] result = new int[val];
int[] result = new int[] {1,3,5,2,4};
- List
List<Integer> val = new ArrayList<>();
val.add(1);
val.add(2);
//List를 배열로 변경
int[] result = val.stream()
.mapToInt(i -> i)
.toArray();
- Arrays
int val[] = { 8, 10, 12, 2, 0, 5};
// 오름차순 {0, 2, 5, 8, 10, 12}
Arrays.sort(val);
// 내림차순 {12, 10, 8, 5, 2, 0}
Arrays.sort(val, Collections.reverseOrder());
// 일부 정렬 {2, 8, 12, 10, 5, 0}
Arrays.sort(val, 0, 4)
// 오름차순 정렬하면 binary search로 특정 값을 찾을 수 있음
Arrays.binarySearch(val, 2);
// 배열을 Arrays로 변환
List result = Arrays.asList(val);
// 배열의 특정 범위 자르기
int result[] = Arrays.copyOfRange(val, 0, 3);
- ArrayList
ArrayList<String> val = new ArrayList<>();
// 추가
val.add("hello"); // {"hello"}
val.add(0, "world"); // {"world", "hello"} (0번째 인덱스에 추가)
// 수정
val.set(1, "c++"); // {"world", "c++"}
// 삭제
val.remove(1); // {"world"}
// 값 존재 유무 확인
val.contains("hello"); // false
val.indexOf("world"); // 0 존재하면 인덱스 리턴
// 오름차순 정렬
Collections.sort(val);
// 오름차순 정렬 (대소문자 구분 없이)
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
// 내림차순 정렬
Collections.sort(val, Collections.reverseOrder());
// 내림차순 정렬 (대소문자 구분 없이)
Collections.sort(list, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));
// 값이 String인 경우
val.get(i);
// 값이 Integer인 경우
val.get(i).intValue();
// 2차원 배열값 출력
int[][] val = {{1,2,3,4,5},{5,4,3,2,1}};
Arrays.deepToString(val);
// 중복제거
List result = val.stream().distinct().collect(Collectors.toList());
// 특정 범위 자르기
val.subList(0, testData.size() - 1);
// 최대값 MAX 구하기
Collections.max(val);
// 최소값 MIN 구하기
Collections.min(val);
- HashMap
HashMap<String, Integer> val = new HashMap<>();
// Key-Value
val.put("hello", 0);
// Key로 값 가져오기
val.get("hello");
// containsKey()로 존재 확인
if (!val.containsKey("hello")){
val.put("hello", 1);
}
// 특정 키가 없으면 값(3) 설정, 있으면 Key("hello")의 값 가져오는 함수
val.put("hello", val.getOrDefault("hello", 3);
// keySet() 함수
for(String key : val.keySet()) {
val.get(key);
}
// 정렬
Map<Integer, Integer> val = new HashMap<Integer, Integer>();
val.put(1, 8);
val.put(2, 3);
val.put(3, 6);
val.put(4, 9);
val.put(5, 3);
List<Integer> result = new ArrayList<>(val.keySet());
//List<String> result2 = new ArrayList<>(val.keySet());
// 오름차순
Collections.sort(result, (o1, o2) -> (val.get(o1).compareTo(val.get(o2))));
// 내림차순
Collections.sort(result, (o1, o2) -> (val.get(o2).compareTo(val.get(o1))));
- Queue
Queue<Integer> val = new LinkedList<>();
// 추가
val.add(7); // {7}, Queue가 꽉찬 경우 예외 발생
val.offer(2); // {7, 2}, Queue가 꽉찬 경우 false Return
// 맨 위에 저장된 객체를 반환 (값은 그대로)
val.peek(); // 7
// 삭제
val.remove();
val.poll(); //맨 위에 저장된 객체를 꺼냄
// 초기화
val.clear();
// 비었는지 확인
val.isEmpty();
// [pair] - (편리하다 / BFS)
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> val = new LinkedList<>();
val.add(new Node(1,3,5));
Node result = val.poll();
- PriorityQueue (우선순위 큐)
// 최소힙
PriorityQueue<Integer> val = PriorityQueue<Integer>();
// 최대힙
PriorityQeueu<Integer> val = PriorityQueue<Integer>(Collections.reverseOrder());
// 삽입
val.add(5);
// 삭제
val.remove();
// root 값 추출
val.peek();
// [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();
}
}
}
- Iterator
Iterator result = val.iterator();
// 인덱스 오름차순
while (val.hasNext()) {
...
}
// 인덱스 내림차순
while (val.hasPrevious()) {
...
}
// 중복없이 값을 넣고 싶을 때
if (val.indexOf(value) < 0) { // 없으면 -1을 리턴하기 때문에
val.put(value);
}
// 리스트 값 하나씩 가져올 때 (int 일 경우)
for(int i = 0; i < val.size(); i++) {
val.get(i).intValue();
}
함수
- length / length() / size()
// length
int[] val = new int[3];
val.length;
// length()
String val = "java";
val.length();
// size()
ArrayList<Integer> val = new ArrayList<>();
val.size();
- String
String val = "123^4567^890";
// 문자열 자르기
val.substring(int start) : start부터 끝까지
val.substring(int start, int end) : start부터 end까지
// char 자르기
for(int i = 0; i < val.length(); i++){
char result = val.charAt(i);
}
// 문자열을 배열
String[] result = val.split("^");
// 대소문자 변경
String result = val.toUpperCase(); // HELLO WORLD
String result2 = val.toLowerCase(); // hello world
// 문자열 일치 여부 검사
boolean result = val.equals("Hello Java");
// 문자열에 포함된 문자 검사
boolean result = val.contains("efg");
// 문자열 시작 또는 끝나는 문자 검사
boolean result = val.startWith(String s) // 문자열 s로 시작하는지 검사 한다.
boolean result2 = val.endsWith(String s) // 문자열 s로 끝나는지 검사 한다.
// 문자열 치환
String result = val.replace("890","999"));
// 문자열 좌우의 공백 없애기
String result = val.trim();
// 문자열 대소문자 바꾸기
String result = val.toLowerCase(); // 대문자를 소문자로
String result = val.toLowerCase(); // 소문자를 대문자
// 문자열 반복
"abc".repeat(3); // abcabcabc
// 문자열 바꾸기
String[] digits = {"0","1","2"};
String[] alphabets = {"zero","one","two"};
val = val.replaceAll(digits[i], alphabets[i]);
- valueOf
// 다른 자료형으로 변환하기
String result = valueOf(boolean val);
String result = valueOf(char val);
String result = valueOf(int val);
String result = valueOf(long val);
String result = valueOf(float val);
String result = valueOf(double val);
String result = valueOf(Object val);
- Math
// 최대 최소
Math.max(10, 2); // 10
Math.min(10, 2); // 2
// 절대값
Math.abs();
double result = Math.abs(1972.98); // 1972.98
int result2 = Math.abs(-197); // 197
// 올림 내림 반올림
// ceil : 인수보다 크거나 같은 정수를 반환
Math.ceil(-2.2); // -2
Math.ceil(-30.54) // -30.0
Math.ceil(200.34) // 201.0
// floor : 인수보다 작거나 같은 정수를 반환
Math.floor(-3.2); // -4
Math.floor(19824.34) // 19824.0
Math.floor(2133.33) // 2133.0
Math.floor(-2133.33) // -2134.0
// round : 인수를 반올림하여 반환
Math.round(-7.38); // -7 첫째자리에서 반올림
Math.round(-23.23) // -23
Math.round(34.53) // 35
//rint : 인수와 가장 가까운 정수를 반환
Math.rint(-34.3) // -34.0
Math.rint(24.3) // 24.0
// 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
//random : 난수를 반환한다. (0.0. ~ 1.0)
double val = Math.random();
int result = (int)(Math.random()*정수);
- 2진수 문자열 s를 10진수로
int result = Integer.parseInt(val, 2);
- Comparator 비교
// 정렬
Arrays.sort(result, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//비교
return ((o2 + o1).compareTo(o1 + o2));
}
});
//오름차순 : (o2+o1).compareTo(o1+o2)
//내림차순 : (o1+o2).compareTo(o2+o1)
댓글