用Scala计算级数

目录

题目

分析

源码

检验

​编辑                        

---

题目

/**
 * 请用脚本的方式编程计算并输出下列级数的前n项和Sn,知道Sn刚好大于或等于q为止，其中，q为大于0的整数，其值通过键盘输入。
 * Sn=2/1+3/2+。。。。。。+（n+1）/n
 */

分析

//分析可得该题包含四个变量对象，和Sn，项An=（i+1）/i,项数n，限定值q。

源码

源码一，简单版

import scala.io.StdIn._
import scala.util.control.Breaks._

/**
 * 请用脚本的方式编程计算并输出下列级数的前n项和Sn,知道Sn刚好大于或等于q为止，其中，q为大于0的整数，其值通过键盘输入。
 * Sn=2/1+3/2+。。。。。。+（n+1）/n
 */
//分析可得该题包含四个变量对象，和Sn，项An=（i+1）/i,项数n，限定值q
object Series {
  def main(args:Array[String]): Unit ={
    println("请输入一个整数")
    println("输入q或Q时程序退出......")
    //用Breaks类实现对循环的控制
    breakable{
      //用一个死循环实现对键盘的扫描和键盘的连续输入
      while(true){
        //从键盘输入值，用val保证数据安全性
        val q = readLine()
        //当输入大小写的Q字母时，程序退出
        if(q.toLowerCase()=="q") break
        //用Long(长整型）增加数据输入的长度
        var Sn = 0.0
        var An = 1.0
        var n = 1
        while(Sn<q.toLong){
          An = (n+1)/n.toDouble
          Sn = Sn+An
          n = n+1
        }
        println(f"当 q=$q 时，Sn=$Sn")

      }
      }
    }
}

源码二，加入容错

import scala.io.StdIn._
import scala.util.control.Breaks._
import scala.util.{Try, Success, Failure}

object Series {
  def main(args: Array[String]): Unit = {
    breakable {
      //通过一个死循环，加一个循环控制实现实现连续输入功能
      while (true) {
        println("请输入一个正整数")
        println("输入q或Q退出......")
        //因为从键盘输入的数据，包括各种类型，为了增加容错，故选用readLine()
        val input = readLine()
        //调用Try类，通过模式匹配实现容错处理
        Try(input.toLong) match {
            //判断输入值是否是正数
          case Success(q) if (q <= 0) =>
            println("请输入一个大于0的正整数。")
          case Success(q) =>
            try {
              //实现级数计算的逻辑
              var sn = 0.0
              var n = 1
              var an = 1.0
              while (sn < q) {
                //通过Math.addExact()函数对数据溢出异常进行处理
                an = Math.addExact(n , 1) / n.toDouble
                sn = sn + an
                n = Math.addExact(n, 1)
              }
              println(s"当q=$q, sn=$sn")
            } catch {
                  //对捕获的异常进行处理
              case _: ArithmeticException =>
                println("计算中发生了溢出异常。请尝试输入较小的正整数。")
              case _: Exception =>
                println("发生了未知异常。")
            }
            //实现程序退出功能
          case Failure(_: NumberFormatException) if input.equalsIgnoreCase("q") =>
            println("程序已退出......")
            break
            //异常处理
          case Failure(_: NumberFormatException) =>
            println("输入无效，请输入一个有效的正整数或q退出。")
          case Failure(exception) =>
            println(s"发生了未知异常：${exception.getMessage}")
        }
      }
    }
  }
}

Math.addExact(a,b) 是 Java 中的一个方法，用于执行精确的整数加法操作。它有以下好处：

1. 溢出检查：Math.addExact 方法会在加法操作导致溢出时抛出 ArithmeticException 异常。这可以帮助你在计算过程中检测到溢出情况，从而避免得到错误的结果。

2. 明确的行为：在 Java 中，整数溢出是未定义的行为，可能会导致意外结果。使用 Math.addExact 可以确保在溢出时得到明确的异常，而不是不确定的结果。

3. 代码可读性：在涉及到整数溢出检查的代码中，使用 Math.addExact 可以提高代码的可读性和可维护性。它传达了你的意图，即要执行精确的整数加法操作。

使用 Math.addExact(n, 1) 用于执行 n + 1 的加法操作，这可以确保在加法操作导致溢出时得到异常。这在处理数字计算时是一种良好的实践，特别是当你需要确保结果的准确性和稳定性时。

当处理异常时，Scala 提供了两种主要的方法：使用 `Try` 和 `match`，以及使用 `try` 和 `catch` 块。这两种方法都可以用来捕获和处理异常，但是它们在语法和用法上有一些不同。

**1. 使用 `Try` 和 `match`：**

`Try` 是 Scala 中的一个特殊类，它用于尝试执行可能会引发异常的代码块，并将结果包装在 `Success` 或 `Failure` 对象中，具体取决于代码是否成功执行或引发了异常。你可以使用 `match` 来匹配 `Try` 的结果并相应地处理成功或失败的情况。

```scala
import scala.util.{Try, Success, Failure}

val result: Try[Int] = Try("123".toInt)

result match {
  case Success(value) =>
    println(s"成功：$value")
  case Failure(exception) =>
    println(s"失败：$exception")
}
```

**2. 使用 `try` 和 `catch`：**

`try` 和 `catch` 是类似于其他编程语言中的异常处理机制，用于捕获和处理代码块中的异常。在 Scala 中，你可以使用 `try` 块来尝试执行可能会引发异常的代码，并使用 `catch` 块来捕获并处理异常。

```scala
try {
  val value = "abc".toInt
  println(s"成功：$value")
} catch {
  case e: NumberFormatException =>
    println(s"捕获异常：${e.getMessage}")
} finally {
  println("无论是否有异常，这里的代码都会执行。")
}
```

在上面的示例中，`try` 块尝试将字符串转换为整数，但由于字符串无法转换为整数，将抛出 `NumberFormatException` 异常，然后被 `catch` 块捕获并处理。

总的来说，`Try` 和 `match` 更符合函数式编程的风格，而 `try` 和 `catch` 更接近传统的异常处理机制。选择使用哪种方法取决于个人的偏好和项目的需求。无论哪种方法，异常处理都是编写健壮和可靠代码的重要部分。

运行测试