Kotlin Strings: Features and Operations Guide
In Kotlin, strings are sequences of characters and are represented by the String type. Strings are immutable, meaning that once a string is created, it cannot be changed. However, you can perform various operations on strings to create new strings. Below are some key features and operations related to strings in Kotlin:
1. Creating Strings
You can create a string using double quotes (").
val greeting = "Hello, World!"
2. String Templates
Kotlin supports string templates, which allow you to embed expressions inside string literals. Use $ for simple variable names and ${} for expressions.
val name = "Alice" val message = "Hello, $name!" println(message) // Output: Hello, Alice! val a = 5 val b = 10 val sum = "The sum of $a and $b is ${a + b}." println(sum) // Output: The sum of 5 and 10 is 15.
3. Multiline Strings
You can create multiline strings using triple quotes (""").
val text = """ This is a multiline string. It preserves the formatting and line breaks. """ println(text)
4. String Properties and Functions
Kotlin provides several properties and functions to work with strings:
Length: Get the length of the string.
val length = greeting.length println(length) // Output: 13
Accessing Characters: Access individual characters using indexing.
val firstChar = greeting[0] println(firstChar) // Output: H
Substring: Extract a substring.
val substring = greeting.substring(0, 5) println(substring) // Output: Hello
Concatenation: Concatenate strings using the
+operator.val newGreeting = greeting + " How are you?" println(newGreeting) // Output: Hello, World! How are you?
Uppercase/Lowercase: Convert the string to uppercase or lowercase.
val upper = greeting.uppercase() val lower = greeting.lowercase() println(upper) // Output: HELLO, WORLD! println(lower) // Output: hello, world!
Trim: Remove leading and trailing whitespace.
val spacedString = " Hello, World! " val trimmedString = spacedString.trim() println(trimmedString) // Output: Hello, World!
Replace: Replace parts of the string.
val replacedString = greeting.replace("World", "Kotlin") println(replacedString) // Output: Hello, Kotlin!
Split: Split the string into a list of substrings.
val parts = greeting.split(", ") println(parts) // Output: [Hello, World!]
5. String Comparison
You can compare strings using the == operator, which checks for equality, or the compareTo function, which compares strings lexicographically.
val str1 = "Hello" val str2 = "hello" println(str1 == str2) // Output: false println(str1.compareTo(str2)) // Output: -32 (because 'H' is 32 less than 'h' in ASCII)
6. String Interpolation
Kotlin allows you to interpolate variables and expressions directly within strings.
val age = 25 val info = "I am $age years old." println(info) // Output: I am 25 years old.
7. Raw Strings
Raw strings are useful when you need to include characters that would otherwise need to be escaped.
val path = """C:\Users\Alice\Documents""" println(path) // Output: C:\Users\Alice\Documents
8. String Equality
Kotlin distinguishes between structural equality (==) and referential equality (===).
val str3 = "Hello" val str4 = "Hello" println(str3 == str4) // Output: true (structural equality) println(str3 === str4) // Output: true (referential equality, due to string interning)
9. String Iteration
You can iterate over the characters of a string using a for loop.
for (char in greeting) { println(char) }
10. String Formatting
Kotlin provides the format function for formatting strings.
val pi = 3.14159 val formattedString = "Pi is approximately %.2f".format(pi) println(formattedString) // Output: Pi is approximately 3.14
11. String Interning
Kotlin automatically interns string literals, meaning that identical string literals share the same memory reference.
val str5 = "Hello" val str6 = "Hello" println(str5 === str6) // Output: true
12. String Builder
For efficient string manipulation, especially when concatenating multiple strings in a loop, you can use StringBuilder.
val builder = StringBuilder() builder.append("Hello") builder.append(", ") builder.append("World!") val result = builder.toString() println(result) // Output: Hello, World!
13. Escaping Characters
You can escape special characters using a backslash (\).
val escapedString = "This is a \"quoted\" string." println(escapedString) // Output: This is a "quoted" string.
14. Checking for Substrings
You can check if a string contains a substring using the contains function.
val containsWorld = greeting.contains("World") println(containsWorld) // Output: true
15. String Padding
You can pad strings to a certain length using padStart and padEnd.
val paddedString = "42".padStart(5, '0') println(paddedString) // Output: 00042
16. String Reversal
You can reverse a string using the reversed function.
val reversedString = greeting.reversed() println(reversedString) // Output: !dlroW ,olleH
17. String to Number Conversion
You can convert strings to numbers using functions like toInt(), toDouble(), etc.
val numberString = "123" val number = numberString.toInt() println(number) // Output: 123
18. String to Char Array
You can convert a string to a character array using the toCharArray function.
val charArray = greeting.toCharArray() println(charArray.joinToString()) // Output: H, e, l, l, o, ,, , W, o, r, l, d, !
19. String Matching
You can use regular expressions to match patterns in strings.
val regex = Regex("[A-Za-z]+") val matchResult = regex.find(greeting) println(matchResult?.value) // Output: Hello
20. String Joining
You can join a collection of strings into a single string using the joinToString function.
val words = listOf("Hello", "World", "Kotlin") val joinedString = words.joinToString(", ") println(joinedString) // Output: Hello, World, Kotlin
These are some of the fundamental aspects of working with strings in Kotlin. Strings are a versatile and powerful feature of the language, and understanding how to manipulate them effectively is key to many programming tasks.
Comments
Post a Comment