[java] 코딩테스트 대비 java 클래스 별 메소드 정리 (1 / 2)

java 코딩테스트 대비

 

 

⚠ 작성자 본인의 학습을 위한 메서드 정리입니다.

java 기준 코딩테스트 간 자주 사용하는 메서드를 정리한 글입니다.
신빙성 있는 글이 아니므로 반박시 님 말이 맞습니다.
메서드에 static이 붙는 경우는 클래스로 호출, 아닌 경우는 인스턴스로 호출이 기본입니다.

 

 

Integer 클래스 (java.lang.Integer)

10진법 → n진법 변환 : public static String toString

public static String toString(int i, *int radix)

매개변수 int i를 기존 10진법 -> int radix 값의 진법으로 변환해 String으로 반환합니다.
* radix 생략 시 매개변수 int i를 10진법에 따라 String으로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.toString(9, 2));
        // out : "1001"
        System.out.println(Integer.toString(300));
        // out : "300"
    }
}

 

n진법 → 10진법 변환 : public static int parseInt

public static int parseInt(String s, *int radix)

매개변수 String s를 int radix 값의 진법 -> 10진법으로 변환해 int로 반환합니다.
* radix 생략 시 매개변수 String s를 10진법 → 10진법의 int로 변환해 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.parseInt("1001", 2));
        // out : 9
		System.out.println(Integer.parseInt("300")); 
        // out : 300
    }
}

 

n진법 → 10진법 변환 : public static Integer valueOf

public static Integer valueOf(String s, *int radix)

매개변수 String s를 int radix 값의 진법 -> 10진법으로 변환해 Integer로 반환합니다.
* radix 생략 시 매개변수 String s를 10진법 -> 10진법으로 변환해 Integer로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.valueOf("100",2));
        // out : 4
        System.out.println(Integer.valueOf("100"));
        // out : 100
    }
}

 

최대 / 최솟값 반환 : public static int max, min

public static int max(int a, int b), min(int a, int b)

매개변수 두 개의 int a, b 중 더 큰, 더 작은 수를 int로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.max(35, 42));
        // out : 42
        System.out.println(Integer.min(35, 42));
        // out : 35
    }
}

 

최대 / 최소값 저장 : public static int MAX_VALUE, MIN_VALUE

public static int MAX_VALUE, MIN_VALUE

정수가 담을 수 있는 최댓값과 최솟값을 저장합니다.

 

public class Test {
	public static void main(String[] args) {
 
        System.out.println(Integer.MIN_VALUE);  
        // out : -2147483648
        System.out.println(Integer.MAX_VALUE);  
        // out : 2147483647
    }
}

 

 

Character 클래스 (java.lang.Character)

대문자, 소문자 판별 : public static boolean isUpperCase, isLowerCase

public static boolean isUpperCase(char c), isLowerCase(char c)

매개변수 char c가 대문자인지, 소문자인지 판별해 boolean으로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Character.isUpperCase('C'));
        // out : true
        System.out.println(Character.isLowerCase('C'));
        // out : false
    }
}

 

문자, 숫자, 공백 판별 : public static boolean isLetter, isDigit, isWhitespace

public static boolean isLetter(char c), isDigit(char c), isWhitespace(char c)

매개변수 char c가 문자인지, 숫자인지,  공백인지 판별해 boolean으로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Character.isLetter('A'));
        // out : true
        System.out.println(Character.isDigit('9'));
        // out : true
        System.out.println(Character.isWhitespace(' '));
        // out : true
    }
}

 

대문자 / 소문자로 변환 : public static char toUpperCase, toLowerCase

public static char toUpperCase(char c), toLowerCase(char c)

매개변수 char c를 각각 대문자로 소문자로 변경해 char로 반환합니다.
toUpperCase/toLowerCase에 대문자/소문자가 입력되어 있으면 별도 변경 없이 그대로 char로 반환됩니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println(Character.toUpperCase('a'));
        // out : 'A'
        System.out.println(Character.toLowerCase('C'));
        // out : 'c'
        System.out.println(Character.toLowerCase('c'));
        // out : 'c' (변동없음)
    }
}

 

 

정수값으로 변환 : public static int getNumericValue

public static int getNumericValue(char ch)

매개변수 char c를 유니코드 값으로 변환하여 반환합니다.
char c가 정수값이 아닌 경우 -1을 반환합니다.
분수처럼 음이 아닌 정수로 표현할 수 없는 경우에는 -2를 반환합니다.

일반적으로 숫자값을 가진 char을 변환하는데 사용합니다.

public class Test {
    public static void main(String[] args) {
        System.out.println(Character.getNumericValue('4'))
        // out : 4
        System.out.println(Character.toLowerCase('A'));
        // out : 10
        System.out.println(Character.toLowerCase('~'));
        // out : -1
    }
}

 

String 클래스 (java.lang.String)

대문자 / 소문자로 변환 : public String toUpperCase, toLowerCase

public String toUpperCase(), toLowerCase()

String으로 구성되어 있는 인스턴스를 전부 대문자 / 소문자로 바꿔 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        System.out.println("heLlo wOrlD".toUpperCase());
        // out : "HELLO WORLD"
        System.out.println("GOOD bye".toLowerCase());
        // out : "good bye"
    }
}

 

특정 값의 위치, 위치의 값 탐색 : public char charAt, indexOf, lastIndexOf

public char charAt(int index)

매개변수 int index에 위치한 String의 문자를 char로 반환합니다.
▶ index를 계산할 때 공백은 count하지 않습니다.
▶ 범위를 벗어난 index의 문자를 호출하면 StringIndexOutOfBoundsException을 호출합니다.

public int indexOf(String s, *int fromindex)

매개변수 String s의 위치를 String에서 찾아 그중 첫 번째 index를 int로 반환합니다.
▶index를 계산할 때 공백은 count하지 않습니다.
▶* fromindex 인자값을 입력 시 해당 index부터 탐색합니다. (생략가능)
▶찾는 값이 없을 때는 -1을 반환합니다.

public int lastIndexOf(String s, *int fromindex)

매개변수 String s의 위치를 String에서 찾아 그중 마지막 index를 int로 반환합니다.
▶index를 계산할 때 공백은 count하지 않습니다.
▶* fromindex 인자값을 입력 시 해당 index부터 탐색합니다. (생략가능)
▶찾는 값이 없을 때는 -1을 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        String s = "Hello World";
        System.out.println(s.charAt(7));
        // out : o (공백은 계산하지 않음)
        System.out.println(s.charAt(13));
        // out : error (범위 벗어나 호출 실패)
        
        System.out.println(s.indexOf("World"));
        // out : 6 (공백은 계산하지 않음)
        System.out.println(s.indexOf("Where"));
        // out : -1 (찾는 값 없음)
        System.out.println(s.indexOf("Hello", 7));
        // out : -1 (찾는 값 없음, index 7부터 탐색하므로)
    }
}

 

문자열의 길이 확인 : public int length

public int length()

String 인스턴스의 길이를 int로 return합니다.
▶ 공백도 문자열에 포함해 count 합니다.
▶ length() 메서드를 활용해 마지막 index 값을 확인할 때, for문 돌릴 때도 유용합니다.

 

public class Test {
    public static void main(String[] args) {
        String s = "Hello World";
        System.out.println(s.length());
        // out : 11
        System.out.println(s.charAt(s.length()-1));
        // out : 'd'
    }
}

 

문자열 간의 병합 : public String concat, String + String

public String concat(String s)

String 인스턴스에 매개변수 s를 붙여 반환합니다.
String + String 연산도 동일한 기능을 합니다.
▶ 각 concat, + 연산마다 더하려는 값을 new String()으로 불러오므로 붙일 때마다 새 주소값을 불러옵니다.
▶ 남발하면 잡아먹는 메모리가 커지므로 가급적 사용을 지양합니다.

 

public class Test {
    public static void main(String[] args) {
        String a = "showme";
        String b = "themoney";

        String c = a + b;
        String d = a.concat(b);

        System.out.println(c);
        //out : "showmethemoney"
        System.out.println(d);
        //out : "showmethemoney"
    }
}

 

특정 위치의 문자열 자르기, 반환 : public String substring

public String substring (String s, int fromIndex, *int toIndex)

입력받은 매개변수 String s의 문자열을 fromIndex부터 toIndex까지 잘라 자른 부분을 반환합니다.
* toIndex는 생략 가능하며, 생략 시 fromIndex부터 문자열 끝까지 자릅니다.
▶ String - String 연산은 불가능합니다.

 

public class Test {
    public static void main(String[] args) {
        String a = "show me the money";
        String b = "money";

        System.out.println(a-b);
        // out : error, String -연산은 불가능
        System.out.println(a.substring(12));
        // out : "money"
        System.out.println(a.substring(0, 5));
        // out : "show"
    }
}

 

문자열 반복 반환 : public String repeat

public String repeat(int i)

String 인스턴스를 i번 반복하여 String으로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        String s = "pen";
        System.out.println(s.repeat(4));
        // out : "penpenpenpen"
    }
}

 

문자열 규칙 포함 여부 탐색 : public boolean contains

public boolean contains(CharSequence cs)

인스턴스에 매개변수 String s가 포함되어 있을 시 true를, 아닐 경우는 false를 반환합니다.
한 개의 매개변수만 포함 여부 확인 가능합니다.

▶ 여러 개의 문자열의 포함 여부를 확인하는 메소드는 없습니다. 별도 메소드 정의가 필요합니다.
여러개의 매개변수 정의가 필요하면 하단에 별도 정의한 containsAny 메서드를 참고해 주세요.

▶ CharSequence와 String의 차이
java에서 String 문자열은 마크업 문자를 입/출력하는데 문제가 발생 → 변경불가(immutable) 문자열
CharSequence : 인터페이스, 마크업문자를 사용 → 변경이 가능한 문자열(mutable)
▶ String 클래스는 CharSequence 인터페이스를 extends 하므로 해당 메서드가 활용 가능합니다.

 

public class Test {
    public static void main(String[] args) {
        String s1 = "Hello World";
        System.out.println(s1.contains("World"));
        // out : true
        System.out.println(s1.contains("Bye"));
        // out : false

		// 별도 정의 메소드 활용, 하단 *참고 활용
        String[] arr = {"pen", "pine", "apple"};
        String s2 = "pen, pine, mango and apple";
        System.out.println(containsAny(s2, arr));
        // out : true
        
    }
    // *참고 : 문자열을 여러개의 문자열과 contains 비교하고 싶을 때
    // 사용방법 : contains(문자열, 포함할 문자열들의 배열)
    public static boolean containsAny(String s, String[] keys) {
        for (String key : keys) {
            if (!s.contains(key)) {
                return false; // 한개의 문자열이라도 포함되어 있지 않으면 false를 중간에 반환
            }
        }
        return true;
    }
}

 

문자열 규칙 일치 여부 탐색 : public boolean matches

public boolean matches(String regex)

인스턴스가 매개변수 String s, 혹은 해당 정규식과 패턴이 일치할 시 true를, 아닐 경우는 false를 반환합니다.

 

(참고) 정규 표현식

▶ 참고 1) 정규 표현식이란? :  특정한 규칙을 가진 문자열의 집합을 표현하는데 쓰이는 형식 언어입니다.

정규 표현식을 사용하면 효과적으로 특정한 문자열 규칙을 정의하고 규칙에 맞는 문자열 필터링 및 수정이 가능합니다.

 

▼ 참고 2) 정규 표현식 사용 CHEAT SHEET

 

▼ 참고 3) 정규 표현식 일반 문법

구 분	정규표현식 문법
^	문자열의 시작
$	문자열의 끝
.	임의의 한 문자
*	문자가 0번 이상 발생
+	문자가 1번 이상 발생
?	문자가 0번 또는 1번 발생
[  ] [^]	문자의 집합 범위   [0-9] : 숫자(0~9)   [a-z] : 알파벳(a~z) 괄호 안의 ^는 not을 의미   [^0-9] : 숫자 0~9가 아닌 경우   [^a-z] : 알파벳 a~z가 아닌 경우
{ }	횟수 / 범위를 의미
( )	소괄호 안의 문자를 하나의 문자로 인식
|	or
\	확장 문자의 시작
\b	단어의 경계
\B	단어가 아닌 것의 경계
\A	입력의 시작 부분
\G	이전 매치의 끝
\Z	입력의 끝, 종결자가 있는 경우
\z	입력의 끝
\s	공백 문자
\S	공백 문자 제외 나머지 문자
\w	알파벳 혹은 숫자, 혹은 언더바 _
\W	알파벳과 숫자, 언더바 _를 제외한 문자
\d	숫자, [0-9]와 동일
\D	[0-9]를 제외한 모든 문자

 

▼ 참고 4) 자주 쓰는 정규표현식 문법

구 분	자주쓰는 정규표현식 문법
^[0-9]*$	숫자
^[a-zA-Z]*$	영문자
^[가-힣]*$	한글
\\w+@\\w+\\.\\w+(\\.\\w+)?	이메일 주소
^\d{2,3}-\d{3,4}-\d{4}$	전화번호
^01(?0|1|[6-9])-(?:\d{3}|\d{4})-\d{4}$	핸드폰 번호
\d{6}\-[1-4]\d{6}	주민등록번호

 

▼ 참고 5) 정규표현식 활용 예제

public class Test {
    public static void main(String[] args) {
        String s1 = "1234a56_789";
        System.out.println(s1.matches("^[0-9]*$"));
        // out : false → 영문자가 섞이기 때문
        System.out.println(s1.matches("^[a-zA-Z]*$"));
        // out : false → _ 포함하기 떄문
        System.out.println(s1.matches("\\w")); // 아래와 동일
        // out: true
        System.out.println(s1.matches("^[0-9a-zA-Z_]*$")); // 위와 동일
        // out : true

        String s2 = "139802";
        String s3 = "11240989";
        System.out.println(s2.matches("\\d{6,7}"));
        // out : true
        System.out.println(s3.matches("\\d{6,7}"));
        // out : false → 숫자가 6~7자리가 아닌 8자리가 나오기 때문

        String s4 = "apple";
        System.out.println(s4.matches("ap{2,}le"));
        // out : true
        System.out.println(s4.matches("b*apple"));
        // out : true
        System.out.println(s4.matches("b+apple"));
        // out : false → "b"가 적어도 한번이라도 포함 안되었기 때문
    }
}

 

▶ 참고 6) Reference

[Java] 정규표현식 사용법 및 예제 - Pattern, Matcher

 

문자열 치환 : public String replace, replaceAll, replaceFirst

public String replace(charsequence target, charsequence replacement)

 : 인스턴스에 있는 모든 target 문자를 replacement로 바꿔 String으로 반환합니다.

public String replaceAll(String regex, String replacement)

: 인스턴스에 있는 모든 정규식에 해당되는 문자를 replacement로 바꿔 String으로 반환합니다.
▶replaceAll은 replace와 달리 정규식으로 구성하여 해당되는 문자열을 전부 변경할 수 있다는 차이점이 있습니다.

public String replaceFirst(String regex, String replacement)

: 인스턴스에 있는 정규식에 해당되는 첫 번째 문자열 replacement로 바꿔 String으로 반환합니다.

 

public class Test {
    public static void main(String[] args) {
        String s1 = "경찰청쇠창살 쇠철창살";
        String s2 = "사랑하는 조국 대한민국 사람입니다.";

        System.out.println(s1.replace("찰", "찰빵"));
        // out : 경찰빵청쇠창살 쇠철창살
        System.out.println(s2.replaceAll("니다.$", "네다."));
        // out : 사랑하는 조국 대한민국 사람입네다.
        System.out.println(s2.replaceFirst("국", "꾹"));
        // out : 사랑하는 조꾹 대한민국 사람입니다.
        
        // * 사상에 문제 없습니다..
    }
}

 

문자열 일치여부 탐색 : public boolean equals, public boolean contentEquals

public boolean equals(Object object)

매개변수로 받은 값과 객체의 값이 동일하며, 매개변수가 같은 클래스의 인스턴스인 경우(String인 경우) 
true를 반환하며, 아닐 경우 false를 반환합니다.

public boolean contentEquals(Charsequence cs / Stringbuilder sb / StringBuffer sb)

매개변수로 받은 값과 객체의 값의 문자열 내용이 완벽하게 동일할 시
true를 반환하며, 아닐 경우 false를 반환합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("good night");
        String str = ("good night");
        System.out.println(str.equals(sb));
        // out : "false" → str은 String, sb는 StringBuilder로 다른 클래스 인스턴스기 때문
        System.out.println(str.contentEquals(sb));
        // out : "true" → contentEquals는 내용만 비교한다.
    }
}

 

문자열 시작점 일치여부 탐색 : public boolean startsWith

public boolean startsWith(String prefix, *int offset)

매개변수로 받은 값이 offset 인덱스를 기준으로 문자열의 시작과 일치하면 true를, 아니면 false를 반환합니다. 
* offset을 생략 시 offset = 0, 즉 0번 인덱스를 기준으로 일치여부를 확인합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
		String str1 = "동해물과 백두산이 마르고 닳도록"
      	
        // no offset
        System.out.println(str1.startsWith("동해물과") // out : true
        
        // apply offset
        System.out.println(str1.startsWith("백두산이", 5) // out : true
    }
}

 

 

문자열 앞뒤 공백 제거 : public String trim

public String trim()

문자열 인스턴스 앞뒤에 위치해 있는 연속된 공백을 제거해 String으로 반환합니다.
문자열 사이에 낀 공백은 제거되지 않습니다.

 

public class Test {
    public static void main(String[] args) {
        String s1 = "    무 ~ 야 ~ 호 ~!    ";
        System.out.println(s1.trim());
        // out : "무 ~ 야 ~ 호 ~!"
    }
}

 

String → String 배열 변환 및 쪼개기  : public String [] split

public String[] split(String regex, *int limit)

문자열 인스턴스를 정규식에 해당되는 문자열 기준으로 분할하여 String 배열로 반환합니다. 
* int limit은 분할 시 배열의 크기의 한계값으로 limit의 개수까지만 정규식에 맞춰 분할합니다.

 

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        String s1 = "DISCO MOVE";
        System.out.println(Arrays.toString(s1.split("")));
        // out : "[D, I, S, C, O,  , M, O, V, E]"
        System.out.println(Arrays.toString(s1.split("", 4)));
        // out : "[D, I, S, CO MOVE]"
        System.out.println(Arrays.toString(s1.split(" ")));
        // out : "[DISCO, MOVE]"

        String s2 = "q1w2e3r4";
        System.out.println(Arrays.toString(s2.split("[^a-z]")));
        // out : "[q, w, e, r]"
    }
}

 

String → char 배열 변환  : public char [] toCharArray

public char[] toCharArray()

String 인스턴스를 char []로 변환하여 반환합니다.

 

import java.util.*;
public class Test {
    public static void main(String[] args) {
        String s1 = "Pen pine apple pen";
        char[] arr = s1.toCharArray();

        System.out.println(Arrays.toString(arr));
        // out : [P, e, n,  , p, i, n, e,  , a, p, p, l, e,  , p, e, n]
    }
}

 

char 배열 → String 변환 : static String copyValueOf

static String copyValueOf(char [] array, *int offset, *int count)

매개변수 char array를 합쳐진 한 개의 String으로 반환합니다.
* int offset과 int count 추가 시 char 배열의 offset의 index부터, count의 길이만큼 String으로 반환합니다. (생략가능)
▶ 동일 기능의 메서드 : static String valueOf, String으로의 형변환
   - valueOf과 copyValueOf 메서드는 성능적으로 완전히 동일합니다.
   - valueOf 메소드는 여러 매개변수를 입력받는 여러 메서드로 오버로딩된다는 차이점이 있습니다.

 

import java.util.*;
public class Test {
    public static void main(String[] args) {
        char[] arr = {'h', 'e', 'l', 'l', ' ', 'o'};
        System.out.println(String.copyValueOf(arr));
        // out : "hell o"
        System.out.println(String.copyValueOf(arr, 0,4));
        // out : "hell"
        System.out.println(String.valueOf(arr));
        // out : "hell o"

        String s = new String(arr);
        System.out.println(s); // char[] → String 형변환
        // out : "hell o"
    }
}

 

원시 자료형 → String 변환 : static String valueOf

static String valueOf(primitive datas)

매개변수 {char [], char, int, float, double, long, boolean}을 String으로 변환해 반환합니다.

 

▶ toString() vs String.valueOf()의 차이점

• toString() : Object → String 변환할 때  null 발생 시 NPE를 발생, Object 값이 String이 아니어도 String으로 출력한다.
• String.valueOf() : Object → String 변환할 때 null 발생 시 null을 문자열 "null"로 return

결론은 디버깅 과정에서 오류 추적에 용이한 것은 String.valueOf이 맞습니다.(null값 추적 및 확인을 위해)

 

public class Test {
    public static void main(String[] args) {
        char[] charArr = {'h', 'e', 'l', 'l', 'o'};
        System.out.println(String.valueOf(charArr));
        // out : "hello"

        int i = 42;
        System.out.println(String.valueOf(i));
        // out : "42" → 이미 sout.println메소드에 toString()이 실행되므로 사실 쓸 필요없음

        boolean f = false;
        System.out.println(String.valueOf(f));
        // out : "false" → 이미 sout.println메소드에 toString()이 실행되므로 사실 쓸 필요없음
    }
}

 

 

 

StringBuilder 클래스 (java.lang.StringBuilder)

StringBuilder 클래스는 일반적인 문자열 삽입, 치환, 삭제 등의 연산 메서드를 지원합니다.
String 클래스 문자열은 불변(immutable) 객체이므로 최초 생성 시 할당된 메모리 공간이 변하지 않습니다. 따라서, String 클래스는 연산 과정이 많을 시 String 문자열 객체의 내용이 바뀌는 것이 아닌, 연산 과정에 따라 새로운 String 객체를 계속해서 생성하게 되므로 메모리 공간을 잡아먹게 됩니다. 이는 프로그램 성능 저하를 유발합니다.

이를 보완할 수 있는 클래스가 StringBuilder 클래스입니다.
문자열의 생성 및 편집 등 연산이 많은 경우 StringBuilder를 활용해 처리시간 및 메모리를 단축할 수 있습니다.
StringBuilder는 StringBuffer 클래스와 달리 스레드 환경에서 동기화 기능을 보장하지 않지만, 그만큼 빠릅니다.

 

문자열 삽입 : public StringBuilder append

public StringBuilder append(element, *int start, *int end)

매개변수로 받은 해당 엘리먼트를 String 문자열로 변환해 StringBuilder의 마지막 index 뒤로 접미(suffix) 삽입합니다.
* (Charsequence만 해당) int start, int end 입력 시 해당 문자열 인덱스의 (start) 번부터 (end) 번까지만 삽입합니다. 

 

append 가능한 엘리먼트는 아래를 참고해 주세요.

 

StringBuilder append 오버로딩 메소드 / 출처 : Docs.Oracle.com

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("안녕하세요");
        sb.append(123);
        sb.append(123.56789);
        sb.append(true);
        sb.append("반갑습니다", 0, 2);
        System.out.println(sb);
        // out : "안녕하세요123123.56789true반갑"
    }
}

 

특정 위치에 문자열 삽입 : public StringBuilder insert

public StringBuilder insert(*int offset, element, *int start, *int end)

매개변수로 받은 해당 엘리먼트를 String 문자열로 변환해 StringBuilder의 지정한 index부터 접도(prefix) 삽입합니다.
* (Charsequence만 해당) int offset, start, end 입력 시 해당 StringBuilder 인덱스의 (offset) 번부터 문자열 element 인덱스의 (start) 번부터 (end-1) 번 문자열까지 삽입합니다. 

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        sb1.insert(0," 안녕하세요");
        sb1.insert(0, " 감사해요");
        sb1.insert(0," 잘있어요");
        sb1.insert(0,"다시 만나요");
        String answer1 = sb1.toString();
        System.out.println(answer1);
        // out : "다시 만나요 잘있어요 감사해요 안녕하세요"

        StringBuilder sb2 = new StringBuilder();
        sb2.insert(0,"안녕하세요",0,1);
        sb2.insert(1,"감사해요",0,2);
        sb2.insert(3,"잘있어요",0,2);
        sb2.insert(5,"다시 만나요",4,6);
        String answer2 = sb2.toString();
        System.out.println(answer2);
        // out : "안감사잘있나요"
    }
}

 

특정 위치의 문자열 삭제 : public StringBuilder delete

public StringBuilder delete(int start, int end)

StringBuilder에서 start index부터 end -1 index까지 값을 삭제합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("안녕하세요");
        sb.delete(2, 4);
        String answer = sb.toString();
        System.out.println(answer);
        // out : "안녕요"
    }
}

 

특정 위치의 문자 삭제 : public StringBuilder deleteCharAt

public StringBuilder deleteCharAt(int index)

StringBuilder에서 index번째 문자를 삭제합니다. (공백은 포함하지 않습니다)

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello World");
        sb.deleteCharAt(7);
        String answer = sb.toString();
        System.out.println(answer);
        // out : "Hello Wrld"
    }
}

 

특정 위치의 문자열 치환 : public StringBuilder replace

public StringBuilder replace(int start, int end, String s)

StringBuilder에서 start index부터 end-1의 index까지의 문자열을 매개변수 문자열 s로 치환합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("abcdefghij");
        sb.replace(3, 6, "yee");
        String answer = sb.toString();
        System.out.println(answer);
        // out : "abcyeeghij"
    }

 

특정 위치의 문자 치환 : public void setCharAt

public void setCharAt(int index, char c)

StringBuilder에서 index번째 문자를 c로 치환합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello World");
        sb.setCharAt(6, 'M');
        String answer = sb.toString();
        System.out.println(answer);
        // out : "Hello Morld"
    }
}

 

특정 위치의 문자열 자르기, 반환 : public String substring

public String substring(int start, *int end)

StringBuilder에서 start번째 index에서부터 end-1번째 index까지의 문자열을 String으로 리턴합니다.
* int end는 생략 가능하며 생략 시 start번째 index부터 문자열 끝까지를 리턴합니다.

※ String 클래스의 substring 메서드와 기능이 동일합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello World");
        System.out.println(sb.substring(6));
        // out: "World"
        System.out.println(sb.substring(6, 8));
        // out : "wo"
        String answer = sb.toString();
        System.out.println(answer);
        // out : "Hello World" // 변동 없음
    }
}

 

특정 값의 위치, 위치의 값 탐색 : public char charAt, indexOf, lastIndexOf

public char charAt(int index)

매개변수 int index에 위치한 String의 문자를 char로 반환합니다.
▶ index를 계산할 때 공백은 count 하지 않습니다.
▶ 범위를 벗어난 index의 문자를 호출하면 StringIndexOutOfBoundsException을 호출합니다.

public int indexOf(String s, *int fromindex)

매개변수 String s의 위치를 String에서 찾아 그중 첫 번째 index를 int로 반환합니다.
▶index를 계산할 때 공백은 count 하지 않습니다.
▶* fromindex 인자값을 입력 시 해당 index부터 탐색합니다. (생략가능)
▶찾는 값이 없을 때는 -1을 반환합니다.

public int lastIndexOf(String s, *int fromindex)
매개변수 String s의 위치를 String에서 찾아 그중 마지막 index를 int로 반환합니다.
▶index를 계산할 때 공백은 count 하지 않습니다.
▶* fromindex 인자값을 입력 시 해당 index부터 탐색합니다. (생략가능)
▶찾는 값이 없을 때는 -1을 반환합니다.

※  String 클래스의 세 메서드와 기능이 동일합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello World");
        System.out.println(sb.charAt(5));
        // out : " " // 공백
        
        System.out.println(sb.indexOf("o"));
        // out : "4"
        
        System.out.println(sb.lastIndexOf("o"));
        // out : "7"
    }
}

 

 

문자열 길이 조정 : public void setLength

public void setLength(int newLength)

StringBuilder의 길이를 newLength만큼 조절합니다.
현재 문자열보다 newLength가 길면 그만큼 공백으로 채워지며, 짧으면 그만큼 삭제됩니다.
★ setLength(0)으로 StringBuilder 초기화가 가능합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.setLength(13);
        sb.append("!");
        System.out.println(sb.toString());
        // out : "Hello        !" // 공백 확인을 위함

        sb.setLength(3);
        System.out.println(sb.toString());
        // out : "Hel"

        sb.setLength(0);
        System.out.println(sb.toString());
        // out : "" // setLength(0)으로 StringBuilder 초기화
    }
}

 

문자열 역순으로 뒤집기 : public StringBuilder reverse

public StringBuilder reverse()

StringBuilder 문자열을 역순으로 뒤집습니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("good night");
        sb.reverse();
        System.out.println(sb.toString());
        // out : "thgin doog"
    }
}

 

StringBuilder → String 변환 : public String toString

publie String toString()

현재 StringBuilder에 들어 있는 문자열을 String 클래스로 반환합니다.
★ 일반적으로 문자열 연산 종료 후 출력 전 String 클래스로 형변환이 필요할 때 사용합니다.

 

public class LearnMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("안녕하세요");
        sb.append(" 감사해요");
        sb.append(" 잘있어요");
        sb.append(" 다시 만나요");
        String answer = sb.toString();
        System.out.println(answer);
        // out : "안녕하세요 감사해요 잘있어요 다시 만나요"
    }
}

 

Arrays 클래스 (java.util.Arrays)

Arrays 클래스 메서드는 import java.util.*; 로 java util 패키지를 import 한 후 사용 가능합니다.

 

문자열 오름차순 / 내림차순 정렬 : public static void sort

public static void sort(array, *int fromIndex, *int toIndex)

매개변수로 받은 해당 배열을 오름차순으로 정렬합니다. (String, char, int 등 가능)
* int fromIndex와 int toIndex를 입력 시 배열의 (fromIndex) 번 요소부터 (toIndex) 번 요소의 전까지 오름차순 정렬합니다.

▶내림차순 정렬(Wrapper 클래스만 해당) : Collections.reverseOrder(), Comparator.reverseOrder() 활용 가능
int와 같은 primitive type은 사용할 수 없으며, 이 경우 배열을 Wrapper 클래스로 변환해야 합니다.

 

import java.util.*;
public class Test {
    public static void main(String[] args) {
        int[] arr1 = {9, 5, 1, 3, 7};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        // out : [1, 3, 5, 7, 9]

        int[] arr2 = {8, 4, 2, 5, 3};
        Arrays.sort(arr2, 0, 3);
        System.out.println(Arrays.toString(arr2));
        // out : [2, 4, 8, 5, 3] * index[0] ~ [2] 까지 정렬

        int[] arr3 = {1, 9, 4, 6, 3};
        Arrays.sort(arr3, Collections.reverseOrder());
        // error : 해당 array는 Wrapper class인 Integer[]로 선언되어야 작동함
        // * int는 원시형 타입으로 미작동

        // 따라서 int -> Integer로 stream을 통해 변환 후 사용 가능하다.
        Integer[] arr4 = (Integer[]) Arrays.stream(arr3).boxed().toArray(Integer[]::new);
        Arrays.sort(arr4, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr4));
        // out : [9, 6, 4, 3, 1]
    }
}

 

배열 →  String 변환 : public static String toString

public static String toString(array)

매개변수로 받은 해당 배열을 String으로 반환합니다.
▶ 쓰임새 : System.out.println 등으로 해당 배열의 내용값 출력이 필요할 시 호출합니다.
▶ System.out.println(array)로 sout 호출 시에는 해당 객채(배열)의 주소값을 호출합니다.

 

import java.util.*;
public class Test {
    public static void main(String[] args) {
        String[] arr = {"pen", "pineapple", "apple", "pen"};

        System.out.println(Arrays.toString(arr));
        // out : "[pen, pineapple, apple, pen]"
        System.out.println(arr);
        // out : "[Ljava.lang.String;@723279cf"

    }
}

 

다음 포스팅에서 이어집니다.

2023.10.05 - [DEV/Java] - [java] 코딩테스트 대비 java 클래스 별 메소드 정리 (2 / 2)

[java] 코딩테스트 대비 java 클래스 별 메소드 정리 (2 / 2)

 

 

 

* REFERENCE

RegExr: Learn, Build, & Test RegEx

All Classes (Java Platform SE 8 )