Remove First Character in String in Kotlin

1. Overview

String is one of the most commonly used data types in Kotlin. Therefore, manipulating strings is a fundamental operation in our daily programming.

In this quick tutorial, we’ll explore various approaches to removing the first character from a string in Kotlin.

2. Introduction to the Problem

Strings are immutable in Java and Kotlin. Therefore, we cannot in-place remove characters from a string object. In other words, we aim to obtain a new string object to hold the required result when we discuss removing the first character from a string.

In this tutorial, we’ll address different solutions to do the job. Furthermore, we’ll discuss these solutions’ behavior in a corner case: when the string is empty.

For simplicity, we’ll use unit test assertions to verify whether each approach works as expected.

3. Using the drop() Function

Kotlin offers a series of convenient String extensions. For example, the drop(n) function can remove the first n characters from a string.

Therefore, if we only want to remove the first character, we can pass 1 to drop():

val myStr = "0a b c d e"
val result = myStr.drop(1)
assertEquals("a b c d e", result)

It’s worth noting that the string.drop(1) approach works with empty strings as well:

val result2 = "".drop(1)
assertEquals("", result2)

4. Using the substring() Function

If we’ve removed the first character from a string, the result is the same as we get the substring of the input from the second character. Therefore, we can also leverage the substring() method to solve the problem:

val myStr = "0a b c d e"
val result = myStr.substring(1)
assertEquals("a b c d e", result)

As the test above shows, we passed 1 to substring() since it’s the second character’s index.

However, this approach throws IndexOutOfBoundsException if the input string is empty:

//throw exception when the string is empty
assertThrows<IndexOutOfBoundsException> {
    "".substring(1)
}

5. Using the takeLast() Function

Similar to substring(), Kotlin’s takeLast() function returns a substring of the input. However, takeLast(n) takes the last n characters from the input string. For example, “123”.takeLast(2) returns “23”. Therefore, if we want to exclude the first character, takeLast(input.length – 1) solves the problem:

val myStr = "0a b c d e"
val result = myStr.takeLast(myStr.length - 1) // or takeLast(myStr.lastIndex)
assertEquals("a b c d e", result)

Alternatively, we can pass myStr.lastIndex to the takeLast() function since string.lastIndex has the same value as string.length – 1:

public val CharSequence.lastIndex: Int
    get() = this.length - 1

But this approach raises IllegalArgumentException if the string is empty:

val myEmpty = ""

assertThrows<IllegalArgumentException> {
    myEmpty.takeLast(myEmpty.length - 1)
}.also {
    assertEquals("Requested character count -1 is less than zero.", it.message)
}

6. Using the replace() Function

Another technique to remove characters from a string is the regex-based approach. For example, we can use the replace() function to solve the problem:

val myStr = "0a b c d e"
val result = myStr.replace("^.".toRegex(), "")
assertEquals("a b c d e", result)

The regex pattern “^.” matches the first character, so we use replace() to replace the first character with an empty string.

As the regex-based solution isn’t dependent on the character’s index, it works even if the string is empty:

val result2 = "".replace("^.".toRegex(), "")
assertEquals("", result2)

7. Conclusion

In this article, we explored several methods to remove the first character from a string in Kotlin. Also, we discussed how these solutions behave if the input string is empty.