Scala初学者指南

object Main {
  def main(args: Array[String]): Unit =
    println("Hello, Scala developer!")
}

object Main extends App {
  println("Hello, Scala developer!")
}

val x = 1
// x = 2 // 这会报错，因为不能给 val 变量重新赋值

var y = 1
y = 2 // 这是合法的，因为 y 是一个 var 变量

val x: Int = 1 + 1
var x: Int = 1 + 1

object Main extends App {
  trait Animal {
    def speak: String
  }

  class Dog extends Animal {
    def speak = "Woof!"
  }

  class Cat extends Animal {
    def speak = "Meow!"
  }

  class Parrot extends Animal {
    def speak = "Squawk!"
  }

  class AnimalShelter[A <: Animal] {
    private var animals: List[A] = Nil

    def addAnimal(animal: A): Unit = {
      animals = animal :: animals
    }

    def getAnimal: A = {
      val animal = animals.head
      animals = animals.tail
      animal
    }
  }

  val dogShelter = new AnimalShelter[Dog]
  dogShelter.addAnimal(new Dog)
  val dog: Dog = dogShelter.getAnimal
  println(dog.speak)

  val catShelter = new AnimalShelter[Cat]
  catShelter.addAnimal(new Cat)
  val cat: Cat = catShelter.getAnimal
  println(cat.speak)

  val parrotShelter = new AnimalShelter[Parrot]
  parrotShelter.addAnimal(new Parrot)
  val parrot: Parrot = parrotShelter.getAnimal
  println(parrot.speak)
}

输出：
Woof!
Meow!
Squawk!

import users._  // 导入包 users 中的所有成员
import users.User  // 导入类 User
import users.{User, UserPreferences}  // 仅导入选择的成员
import users.{UserPreferences => UPrefs}  // 导入类并且设置别名

def sqrtplus1(x: Int) = {
  import scala.math.sqrt
  sqrt(x) + 1.0
}

package accounts

import _root_.users._

// File: com/example/myapp/package.scala

package com.example

package object myapp {
  val appName: String = "MyApp"

  def printAppName(): Unit = {
    println(appName)
  }
}

package com.example.myapp

object Main {
  def main(args: Array[String]): Unit = {
    println(myapp.appName)  // 直接访问包对象中的常量
    myapp.printAppName()    // 直接调用包对象中的方法
  }
}

trait A {
  def printA() = println("A")
}

trait B {
  def printB() = println("B")
}

class C extends A with B

object Main extends App {
  val c = new C
  c.printA()
  c.printB()
}

输出：
A
B

trait Greeter {
  def greet(name: String): Unit =
    println("Hello, " + name + "!")
}

class DefaultGreeter extends Greeter

class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
  override def greet(name: String): Unit = {
    println(prefix + name + postfix)
  }
}

val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!

val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?

import scala.collection.mutable.ArrayBuffer

trait Pet {
  val name: String
}

class Cat(val name: String) extends Pet
class Dog(val name: String) extends Pet

val dog = new Dog("Harry")
val cat = new Cat("Sally")

val animals = ArrayBuffer.empty[Pet]
animals.append(dog)
animals.append(cat)
animals.foreach(pet => println(pet.name))  // Prints Harry Sally

class Vector2D(val x: Double, val y: Double) {
  def +(other: Vector2D): Vector2D = {
    new Vector2D(x + other.x, y + other.y)
  }
}

val v1 = new Vector2D(1.0, 2.0)
val v2 = new Vector2D(3.0, 4.0)
val sum = v1 + v2

println(sum.x) // 输出：4.0
println(sum.y) // 输出：6.0

val num1 = 10
val num2 = 5

val sum = num1 + num2
val difference = num1 - num2
val product = num1 * num2

println(sum)        // 输出：15
println(difference)  // 输出：5
println(product)     // 输出：50

def callByName(param: => Int): Unit = {
  println("Inside callByName")
  println("Param 1: " + param)
  println("Param 2: " + param)
}

def randomNumber(): Int = {
  println("Generating random number")
  scala.util.Random.nextInt(100)
}

callByName(randomNumber())

implicit def intToString(x: Int): String = x.toString

val x: String = 1
println(x) // 输出 "1"

implicit val x: Int = 1

def foo(implicit x: Int): Unit = println(x)

foo // 输出 1

class MyClass(x: Int) {
  def printX(): Unit = println(x)
}

val a = new MyClass(1)
val b = new MyClass(2)
a.printX() // 输出 1
b.printX() // 输出 2

class Point(var x: Int = 0, var y: Int = 0)

val origin = new Point  // x and y are both set to 0
val point1 = new Point(1)
println(point1.x)  // prints 1

class Point(var x: Int = 0, var y: Int = 0)
val point2 = new Point(y=2)
println(point2.y)  // prints 2

object MyObject {
  val x = 1
  def printX(): Unit = println(x)
}

MyObject.printX() // 输出 1

class MyClass(x: Int) {
  private val secret = 42
  def printCompanionSecret(): Unit = println(MyClass.companionSecret)
}

object MyClass {
  private val companionSecret = 24
  def printSecret(c: MyClass): Unit = println(c.secret)
}

val a = new MyClass(1)
a.printCompanionSecret() // 输出 24
MyClass.printSecret(a) // 输出 42

case class Person(var name: String, var age: Int)

object Test01 {
  case class Person(var name: String, var age: Int)

  def main(args: Array[String]): Unit = {
    val z = Person("张三", 20)
    z.age = 23
    println(s"z = $z")
  }
}

x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}

val (x, _, z) = (1, 2, 3)

val list = List(1, 2, 3)
list.map(_ * 2)

def add(x: Int, y: Int) = x + y
val f = add _

println("Hello, world!")

val x = 1
println(x)

val x = 1
val y = 2
println(x + y)

val name = "Alice"
val age = 18
println(s"My name is $name and I am $age years old.")

object Main {
  def main(args: Array[String]): Unit = {
    // 定义一个空的字符串列表
    var emptyList: List[String] = List()
    // 定义一个具有数据的列表
    var intList = List(1, 2, 3, 4, 5, 6)
    // 定义空列表
    var emptyList2 = Nil
    // 使用::运算符连接元素
    var numList = 1 :: (2 :: (3 :: Nil))
    println(emptyList)
    println(intList)
    println(emptyList2)
    println(numList)
  }
}

输出：
List()
List(1, 2, 3, 4, 5, 6)
List()
List(1, 2, 3)

val list = List(1, 2, 3, 4)

// 获取列表的长度
val length = list.length

// 获取列表的第一个元素
val first = list.head

// 获取列表的最后一个元素
val last = list.last

// 获取列表除第一个元素外剩余的元素
val tail = list.tail

// 获取列表除最后一个元素外剩余的元素
val init = list.init

// 反转列表
val reversed = list.reverse

// 在列表头部添加元素
val newList1 = 0 +: list

// 在列表尾部添加元素
val newList2 = list :+ 5

// 连接两个列表
val list1 = List(1, 2)
val list2 = List(3, 4)
val concatenatedList = list1 ++ list2

// 检查列表是否为空
val isEmpty = list.isEmpty

// 检查列表是否包含某个元素
val containsElement = list.contains(1)

// 过滤列表中的元素
val filteredList = list.filter(_ > 2)

// 映射列表中的元素
val mappedList = list.map(_ * 2)

// 折叠列表中的元素（从左到右）
val sum1 = list.foldLeft(0)(_ + _)

// 折叠列表中的元素（从右到左）
val sum2 = list.foldRight(0)(_ + _)

// 拉链操作
val names = List("Alice", "Bob", "Charlie")
val ages = List(25, 32, 29)
val zipped = names.zip(ages) // List(("Alice", 25), ("Bob", 32), ("Charlie", 29))

// 拉链操作后解压缩
val (unzippedNames, unzippedAges) = zipped.unzip // (List("Alice", "Bob", "Charlie"), List(25, 32, 29))

object Main {
  def main(args: Array[String]): Unit = {
    // 定义一个空的映射
    val emptyMap = Map()
    // 定义一个具有数据的映射
    val intMap = Map("key1" -> 1, "key2" -> 2)
    // 使用元组定义一个映射
    val tupleMap = Map(("key1", 1), ("key2", 2))
    println(emptyMap)
    println(intMap)
    println(tupleMap)
  }
}

输出：
Map()
Map(key1 -> 1, key2 -> 2)
Map(key1 -> 1, key2 -> 2)

val map = Map("key1" -> 1, "key2" -> 2)

// 获取映射的大小
val size = map.size

// 获取映射中的所有键
val keys = map.keys

// 获取映射中的所有值
val values = map.values

// 检查映射是否为空
val isEmpty = map.isEmpty

// 检查映射是否包含某个键
val containsKey = map.contains("key1")

// 获取映射中某个键对应的值
val value = map("key1")

// 获取映射中某个键对应的值，如果不存在则返回默认值
val valueOrDefault = map.getOrElse("key3", 0)

// 过滤映射中的元素
val filteredMap = map.filter { case (k, v) => v > 1 }

// 映射映射中的元素
val mappedMap = map.map { case (k, v) => (k, v * 2) }

// 遍历映射中的元素
map.foreach { case (k, v) => println(s"key: $k, value: $v") }

// 定义一个从1到5的整数序列，包括1和5
val range1 = 1 to 5

// 定义一个从1到5的整数序列，包括1但不包括5
val range2 = 1 until 5

// 定义一个从1到10的整数序列，步长为2
val range3 = 1 to 10 by 2

// 定义一个从10到1的整数序列，步长为-1
val range4 = 10 to 1 by -1

val range = 1 to 5
val list = range.toList

val range = 1 to 10 by 2

// 获取序列的起始值
val start = range.start

// 获取序列的结束值
val end = range.end

// 获取序列的步长
val step = range.step

// 获取一个包括结束值的新序列
val inclusiveRange = range.inclusive

object Main {
  def main(args: Array[String]): Unit = {

    val list = List(1, 2, 3)
    val iterator = list.iterator

    // 1. 使用 hasNext 方法来检查迭代器中是否还有元素
    val hasMoreElements = iterator.hasNext
    println(s"Has more elements: $hasMoreElements")

    // 2. 使用 next 方法来获取迭代器中的下一个元素
    val nextElement = iterator.next()
    println(s"Next element: $nextElement")

    // 注意：上面的代码已经将迭代器移动到了第二个元素，因此下面的代码将从第二个元素开始执行

    // 3. 使用 size 方法来获取迭代器中元素的个数
    val size = iterator.size
    println(s"Size: $size")

    val size1 = iterator.size
    println(s"Size1: $size1")

    // 注意：上面的代码已经将迭代器移动到了末尾，因此下面的代码将不再有效

    // 4. 使用 contains 方法来检查迭代器中是否包含某个元素
    val containsElement = iterator.contains(2)
    println(s"Contains element: $containsElement")
  }
}

输出：
Has more elements: true
Next element: 1
Size: 2
Size1: 0
Contains element: false

object Main {
  def main(args: Array[String]): Unit = {
    // 定义一个包含两个元素的Tuple
    val tuple1 = (1, "hello")
    println(tuple1)

    // 定义一个包含三个元素的Tuple
    val tuple2 = (1, "hello", true)
    println(tuple2)

    // 定义一个包含多个不同类型元素的Tuple
    val tuple3 = (1, "hello", true, 3.14)
    println(tuple3)

    // 访问Tuple中的元素
    val firstElement = tuple3._1
    val secondElement = tuple3._2
    println(s"first element: $firstElement, second element: $secondElement")
  }
}

输出：
(1,hello)
(1,hello,true)
(1,hello,true,3.14)
first element: 1, second element: hello

object Main {
  def main(args: Array[String]): Unit = {
    val tuple = (1, "hello")
    // 交换二元组的元素
    // 输出：(hello,1)
    val swapped = tuple.swap

    // 使用 copy 方法来创建一个新的 Tuple，其中某些元素被替换为新值
    //输出：(1,world)
    val newTuple = tuple.copy(_2 = "world")

    // 遍历元素
    // 输出： 1 hello
    tuple.productIterator.foreach(println)

    // 转换为字符串
    // 输出： (1,hello)
    val stringRepresentation = tuple.toString

    // 使用 Tuple.productArity 方法来获取 Tuple 中元素的个数
    // 输出： 2
    val arity = tuple.productArity

    // 使用 Tuple.productElement 方法来访问 Tuple 中的元素
    // 输出： 1
    val firstElement = tuple.productElement(0)
  }
}

object Email {
  def apply(user: String, domain: String): String = s"$user@$domain"
  
  def unapply(email: String): Option[(String, String)] = {
    val parts = email.split("@")
    if (parts.length == 2) Some(parts(0), parts(1))
    else None
  }
}

// 测试
val address = "john.doe@example.com"
address match {
  case Email(user, domain) => println(s"User: $user, Domain: $domain")
  case _ => println("Invalid email address")
}

object Main {
  def main(args: Array[String]): Unit = {
    println("----while----")
    var i = 0
    while (i < 5) {
      println(i)
      i += 1
    }

    println("----if----")
    val x = 3
    if (x > 0) {
      println("x大于0")
    } else {
      println("x小于0")
    }
  }
}

输出：
----while----
0
1
2
3
4
----if----
x大于0

object Main {
  def main(args: Array[String]): Unit = {
  println("----for循环----")
    for (i <- 1 to 5) {
      println(i)
    }
  }
}

输出：
----for循环----
1
2
3
4
5

public class Main {
  public static void main(String[] args) {
    // 多重for循环
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++) {
        System.out.println(i + " " + j);
      }
    }
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    // 多重for循环
    for (i <- 0 until 3; j <- 0 until 3) {
      println(i + " " + j)
    }
  }
}

输出：
0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = for (i <- 1 to 5) yield i * 2
    println(numbers)
  }
}

输出：
Vector(2, 4, 6, 8, 10)

object Main {
  def main(args: Array[String]): Unit = {
    def matchTest(x: Any): String = x match {
      case 1 => "one"
      case "two" => "two"
      case y: Int => "scala.Int"
      case _ => "many"
    }

    println(matchTest(1))
    println(matchTest("two"))
    println(matchTest(3))
    println(matchTest("test"))
  }
}

输出：
one
two
scala.Int
many

abstract class Notification

case class Email(sender: String, title: String, body: String) extends Notification

case class SMS(caller: String, message: String) extends Notification

def showNotification(notification: Notification): String = {
  notification match {
    case Email(sender, title, _) =>
      s"You got an email from $sender with title: $title"
    case SMS(number, message) =>
      s"You got an SMS from $number! Message: $message"
  }
}

val someSms = SMS("12345", "Are you there?")
val someEmail = Email("John Doe", "Meeting", "Are we still meeting tomorrow?")

println(showNotification(someSms))
println(showNotification(someEmail))

def checkNumberType(number: Int): String = number match {
  case n if n > 0 && n % 2 == 0 => "Positive even number"
  case n if n > 0 && n % 2 != 0 => "Positive odd number"
  case n if n < 0 && n % 2 == 0 => "Negative even number"
  case n if n < 0 && n % 2 != 0 => "Negative odd number"
  case _ => "Zero"
}

// 测试
println(checkNumberType(10))    // 输出: Positive even number
println(checkNumberType(15))    // 输出: Positive odd number
println(checkNumberType(-4))    // 输出: Negative even number
println(checkNumberType(-9))    // 输出: Negative odd number
println(checkNumberType(0))     // 输出: Zero

def processValue(value: Any): String = value match {
  case str: String => s"Received a String: $str"
  case num: Int => s"Received an Int: $num"
  case lst: List[_] => s"Received a List: $lst"
  case _: Double => "Received a Double"
  case _ => "Unknown value"
}

// 测试
println(processValue("Hello"))                // 输出: Received a String: Hello
println(processValue(10))                     // 输出: Received an Int: 10
println(processValue(List(1, 2, 3)))           // 输出: Received a List: List(1, 2, 3)
println(processValue(3.14))                    // 输出: Received a Double
println(processValue(true))                    // 输出: Unknown value

sealed abstract class Shape

case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape
case class Square(side: Double) extends Shape

def calculateArea(shape: Shape): Double = shape match {
  case Circle(radius) => math.Pi * radius * radius
  case Rectangle(width, height) => width * height
  case Square(side) => side * side
}

// 测试
val circle = Circle(5.0)
val rectangle = Rectangle(3.0, 4.0)
val square = Square(2.5)

println(s"Area of circle: ${calculateArea(circle)}")         // 输出: Area of circle: 78.53981633974483
println(s"Area of rectangle: ${calculateArea(rectangle)}")   // 输出: Area of rectangle: 12.0
println(s"Area of square: ${calculateArea(square)}")         // 输出: Area of square: 6.25

def calculateDiscountedPrice(originalPrice: Double, discountPercentage: Double): Double = {
  def applyDiscount(price: Double, discount: Double): Double = {
    val discountedPrice = price - (price * discount)
    discountedPrice
  }

  def validateDiscount(discount: Double): Double = {
    val maxDiscount = 0.8 // 最大折扣为80%
    if (discount > maxDiscount) {
      maxDiscount
    } else {
      discount
    }
  }

  val validatedDiscount = validateDiscount(discountPercentage)
  val finalPrice = applyDiscount(originalPrice, validatedDiscount)
  finalPrice
}

// 调用外部方法
val price = calculateDiscountedPrice(100.0, 0.9)
println(s"The final price is: $price")

object Main extends App {
  val emailPattern = "([a-zA-Z0-9_.+-]+)@([a-zA-Z0-9-]+)\\.([a-zA-Z0-9-.]+)".r

  def validateEmail(email: String): Boolean = email match {
    case emailPattern(username, domain, extension) =>
      println(s"Valid email address: $email")
      true
    case _ =>
      println(s"Invalid email address: $email")
      false
  }

  // 测试
  validateEmail("john.doe@example.com")        // 输出: Valid email address: john.doe@example.com
  validateEmail("jane.doe@invalid")            // 输出: Invalid email address: jane.doe@invalid
}

class Animal
class Dog extends Animal

class Cage[+A]

val dogCage: Cage[Dog] = new Cage[Dog]
val animalCage: Cage[Animal] = dogCage

class Animal
class Dog extends Animal

class Cage[-A]

val animalCage: Cage[Animal] = new Cage[Animal]
val dogCage: Cage[Dog] = animalCage

abstract class Animal {
  def name: String
}

class Dog(val name: String) extends Animal {
  def bark(): Unit = println("Woof!")
}

class Cat(val name: String) extends Animal {
  def meow(): Unit = println("Meow!")
}

class Cage[+A](val animal: A) {
  def showAnimal(): Unit = println(animal.name)
}

def printAnimalNames(cage: Cage[Animal]): Unit = {
  cage.showAnimal()
}

val dog: Dog = new Dog("Fido")
val cat: Cat = new Cat("Whiskers")

val dogCage: Cage[Dog] = new Cage[Dog](dog)
val catCage: Cage[Cat] = new Cage[Cat](cat)

printAnimalNames(dogCage) // 输出：Fido
printAnimalNames(catCage) // 输出：Whiskers

abstract class Animal {
  def name: String
}

class Dog(val name: String) extends Animal {
  def bark(): Unit = println("Woof!")
}

class Cage[A <: Animal](val animal: A) {
  def showAnimal(): Unit = println(animal.name)
}

val dog: Dog = new Dog("Fido")
val cage: Cage[Animal] = new Cage[Dog](dog)

cage.showAnimal() // 输出：Fido

class Animal {
  def sound(): Unit = println("Animal sound")
}

class Dog extends Animal {
  override def sound(): Unit = println("Dog barking")
}

class Cat extends Animal {
  override def sound(): Unit = println("Cat meowing")
}

def makeSound[A >: Dog](animal: A): Unit = {
  animal.sound()
}

val dog: Dog = new Dog
val cat: Cat = new Cat

makeSound(dog) // 输出：Dog barking
makeSound(cat) // 输出：Animal sound

class Outer {
  private val outerField: Int = 10

  class Inner {
    def printOuterField(): Unit = {
      println(s"Outer field value: $outerField")
    }
  }
}

val outer: Outer = new Outer
val inner: outer.Inner = new outer.Inner
inner.printOuterField() // 输出：Outer field value: 10

def outerMethod(): Unit = {
  val outerField: Int = 10

  class Inner {
    def printOuterField(): Unit = {
      println(s"Outer field value: $outerField")
    }
  }

  val inner: Inner = new Inner
  inner.printOuterField() // 输出：Outer field value: 10
}

outerMethod()

trait Flyable {
  def fly(): Unit
}

trait Swimmable {
  def swim(): Unit
}

class Bird extends Flyable {
  override def fly(): Unit = println("Flying...")
}

class Fish extends Swimmable {
  override def swim(): Unit = println("Swimming...")
}

def action(obj: Flyable with Swimmable): Unit = {
  obj.fly()
  obj.swim()
}

val bird: Bird = new Bird
val fish: Fish = new Fish

action(bird) // 输出：Flying...
action(fish) // 输出：Swimming...

def printType[T](value: T): Unit = {
  value match {
    case s: String => println("String: " + s)
    case i: Int => println("Int: " + i)
    case d: Double => println("Double: " + d)
    case _ => println("Unknown type")
  }
}

printType("Hello") // 输出：String: Hello
printType(123) // 输出：Int: 123
printType(3.14) // 输出：Double: 3.14
printType(true) // 输出：Unknown type

import java.util.Date
object Main {
  def main(args: Array[String]): Unit = {
    printCurrentDate() // 输出当前日期和时间
  }
  def printCurrentDate(): Unit = {
    val currentDate = new Date()
    println(currentDate.toString)
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    greet() // 输出 "Hello, World!"
    greet("Alice") // 输出 "Hello, Alice!"
  }

  def greet(name: String = "World"): Unit = {
    println(s"Hello, $name!")
  }
}

def applyFuncToList(list: List[Int], f: Int => Int): List[Int] = {
  list.map(f)
}

val numbers = List(1, 2, 3, 4)
val double = (x: Int) => x * 2
val doubledNumbers = applyFuncToList(numbers, double) // List(2, 4, 6, 8)

object Main {
  def main(args: Array[String]): Unit = {
    val add = (x: Int, y: Int) => x + y
    println(add(1, 2))  //输出： 3
  }
}

object Main {
  def main(args: Array[String]): Unit = {

    println(divide.isDefinedAt(0)) // false
    println(divideSafe.isDefinedAt(0)) // true

    println(divide(1)) // 42
    println(divideSafe(1)) // Some(42)

    // println(divide(0)) // 抛出异常
    println(divideSafe(0)) // None
  }

  val divide: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 42 / d
  }

  val divideSafe: PartialFunction[Int, Option[Int]] = {
    case d: Int if d != 0 => Some(42 / d)
    case _ => None
  }

}

def add(a: Int)(b: Int): Int = a + b

val result = add(1)(2) // 3

val addOne = add(1) _
val result = addOne(2) // 3

def sum(x: Int, y: Int): Int = {
  println("sum函数被执行了...")
  x + y
}

lazy val res: Int = sum(1, 2)

println("-----")
println(res)