Scala - 数值类型

Scala 数值类型 提供了对数字的基本理解和管理。它确保了应用程序的准确性并提升了编码效率。在本教程中，我们将了解 Scala 中的 数值类型。

Scala 数值类型基础

Scala 提供了各种数值类型来满足计算需求。开发者可以处理多种格式，并在计算中确保效率和精度。这些数值类型包括 Integral types（整数类型）和 Floating types（浮点类型）。我们还将讨论它们的类型范围。下面将简要介绍这些内容。

1. Integral Types（整数类型）

在 Scala 中，有多种 Integral types 用于表示整数。这些整数类型包括 Short、Int、Long 和 Byte。每种类型都有特定的范围。例如，

val byteVal: Byte = 125
val shortVal: Short = 32767
val intVal: Int = 2135482547
val longVal: Long = 9223372036854775807L

2. Floating-Point Types（浮点类型）

Scala 提供了 Float 和 Double 用于表示小数。您可以根据精度需求进行选择。例如，

val floatVal: Float = 2.718F
val doubleVal: Double = 2.718281828459045

3. Type Ranges（类型范围）

Integral types 和 Floating types 都有各自特定的范围。因此，您可以为特定任务选择合适的类型。以下是它们范围的简要说明：

数值类型：Integers 和 Floating Points

在 Scala 中，数字分为两种类型：Integers（整数）和 Floating Points（浮点数）。这些是 Scala 程序中用于各种数学计算的基本数字类型。对于简单算术和复杂算法，它们都很重要。

1. Arithmetic Operations（算术运算）

您可以直接使用像 *、/、+、- 等运算符对 Integers 执行算术运算。例如，

val difference: Int = 8 - 3
val quotient: Int = 15 / 3
val sum: Int = 5 + 3
val product: Int = 5 * 3
val power: Int = 2 ^ 3

对于 Floating Point numbers，结果可能不同，但运算符始终相同。例如，

val difference: Float = 8.0f - 3.0f
val quotient: Float = 15.0f / 3.0f
val sum: Float = 5.0f + 3.0f
val product: Float = 5.0f * 3.0f
val power: Float = math.pow(2.0, 3.0).toFloat

2. Type Casting（类型转换）

您可能需要将 Integers 转换为 Floating Point numbers 或反之。为此，可以使用 Type Casting。在 Scala 中，这里使用像 toFloat 和 toInt 等方法。例如，

val integerValue: Int = 10
val doubleValue: Double = integerValue.toDouble

反之亦然，

val floatValue: Float = 7.5f
val integerValue: Int = floatValue.toInt

数值类型 - Comparisons and Equality（比较和相等性）

有时，您需要比较 integers 和 floating points。您可以使用标准的比较符号，如 ==、!=、<、>、<= 和 >= 来实现。例如，

val isNotEqual: Boolean = 8 != 3
val isLessOrEqual: Boolean = 2.0 <= 2.5

在比较 floating points 时，需要注意精度问题。微小的舍入误差可能导致意外结果。最好检查两个 floating points 是否“足够接近”，而不是精确相等。

精度与限制

数值类型的精度及其固有限制非常重要。Scala 为其数值类型定义了边界和行为，开发者需要了解这些。

1. 浮点精度

在 Scala 中，浮点数由 Float 和 Double 表示。这两种类型都有固有的精度限制。你可以存储小数值，但它们可能无法始终被精确存储。例如，

val sumResult: Double = 1.5 + 2.7
println(sumResult)  // 由于精度问题，可能不是精确的 4.2

2. 整数溢出

在 Scala 中，Integer 是固定大小的。由于固定大小，它们可能出现下溢和溢出情况。当整数超过其最小值时，它会回绕到最大值，反之亦然。例如，

val minInt: Int = Int.MinValue
val underflowed: Int = minInt - 1

3. 舍入误差

处理浮点数可能很棘手，因为存在舍入误差。这些误差发生是因为二进制系统可能无法完美表示某些十进制小数。例如，

val roundedValue: Double = Math.round(0.785 * 100) / 100.0
println(roundedValue)  // 由于舍入误差，可能不是精确的 0.79

4. 安全操作

为了避免精度问题，尤其是在处理浮点数时，你可以使用任意精度算术库。这些工具可以提供准确的结果。

数值类型之间的类型转换和强制转换

In Scala 中，你可能需要进行数据转换，即将一种数据类型转换为另一种类型。此过程称为 Casting。它用于在表示浮点格式时减少错误。

1. 隐式和显式转换

Scala 同时支持 Explicit 和 Implicit 类型转换。当上下文需要时，Implicit 会自动发生。而开发者可以在需要时进行 explicit 转换。例如，

val floatValue: Float = 7.5f
val intValue: Int = floatValue.toInt  // 隐式转换

显式转换：

val floatVal2: Float = 3.14f
val intVal2: Int = floatVal2.toInt  // 显式转换

当你从较大的类型强制转换为较小的类型时，有可能丢失数据。例如，

val largeFloat: Float = 1.5e7f
val castedInt: Int = largeFloat.toInt  // 可能的数据丢失

在转换之前，你应该注意这一点并处理此类错误。在 Scala 中，Numeric types 存在一个层次结构。该层次结构如下所示。

2. 泛型 Numeric 操作

In Scala 中，Numeric types 提供了多功能性和精确性。你可以创建适用于任何 numeric types 的泛型 function。例如，如果你需要一个适用于任何 numeric type 的 function。类似于这种 Haskell 方法：

case class NumericPair[A](first: A, second: A)(implicit num: Numeric[A])

你可以使用 Numeric[A] trait 执行各种操作，如减法、加法、乘法和除法。基本类型如 Float 和 Int 并不直接扩展它。它提供了 implicit objects。例如，使用 num.plus(a, b) 而非 a+b。

3. 自定义 Numeric Types

有时，内置的 numeric types 无法满足你的需求。例如，如果你想定义一个自定义的 Decimal type 以进行精确计算。虽然你不能直接扩展 Numeric trait，但你可以为该类型创建 instance。

final class CustomNumber(val value: Int) extends AnyVal

object CustomNumber {
   implicit val numeric: Numeric[CustomNumber] = new Numeric[CustomNumber] {
      // 定义 plus、minus、times 等操作
   }
}

4. 使用 Numeric Types 的 Vector 操作

Vector 是一种在许多应用中使用的数据结构，如物理和图形模拟。在 Scala 中创建泛型 Vector class 时，你可能需要使其兼容所有 numeric types。

class Point2D[@specialized T](val x: T, val y: T)(implicit num: Numeric[T]) {
   def +(other: Point2D[T]) = new Point2D(num.plus(x, other.x), num.plus(y, other.y))
}

这种方法涉及使用 `@specialized` annotation 来针对特定类型进行优化。它确保高效操作，而不会产生 boxing 的开销。

5. 安全的除法和处理

你可以使用 Option type 处理除零错误。例如，

def safeDivision(dividend: Int, divisor: Int): Option[Int] = if (divisor == 0) None else Some(dividend / divisor)

你需要使用 `map` function 处理结果：

safeDivision(6, 2).map(_ * 6)  // 返回值为 Some(18) 的 Option[Int]

使用数值类型优化性能

您可以使用 Numeric 类型来优化 Scala 程序。

专用注解

当在 Scala 程序中使用专用注解时，编译器会生成优化的字节码，并减少 unboxing 和 boxing 操作的开销。例如，

def multiply[@specialized(Int, Double) T](a: T, b: T)(implicit numeric: Numeric[T]): T = numeric.times(a, b)

Boxing 和 Unboxing 是将基本类型包装（boxing）成对象对应类型以及反向的过程。这可能会带来性能开销。您可以使用 value classes 来避免这种开销。例如，

final class EnhancedDouble(val value: Double) extends AnyVal {
   def cube: Double = value * value * value
}

由于 AnyVal 扩展，不会产生任何对象开销。

请注意，Scala 中有 BigInt 和 BigDecimal 用于大数运算。但这些是不可变的，可能比基本类型慢。