[Java] 기본 함수 - 1

🫠 코테에서 자주 쓰는 Java 기본 함수 1편

 

1. char

char ch = 'a';

Character.isUpperCase(ch); // (ch는 대문자인가? false)
Character.isLowerCase(ch); // (ch는 소문자인가? true)

Character.isLetter(ch); // (ch는 문자인가? true)
Character.isDigit(ch);  // (ch는 숫자인가? false)
Character.isWhitespace(ch); // (ch는 공백문자인가? false)

Character.toUpperCase(ch); // (대문자로 A)
Character.toLowerCase(ch); // (소문자로 a)

String str = Character.toString(ch); // (문자를 문자열로, 또는 ch + "";)

a + 0; // (문자 유니코드값 97)

char ch2 = '3';
Character.getNumbericValues(ch2); // (char를 int로 3)

 

2. String

String str = "abcde";

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

str.charAt(0);      // (인덱스로 문자 찾기)
str.indexOf(b);     // (문자로 첫번째 인덱스 찾기)
str.lastIndexOf(d); // (문자로 마지막 인덱스 찾기)

str.startsWith("ab"); // (str은 ab로 시작하는가? true)
str.endsWith("ef");   // (str은 ef로 끝나는가? false)

str.substring(0,2); // (0~1 문자 반환)
str.subsrting(3);   // (3~ 문자 반환)

str.replace('b', 'x');  // (b를 x로 변경)
str.replace("ab", "x"); // (ab를 x로 변경)

str.toUpperCase(); // (전부 대문자로)
str.toLowerCase(); // (전부 소문자로)

str.compareTo("abcdf"); // (사전순 str이 앞이면 -1, 같으면 0, 뒤면 1)

Integer.parseInt("123"); // (String을 int로)
Integer.toString(123);   // (int를 String로, 또는 123 + "")

String[] Arr = str.split(""); // (str을 "" 기준으로 String배열로)

 

3. StringBuilder

StringBuilder sb = new StringBuilder();

sb.append("abc");   // (문자열 추가)
sb.insert(2, "X");  // (2 위치에 X 삽입)

sb.delete(0, 2);    // (0~1 문자 삭제)
sb.deleteCharAt(2); // (2 문자 삭제)

sb.setCharAt(0, 'y'); // (0 문자 y로 변경)

sb.reverse(); // (문자열 반전)

sb.setLength(1); // (문자열 길이 1로)
sb.setLength(3); // (문자열 길이를 3으로, 뒤 자리는 공백)

StringBuilder sb = new StringBuilder(str); // (String을 StringBuilder로)
String str = sb.toString(); // (StringBuilder를 String으로)

 

4. Arrays

int arr[] = {4, 3, 1, 2, 0};

Arrays.sort(arr); // (오름차순 정렬)
Arrays.sort(arr, 0, 4); // (0~3 부분 정렬)

Integer arr2[] = {4, 1, 3, 2, 0};
Arrays.sort(arr2, Collections.reverseOrder()); // (내림차순 정렬, Integer형 사용가능)

Arrays.binarySearch(arr, 6); // (값이 6인 요소의 최초 인덱스 반환, 오름차순 정렬 必)


int arr3[] = Arrays.copyOfRange(arr, 0, 3); // (0~2 배열 자르기)
int arr4[] = Arrays.copyOf(arr1, 3); // (3만큼 배열 복사 {4, 3, 1})
int arr5[] = Arrays.copyOf(arr1, 7); // (7만큼 배열 복사 {4, 3, 1, 2, 0, 0, 0})


Arrays.fill(arr, 1); // (모든값을 1로 초기화)

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

 

5. List

List<String> list = new ArrayList<>();
List<String> list2 = new ArrayList<>(Arrays.asList("c", "d"));

list.add("b")      // (가장 뒤에 b 삽입)
list.add(0, "a")   // (0에 a 삽입)
list.addAll(list2) // (list의 뒤에 list2의 모든 값 삽입)

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

list.indexOf("b")     // ("b"의 첫번째 인덱스 찾기)
list.lastIndexOf("b") // ("b"의 마지막 인덱스 찾기)

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

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

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

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

 

※ 배열 형변환

List<String> list = new ArrayList<>(Arrays.asList(arrStr)); // (String배열을 List로)

List<String> list = new ArrayList<>();
String[] arrStr = list.toArray(new String[list.size()]); // (List를 String배열로)

//

List<Integer> list = new ArrayList<>(Arrays.asList(arrInt)); // (int배열을 List로)

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

 

6. Collection

int[] arr = {4, 3, 0, 1, 2, 0};
List<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 순서 반전)

Collections.frequency(list, 0) // (list 내 특정요소(0) 등장횟수)

Collections.binarySearch(list, 3) // (값이 3인 요소의 최초 인덱스 반환, 오름차순 정렬 必)

 

7. Math

int a = -3, b = 7;

Math.max(a, b); // (최댓값 반환 7)
Math.min(a, b); // (최솟값 반환 -3)

Math.abs(a); // (절댓값 반환 3)

Math.ceil(-1.64);  // -1.0 (올림)
Math.floor(-1.64); // -2.0 (내림)
Math.round(-1.64); // -2 (소수점이하 반올림)

double a = 1.2345;
String b = String.format("%.1f", a);
double c = Double.parseDouble(b); // (.1f 소수점 둘째 반올림 1.2, .3f 넷째 반올림 1.235)

Math.pow(2, 4);	// (2의 4제곱 16.0)
Math.sqrt(16);	// (16의 제곱근 4.0)

// Math클래스의 메서드들은 대부분 double형식의 값을 반환한다

 

8. Integer

int num1 = 10, num2 = 20;

Integer.max(num1, num2); // (최댓값 반환 20)
Integer.min(num1, num2); // (최솟값 반환 10)

Integer.toBinaryString(num1);	// (num1 > 2진수 1010)
Integer.toOctalString(num1);	// (num1 > 8진수 12)
Integer.toHexString(num1);	    // (num1 > 16진수 a)