String Handling and Character Operations in Kotlin | CodeSignal Learn

String Handling and Character Operations in Kotlin | CodeSignal Learn

Skip to main content

Lesson Overview

Welcome to an engaging Kotlin session! In this unit, we will delve deeper into handling string data with Kotlin. Imagine situations in which you need to analyze text data, like constructing a web scraper or developing a text-based algorithm to interpret user reviews on a website. All these scenarios require efficient handling of strings, which involves analyzing and manipulating them. In this lesson, we will focus on how to traverse strings and perform operations on each character using Kotlin. The objective of this lesson is to become proficient in using Kotlin loops, with a specific emphasis on strings . We will explore the techniques of string indexing and practice character operations using Kotlin functions.

Working with ASCII Codes in Characters

String Indexing Reminder

Kotlin strings use a zero-based indexing system. This means that you can access specific characters in a string by using their position. Please note: If you try to access an index that does not exist in your string, Kotlin will throw an IndexOutOfBoundsException . Hence, it's recommended to always check the string length before accessing any index. Here's an example: fun main() {val text = "Hello, Kotlin!" val index = 9 // The index we want to access if (index < text.length) {val charAtIndex = text[index] println("The character at index $index is: $charAtIndex")} else {println("The index $index is out of bounds for the string!")}}

Character Operations

Lesson Summary and Practice

Excellent work! We have learned how to work with strings in Kotlin by looping over them, managing string indices, and manipulating characters using Kotlin methods. Moreover, we have also explored strategies to handle IndexOutOfBoundsException while dealing with strings in our programs. Real-world problems abound where string operations can be handy. From designing smart typewriters and web scrapers to crafting AI bots, mastering string operations is a valuable skill in the world of programming. Therefore, don't waste any time! Jump into the practice problems to reinforce your learning. Your journey is just beginning—see you in the upcoming sessions!

Previous Lesson Next Lesson: Basic String Manipulation in Kotlin

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Characters in Kotlin can be manipulated using their ASCII values. ASCII (American Standard Code for Information Interchange) is a character encoding standard used to represent text in computers and other devices that use text. Every character has a unique ASCII value.

You can convert a character into its ASCII value using the .code property:

Kotlin

fun main() {
    val c = 'A'
    val asciiVal = c.code
    println("The ASCII value of $c is: $asciiVal")
}

Similarly, you can convert an ASCII value back to its corresponding character:

Kotlin

fun main() {
    val asciiVal = 65
    val c = asciiVal.toChar()
    println("The character of ASCII value $asciiVal is: $c")
}

Manipulating the ASCII value of characters can be quite useful in certain situations. For example, to convert a lowercase letter to uppercase (or vice versa), you could subtract (or add) 32 to the character's ASCII value.

Kotlin

fun main() {
    val text = "Hello, Kotlin!"
    val index = 9 // The index we want to access

    if (index < text.length) {
        val charAtIndex = text[index]
        println("The character at index $index is: $charAtIndex")
    } else {
        println("The index $index is out of bounds for the string!")
    }
}

Let's now explore character operations in Kotlin. We have methods like Char.uppercaseChar(), Char.lowercaseChar(), and type-checking methods that you can use to perform operations on characters. Here are some examples:

Char.uppercaseChar() and Char.lowercaseChar() can be used to change the case of individual characters. Additionally, to change the case of an entire string, you can use the String.uppercase() and String.lowercase() methods.

Kotlin

fun main() {
    var s = "mark"
    val sb = StringBuilder(s)
    for (i in 0 until sb.length) {
        sb.setCharAt(i, sb[i].uppercaseChar())
    }
    println(sb.toString())  // Prints: 'MARK'

    s = "Mark"
    sb.clear().append(s)
    for (i in 0 until sb.length) {
        sb.setCharAt(i, sb[i].lowercaseChar())
    }
    println(sb.toString())  // Prints: 'mark'

    println("hello".uppercase())  // Prints: 'HELLO'
    println("WORLD".lowercase())  // Prints: 'world'
}

Methods Char.isLowerCase() and Char.isUpperCase() can be used to determine whether a character is a lowercase or uppercase letter.

Kotlin

fun main() {
    val a = 'a'
    val b = 'B'
    println("Is $a lowercase? ${a.isLowerCase()}")  // Prints: true
    println("Is $b lowercase? ${b.isLowerCase()}")  // Prints: false

    println("Is $a uppercase? ${a.isUpperCase()}")  // Prints: false
    println("Is $b uppercase? ${b.isUpperCase()}")  // Prints: true
}

The Char.isLetter(), Char.isDigit(), and Char.isLetterOrDigit() methods are useful when you need to check whether the character satisfies a specific condition (is a letter, a digit, or a letter/digit).

fun main() {
    println('C'.isLetter())  // Prints: true
    println('+'.isLetter())  // Prints: false

    println('9'.isDigit())  // Prints: true
    println('D'.isDigit())  // Prints: false

    println('6'.isLetterOrDigit())  // Prints: true
    println('k'.isLetterOrDigit())  // Prints: true
    println('?'.isLetterOrDigit())  // Prints: false
}

Kotlin

fun main() {
    println('C'.isLetter())  // Prints: true
    println('+'.isLetter())  // Prints: false

    println('9'.isDigit())  // Prints: true
    println('D'.isDigit())  // Prints: false

    println('6'.isLetterOrDigit())  // Prints: true
    println('k'.isLetterOrDigit())  // Prints: true
    println('?'.isLetterOrDigit())  // Prints: false
}