코딩도장

코틀린에서 CharSequence는 String, StringBuilder 등 문자열과 관련된 클래스들이 구현하는 뼈대 인터페이스다

val seq: CharSequence = "Hello"
println(seq.length) // 5
println(seq[2]) // l
println(seq.subSequence(1, 4)) // ell

// 접두사, 접미사 관련
val str1: CharSequence = "https://www.naver.com"
println(str1.startsWith("https://")) // true
println(str1.endsWith(".com")) // true
println(str1.removePrefix("https://")) // www.naver.com
println(str1.removeSuffix(".com")) // https://www.naver
println(str1.removeSurrounding("https://", ".com")) // www.naver

// 비어 있는지 검사하기
val emptyStr = ""
val whiteSpaces = " "
val nullStr: String? = null
println(emptyStr.isEmpty()) // true
println(whiteSpaces.isEmpty()) // false
println(emptyStr.isBlank()) // true
println(whiteSpaces.isBlank()) // true
println(nullStr.isNullOrEmpty()) // true
println(nullStr.isNullOrBlank()) // true

// 가공하기
// removeRange, padStart, padEnd, trimStart, trimEnd, trim, slice, subSequence, substring, reversed 등 제공

// 쪼개기
val hello: CharSequence = "안녕하세요.\n고맙습니다.\n반갑습니다."
val time: CharSequence = "2018-01-22"
println(hello.lines())
for (line in hello.lineSequence())
  println(line)
println(time.split('-'))
// [안녕하세요.,고맙습니다.,반갑습니다.]
// 안녕하세요.
// 고맙습니다.
// 반갑습니다.
// [2018, 01, 22]

// 문자열 찾아 바꾸기
val adage = "Love begets love."
println(adage.replace("love", "hate", ignoreCase = true))
println(adage.replaceFirst("love", "compliment", ignoreCase = true))
println(adage.replaceRange(5..10, "hello"))
// hate begets love.
// compliment begets love.
// Love hello love.

// 문자열 덧붙이기
val builder = StringBuilder().append("2018").append(" Pyeongchang")
var result = builder.toString()
println(result) // 2018 Pyeongchang

// 정규식 다루기
val regex = Regex("[0-9]+")
val str = "4324235"
val str2 = "324 6546 5432"
println(regex matches str) // true
println(regex matches str2) // false
println(regex.replace(str2, "숫자")) // 숫자 숫자 숫자

문자열 추가하고 병합하기 (substring)

s = "abcdef"
println(s.substring(0..2)) // abc
s = s.substring(0..1) + "x" + s.substring(2..s.length-1) // abxcdef

문자열 비교하기 (compare)

var s1 = "Hello Kotlin"
var s2 = "Hello KOTLIN"
// 같으면 0, s1<s2 이면 양수, 반대면 음수를 반환
println(s1.compareTo(s2))
println(s1.compareTo(s2, true)) // 대소문자 무시

StringBuilder 사용하기

: StringBuilder를 사용하면 문자열이 사용할 공간을 좀 더 크게 잡을 수 있기 때문에 문자열이 자주 변경되는 경우에 사용하면 좋습니다.

var s = StringBuilder("Hello")
s.append("World")
s.insert(10, "Added") // 인덱스 10번부터 추가
s.delete(5, 10) // 인덱스 5번부터 10번 전까지 삭제

기타 문자열 처리

: 소문자/대문자 변경(toLowerCase, toUpperCase), 특정 문자 단위로 잘라내기(split), 앞뒤 공백 제거(trim)

var deli = "Welcome to Kotlin"
val sp = deli.split(" ")
println(sp) // [Welcome, to, Kotlin]

// 하나 이상의 분리 문자를 지정
...
str.split("=", "-")

문자열을 정수로 반환하기 (toInt)

val number: Int = "123".toInt()

...
try {
  "12w".toInt()
} catch(e: NumberFormatException) {
  println(e.printStackTrace())
}

만일 숫자가 아닌 문자가 포함되었을 때 null을 반환받고자 한다면 toIntOrNull()을 사용할 수 있습니다.

​

형식 문자 사용하기 (format)

val pi = 3.1415926
val dec = 10
val s = "hello"
println("pi = %.2f, %3d, %s".format(pi, dec, s))

String 인스턴스

// StringBuffer 클래스
StringBuffer strBf = new StringBuffer("피카츄");
strBf.append(" 라이츄");
System.out.println(strBf);

// StringBuilder 클래스
StringBuilder strBd = new StringBuilder("피카츄");
strBd.append(" 라이츄");
System.out.println(strBd);

피카츄 라이츄
피카츄 라이츄

정리

Kotlin string은 참조만 되지 변경하기가 어렵다. Python도 그랬던것 같다. 아마 가볍게 만들려고 그런것 같다.

공부하던중  Kotlin에도 자료구조에 사용하기 좋은 stringBuilder라는 구조를 찾았다.

StringBuilder 클래스는 String처럼 문자열을 다루는 클래스로, String에 문자열을 넣고 인스턴스 생성 후에 값을 변경하지 못했던 점을 개선한 클래스라 할 수 있다. 추가적으로 내부적으로 문자열을 저장하기 위한 메모리 공간을 지닌다. 

이놈은 append도 되고 insert, delete도 된다.  처리후 toString으로 형변환을 시켜주면 된다.

StringBuilder stb = new StringBuilder(32);  
이때   예시처럼 작성을 하면 생성자의 인자로 전달되는 숫자인 32 크기만큼 문자를 저장할 수 있는 공간을 마련한다. length를 찍어보면 아직까지는 0이다 메모리공간만 마련하는듯

-append(값) : 문자열 추가한다. 재미있는건 어떤 타입도 다 문자열로 바꾼다.
-delete(시작, 끝) : 시작 인덱스부터 끝 인덱스까지의 내용을 삭제한다.
-insert(위치, 값) : 특정 원하는 위치에 문자열을 추가한다.
-replace(시작, 끝, 값) : 시작 인덱스부터 끝 인덱스 이전까지의 내용을 추가하고자 하는 '값'으로 문자열을 대체한다.
-reverse() : 저장해놨던 문자열의 내용을 뒤집는다.
-substring(시작, 끝) : 저장된 문자열 중에서 시작부터 끝 이전까지의 내용만 담은 String 인스턴스의 값을 반환한다.
-deleteCharAt(위치) :  특정 위치의 값만 삭제한다.

fun main(args : Array<String>) {
    /*
    기존 참조하던 "abc" 뒤에 "def"를 추가하는 것이 아니라
    추가된 문자열 "abcdef"를 새로 생성하고 참조하는 것이다.
    그러면 쓰레기 "abc"가 남게되며 이러한 과정이 많아지면 비효율적
    var s1 = "ab"
    s1 += "cd"
    */

    val str = StringBuilder()   // 빈 생성자
    println("1. 문자열 : $str")
    /* 추가 */
    str.append(5)               // Int 타입
    str.append("man")          // String 타입
    str.append(' ')             // Char 타입
    str.append(true)            // Boolean 타입
    str.append(5431)
    str.append(" is ")
    str.append("women")

    println("2. 문자열 : $str")
    println("index=0 : ${str[0]}, index=5 : ${str[5]}")

    /* 삭제 */
    str.deleteCharAt(0) // index
    str.delete(8, 12)    // [start, end)
    println("after delete 0, 8..12 : $str")

    println("=========================================")
    val temp: String = "ABCD"
    val str2 = StringBuilder(temp)  // String을 받는 생성자
    println("1. 문자열 : $str2")
    println("길이 = ${str2.length}")
    println("뒤집기 = ${str2.reverse()}")

    str2.insert(0, "front+")   // index=0 위치에 추가
    println("2. insert front : $str2")

    val li = listOf("abc", "def", "ghi")
    str2.append(li.joinToString(""))
    println("3. append abcdefghi : $str2")

    println("4-1. 부분 문자열 : ${str2.substring(6)}")       // [6, length)
    println("4-2. 부분 문자열 : ${str2.substring(6, 9)}")        // [6, 8)
    println("4-3. 부분 문자열 : ${str2.substring(6..9)}")    // [6, 9]

    println("=========================================")
    val str3 = str.toString()   // String Type으로 저장
    if(str3 is String) println("String Type")
}

알고리즘 풀때 스트링을 자주쓰는 편인데 코틀린 String에 대해 잘 안나와 있어 코틀린 사이트에서 추려서 정리해봤다

앞 뒤문자를 짜르는 명령어가 필요했는데 결국 substring을 이용해서 만들었다고 한다.

drop 은 문자열의 앞이나 뒷부분을 자를 때 사용된다.

내부적으로는 substring 으로 구현되어 있다.

• drop : 앞에서부터 n 개의 문자를 제거한 String 을 반환
• dropLast: 뒤에서부터 n 개의 문자를 제거
• dropWhile, dropLastWhile: 조건을 만족하지 않는 문자가 나올때까지 제거
• 파이썬같이 insert나 append를 찾고 싶었어나 배열은 자료구조상 안된 arrayList에서는 가능한것 같음.

val string = "<<<First Grade>>>"
println(string.drop(6)) // st Grade>>>
println(string.dropLast(6)) // <<<First Gr
println(string.dropWhile { !it.isLetter() }) // First Grade>>>, 앞쪽 문자가 아닌걸 제거
println(string.dropLastWhile { !it.isLetter() }) // <<<First Grade, 뒤쪽 문자가 아닌걸 제거

끝이 없다. 더 보고 싶은 분은 아래 코틀린 사이트에서 공부하시길

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/