介绍一些实用的Scala类或对象或特性｜ 青训营笔记

用户2267934174486
332 阅读4分钟

介绍一些冷门的Scala类或对象或特性

[toc]

介绍常见scala compiler option

Scala编译器（Scala Compiler）提供了一系列的选项来修改或定制编译过程。以下是一些常见的Scala编译器选项：

-deprecation：此选项会在你使用被废弃的特性、方法或类时发出警告。

-unchecked：如果你使用了模式匹配但没有覆盖所有可能的情况，或者如果你在泛型代码中做了可能导致ClassCastException的操作，那么此选项会发出警告。

-encoding：此选项允许你设置用于源文件的字符编码，如-encoding UTF-8。

-feature：这个选项会发出警告，当你使用一些需要显式导入或特定编译器选项才能启用的特性时。

-optimise 或 -optimize：这个选项会打开一系列的编译器优化，例如内联和常量折叠等。

-language：此选项可以启用或关闭某些Scala语言特性。

-Xfatal-warnings：此选项将所有警告转化为错误。

-Xlint：启用一系列额外的检查和警告。

-Y：此选项后面跟着的是一些更高级的选项，通常只在需要调试或修改编译器时使用。

-classpath 或 -cp：这个选项可以指定类路径。

-d：此选项可以指定输出目录。

import scala.language.postfixOps

这个引入的是一个特定的语言特性，即后缀操作符（Postfix Operators）。

默认情况下，Scala会对使用无参数方法时省略圆括号报warning。解除warning可以import scala.language.postfixOps或者增加编译选项：-language:postfixOps.

import scala.language.postfixOps
val list = List(1, 2, 3, 4, 5)
println(list size)  // Output: 5

import scala.util.hashing.MurmurHash3;

MurmurHash3是一个高效的非加密哈希算法，常用于哈希表和Bloom过滤器等数据结构。Scala中的MurmurHash3提供了多个静态方法，用于计算不同类型数据的哈希值。

val str = "Hello, World!"
val hash = MurmurHash3.stringHash(str)
println(hash)

val array = Array(1, 2, 3, 4, 5)
val hash = MurmurHash3.arrayHash(array)
println(hash)

val bytes = Array[Byte](1, 2, 3, 4, 5)
val hash = MurmurHash3.bytesHash(bytes)
println(hash)

import scala.collection.immutable.LazyList

LazyList是Scala的一种集合类型，它的元素是惰性计算的。这意味着元素只有在首次访问时才会被计算，并且会被缓存以供后续访问。LazyList在处理大型或无限的数据集时特别有用，因为你不需要一开始就计算所有的元素。

import scala.collection.immutable.LazyList

val lazyList = LazyList.from(1)

import scala.util.Try

Option类的collect方法允许你对Option进行模式匹配，并且只在匹配成功时返回结果。如果模式匹配失败，那么collect方法会返回None。

import scala.util.Try

val number: Option[Int] = Try("123".toInt).toOption
val result = number.collect { case n if n > 100 => "Big number" }

import scala.collection.generic.CanBuildFrom

CanBuildFrom是一个类型类，它用于定义如何构建一个集合。虽然它在大多数情况下都不需要显式使用，但了解其工作原理有助于理解Scala的集合库。

import scala.collection.mutable.ArrayBuffer
import scala.collection.generic.CanBuildFrom

def concat[T, C[_]](c1: C[T], c2: C[T])(implicit ev: C[T] => Traversable[T], cbf: CanBuildFrom[C[T], T, C[T]]): C[T] = {
  val builder = cbf()
  builder ++= c1
  builder ++= c2
  builder.result()
}

val arrayBuffer1 = ArrayBuffer(1, 2, 3)
val arrayBuffer2 = ArrayBuffer(4, 5, 6)
val result = concat(arrayBuffer1, arrayBuffer2)

import scala.language.higherKinds

这个特性用于启用高阶类型（Higher-Kinded Types）。高阶类型是一种允许类型接受类型参数的类型。这是一种非常强大的功能，可以用于创建复杂的类型抽象，如functors和monads。

import scala.language.higherKinds

trait Functor[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
}

import scala.util.control.TailCalls._

TailCalls可以帮助你创建尾递归函数，即使在Scala语言本身不支持尾递归优化的情况下也是如此。尾递归函数是一种特殊类型的函数，其中最后一个操作是递归调用，这可以避免在深度递归时导致栈溢出。

import scala.util.control.TailCalls._

def factorial(n: Int): TailRec[Int] =
  if (n == 0) done(1) else tailcall(factorial(n - 1).map(_ * n))

import scala.language.implicitConversions

这个特性用于启用隐式转换。隐式转换可以自动转换类型，从而提高代码的可读性和灵活性。

import scala.language.implicitConversions

implicit def stringToInt(s: String): Int = s.toInt

val x: Int = "123"  // String is automatically converted to Int

import scala.concurrent.Future

Future是一个表示未完成的异步计算的容器。使用Future可以在不阻塞主线程的情况下执行耗时的操作，例如网络请求或文件I/O。

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

val future: Future[Int] = Future {
  // simulate a long-running computation
  Thread.sleep(1000)
  42
}

import scala.util.matching.Regex

Regex类提供了对正则表达式的支持。你可以使用正则表达式进行复杂的字符串匹配和替换。

import scala.util.matching.Regex

val regex: Regex = "[a-z]+".r
val matches: Iterator[Match] = regex.findAllMatchIn("hello, world")
avatar
文章
阅读
粉丝