JVM 语言比较研究：Java、Kotlin 和 Scala 的利与弊

if (r instanceof ColoredPoint(Point p, Color c)) {    // ...}

if (r instanceof ColoredPoint(Point p, _)) {    // ...}

if (r instanceof ColoredPoint(Point(int x, _), _)) {    // ...}

for (Order order : orders) {    if (total < limit) total++;}

for (_ : orders) {    if (total < limit) total++;}

switch (b) {    case Box(RedBall _), Box(BlueBall _) -> processBox(b);    case Box(GreenBall _) -> stopProcessing();    case Box(_) -> pickAnotherBox();}

javac --release 21 --enable-preview Main.java

java --enable-preview Main

java --source 21 --enable-preview Main.java

jshell --enable-preview

mapOf(1 to "one", 2 to "two", 3 to "three")   .forEach { (_, value) -> println("$value!") }

var name: String by Delegates.observable("no name") {    kProperty, oldValue, newValue -> println("$oldValue")}

var name: String by Delegates.observable("no name") {    _, oldValue, _ -> println("$oldValue")}

val (w, x, y, z) = listOf(1, 2, 3, 4)print(x + z) // 'w'和'y'未被使用

val (_, x, _, z) = listOf(1, 2, 3, 4)print(x + z)

//导入包junit的所有成员。（相当于java中使用通配符*的导入）import org.junit._

// 导入junit中除Before之外的所有成员。import org.junit.{Before => _, _}

// 导入junit的所有成员，但将Before重命名为B4。import org.junit.{Before => B4, _}

// 在List中使用下划线val list: List[_] = List(1, "two", true)println(list)

// 在Array中使用下划线val array: Array[_] = Array(1, "two", true)println(array.mkString("Array(", ", ", ")"))

// 在Seq中使用下划线val seq: Seq[_] = Seq(1, "two", true)println(seq)

// 在Option中使用下划线val opt: Option[_] = Some("Hello")println(opt)

// 在Vector中使用下划线val vector: Vector[_] = Vector(1, "two", true)println(vector)

def itemTransaction(price: Double): String = { price match {   case 130 => "Buy"   case 150 => "Sell"

   // 如果价格不是130和150中的任何一个，则执行这一情况   case _ => "Need approval" }}

println(itemTransaction(130)) // 购买println(itemTransaction(150)) // 出售println(itemTransaction(70))  // 需要批准println(itemTransaction(400)) // 需要批准

val ints = (1 to 4).map(_ => "Hello")println(ints) // Vector(Hello, Hello, Hello, Hello)

val books = Seq(("Moby Dick", "Melville", 1851), ("The Great Gatsby", "Fitzgerald", 1925), ("1984", "Orwell", 1949), ("Brave New World", "Huxley", 1932))

val recentBooks = books .filter(_._3 > 1900)  // 只筛选1900年以后出版的书 .filter(_._2.startsWith("F"))  // 只筛选作者名字以“F”开头的书。// 只返回元组的第一个元素；书名

println(recentBooks) // List(The Great Gatsby)

val text = "a,b"val Array(a, _) = text.split(",")println(a)

val Array(_, b) = text.split(",")println(b)

val text = "a,b,c,d,e"val Array(a, _*) = text.split(",")println(a)

val text = "a,b,c,d,e"val Array(a, b, _, d, e) = text.split(",")println(a)println(b)println(d)println(e)

var x: String = _x = "real value"println(x) // 真实值

def greet(prefix: String, name: String): String = s"$prefix $name"

// Eta扩展，将greet变成一个函数val greeting = greet _

println(greeting("Hello", "John"))

def multiply(numbers: Int*): Int = { numbers.reduce(_ * _)}

val factors = Seq(2, 3, 4)val product = multiply(factors: _*)//使用factors: _*将Seq元素转换为变量

println(product) // 应该打印：24

def sum(x: Int, y: Int): Int = x + yval sumToTen = sum(10, _: Int)val sumFiveAndTen = sumToTen(5)

println(sumFiveAndTen, 15)

def bar(x: Int, y: Int)(z: String, a: String)(b: Float, c: Float): Int = xval foo = bar(1, 2) _

println(foo("Some string", "Another string")(3 / 5, 6 / 5), 1)

class User { private var pass = "" def password = pass def password_=(str: String): Unit = {   require(str.nonEmpty, "Password cannot be empty")   require(str.length >= 6, "Password length must be at least 6 characters")   pass = str }}

val user = new Useruser.password = "Secr3tC0de"println(user.password) // 应该打印："Secr3tC0de"

try { user.password = "123" //将会失败，应为它少于6个字符 println("Password should be at least 6 characters")} catch { case _: IllegalArgumentException => println("Invalid password")}

trait Wrapper[F[_]] { def wrap[A](value: A): F[A]}

object OptionWrapper extends Wrapper[Option] { override def wrap[A](value: A): Option[A] = Option(value)}

val wrappedInt = OptionWrapper.wrap(5)println(wrappedInt)

val wrappedString = OptionWrapper.wrap("Hello")println(wrappedString)