字符串 #

val greeting = "Hello, Scala!"
val empty = ""
val singleChar = "A"

val str = "Hello"
val newStr = str + " World"
println(str)
println(newStr)

val firstName = "John"
val lastName = "Doe"

val fullName1 = firstName + " " + lastName
val fullName2 = s"$firstName $lastName"
val fullName3 = firstName.concat(" ").concat(lastName)

val name = "Scala"
val version = 3

val greeting = s"Hello, $name!"
val info = s"Scala $version is great!"
val expr = s"2 + 2 = ${2 + 2}"
val method = s"Name length: ${name.length}"

val price = 99.99
val quantity = 10

val formatted = f"Price: $$${price}%.2f"
val percentage = f"Progress: ${33.333}%.1f%%"
val padded = f"${42}%05d"

val escaped = "Hello\nWorld"
val rawStr = raw"Hello\nWorld"

println(escaped)
println(rawStr)

val name = "Scala"
val multiline = s"""Welcome to $name!
                    |This is a multiline string.
                    |Enjoy coding!""".stripMargin

println(multiline)

val text = """This is a
multiline string
in Scala"""

println(text)

val formatted = """This is a
                  |multiline string
                  |with stripMargin""".stripMargin

println(formatted)

val custom = """This is a
               #multiline string
               #with custom margin""".stripMargin('#')

println(custom)

val indented = """This is a
                 |  indented
                 |    multiline string""".stripMargin

println(indented)

val str = "Hello, Scala!"

str.length
str.size
str.isEmpty
str.nonEmpty

str.charAt(0)
str(0)
str.apply(0)

val str = "Hello, Scala!"

str.substring(7)
str.substring(0, 5)
str.take(5)
str.takeRight(6)
str.drop(7)
str.dropRight(8)

val str = "apple,banana,cherry"

val parts = str.split(",")
val parts2 = str.split(", ", 2)

val joined = parts.mkString("-")
val joined2 = parts.mkString("[", ", ", "]")

val str = "Hello, Scala!"

str.toLowerCase
str.toUpperCase
str.capitalize
str.toLowerCase.capitalize

val str = "  Hello, Scala!  "

str.trim
str.stripLeading
str.stripTrailing
str.stripPrefix("  ")
str.stripSuffix("  ")

val str = "Hello, Scala!"

str.replace("Scala", "World")
str.replaceFirst("l", "L")
str.replaceAll("[aeiou]", "*")

val str = "Hello, Scala!"

str.indexOf('l')
str.indexOf("Scala")
str.lastIndexOf('l')
str.contains("Scala")
str.startsWith("Hello")
str.endsWith("!")

val str1 = "apple"
val str2 = "banana"
val str3 = "Apple"

str1.compareTo(str2)
str1.compareToIgnoreCase(str3)
str1.equals(str2)
str1.equalsIgnoreCase(str3)

val str = "Hello"

str.toCharArray
str.toList
str.toSeq
str.toSet

val str = "Hello"

str.foreach(println)

for (c <- str) println(c)

str.map(_.toUpper)
str.filter(_.isLetter)
str.takeWhile(_ != 'l')

val list = List('H', 'e', 'l', 'l', 'o')

list.mkString
list.mkString("-")
list.toString

val sb = new StringBuilder

sb.append("Hello")
sb.append(", ")
sb.append("Scala")
sb.append('!')

val result = sb.toString

val sb = new StringBuilder("Hello")

sb.insert(5, " World")
sb.delete(5, 11)
sb.replace(0, 5, "Hi")
sb.reverse

sb.clear

val words = List("Hello", "World", "Scala")

val sentence = words.mkString(" ")
val csv = words.mkString(",")
val json = words.map(s => s""""$s"""").mkString("[", ", ", "]")

import scala.util.matching.Regex

val pattern1 = "[0-9]+".r
val pattern2 = new Regex("[0-9]+")
val pattern3 = """\d+""".r

val text = "123 Main Street, Apt 456"
val pattern = """\d+""".r

val firstMatch = pattern.findFirstIn(text)
val allMatches = pattern.findAllIn(text).toList
val matchIterator = pattern.findAllIn(text)

val text = "123 Main Street, Apt 456"
val pattern = """\d+""".r

val replaced1 = pattern.replaceAllIn(text, "XXX")
val replaced2 = pattern.replaceFirstIn(text, "XXX")

val pattern = """(\d+)-(\d+)-(\d+)""".r
val text = "2024-03-27"

text match
  case pattern(year, month, day) =>
    println(s"Year: $year, Month: $month, Day: $day")
  case _ =>
    println("No match")

val pattern = """(\w+)@(\w+)\.(\w+)""".r
val text = "user@example.com"

pattern.findAllMatchIn(text).foreach { m =>
  println(s"Full: ${m.matched}")
  println(s"User: ${m.group(1)}")
  println(s"Domain: ${m.group(2)}")
  println(s"TLD: ${m.group(3)}")
}

val str = "Hello, Scala!"

str.reverse
str.sorted
str.distinct
str.grouped(3).toList
str.sliding(3).toList
str.padTo(20, '-')
str.patch(5, " WORLD", 7)

val str = "Scala"

str.padTo(10, ' ')
str.padTo(10, '-')

f"$str%-10s|"
f"$str%10s|"

val str = "Scala"

str.reverse
str.reverseIterator.toList

val num = 42

num.toString
num.toHexString
num.toBinaryString
num.toOctalString

f"$num%04d"
f"$num%x"

val intStr = "123"
val intVal = intStr.toInt
val intOption = intStr.toIntOption

val hexStr = "FF"
val hexVal = Integer.parseInt(hexStr, 16)

val binStr = "1010"
val binVal = Integer.parseInt(binStr, 2)

def safeParseInt(str: String): Option[Int] =
  scala.util.Try(str.toInt).toOption

safeParseInt("123")
safeParseInt("abc")

val name = "Scala"
val version = 3

val bad = "Hello, " + name + " " + version + "!"
val good = s"Hello, $name $version!"

val json = """{
  "name": "Scala",
  "version": 3,
  "features": ["FP", "OOP"]
}"""

val sql = """
  SELECT id, name, email
  FROM users
  WHERE status = 'active'
  ORDER BY created_at DESC
""".stripMargin

val str: String = null

val safe = Option(str).getOrElse("")
val safeUpper = Option(str).map(_.toUpperCase).getOrElse("")
val nonEmpty = Option(str).filter(_.nonEmpty)