如何在Scala中获取用户的输入？

我想从用户那里获取输入。您能告诉我如何在Scala中以字符串形式请求用户输入吗？

来自（格式和链接已更新）：

简短答复:

readInt

长答覆：

如果您想从终端读取数据，请签出。 您可以这样使用这些函数：

Console.readInt

另外，为了您的方便， 在

控制台

中自动定义一些函数的快捷方式。自从

Predef

中的内容总是在任何地方自动导入，您可以 可以这样使用它们：

readInt

请试一试

scala>readint

请在Scala 2.11使用中尝试此方法

scala.io.StdIn.readLine()

---

这里不是弃用的

控制台.readLine

而是读取整数值的标准方法

val a=scala.io.StdIn.readInt()
println("The value of a is "+ a)

同样地

def readBoolean（）：Boolean 从stdin的整行读取布尔值

def readByte（）：字节 从stdin的整行读取字节值

def readChar（）：Char 从stdin的整行读取字符值

def readDouble（）：Double 从stdin的整行读取双精度值

def readFloat（）：浮点 从stdin的整行读取浮点值

def readInt（）：Int 从stdin的整行读取Int值

def readLine（文本：字符串，参数：任意*）：字符串 将格式化文本打印到标准输出，并从标准输入中读取整行内容

def readLine（）：字符串 从stdin读取一整行

def readLong（）：Long 从stdin的整行读取长值

def readShort（）：Short 从stdin的整行读取短值

def readf（格式：字符串）：列表[任何] 按照格式说明符的指定从stdin读入结构化输入

def readf1（格式：字符串）：任意 按照格式说明符的指定从stdin读入结构化输入，返回 根据格式规范，仅提取第一个值

def readf2（格式：字符串）：（任意，任意） 按照格式说明符的指定从stdin读入结构化输入，返回 根据格式规范，仅提取前两个值

def readf3（格式：字符串）：（任意、任意、任意） 按照格式说明符的指定从stdin读入结构化输入，返回 根据格式规范，仅提取前三个值

类似地，如果要从同一行读取多个用户输入，例如：姓名、年龄、体重，则可以使用Scanner对象

import java.util.Scanner

// simulated input
val input = "Joe 33 200.0"
val line = new Scanner(input)
val name = line.next
val age = line.nextInt
val weight = line.nextDouble

从Scala食谱中节选：Alvin Alexander的面向对象和函数式编程食谱

object InputTest extends App{

    println("Type something : ")
    val input = scala.io.StdIn.readLine()
    println("Did you type this ? " + input)

}

通过这种方式，您可以请求输入

scala.io.StdIn.readLine()

---

readLine允许提示用户并将其输入作为字符串读取

val name = readLine("What's your name? ")

---

从用户处读取输入的简单示例

val scanner = new java.util.Scanner(System.in)

scala> println("What is your name") What is your name

scala> val name = scanner.nextLine()
name: String = VIRAJ

scala> println(s"My Name is $name")
My Name is VIRAJ

我们也可以使用读线

val name = readLine("What is your name ")
What is your name name: String = Viraj

---

在Scala 2中：

import java.io._
object Test {
    // Read user input, output
    def main(args: Array[String]) {

        // create a file writer
        var writer = new PrintWriter(new File("output.txt"))

       // read an int from standard input
       print("Enter the number of lines to read in: ")
       val x: Int = scala.io.StdIn.readLine.toInt

       // read in x number of lines from standard input
       var i=0
       while (i < x) {
           var str: String = scala.io.StdIn.readLine
           writer.write(str + "\n")
           i = i + 1
       }

       // close the writer
       writer.close
     }
}

---

您可以使用readLine（）接受用户字符串输入

也可以使用scanner类获取用户输入

import java.util.Scanner;

object q1 {
  def main(args:Array[String]):Unit={ 
      val scanner = new Scanner(System.in)
    println("Enter your name : ")
    val a = scanner.nextLine()
    println("My name is : "+a)
  }
}

使用线程轮询输入读线：
//keystop1.sc
//在Scala或SBT控制台/Quick REPL:：load Keysp1.sc中
//作为脚本：scala-savecompiled keystop1.sc
@volatile var isRunning=true
@volatile var isPause=false
val tInput:Thread=新线程{
覆盖def运行：单位={
var status=“”
同时（正在运行）{
这是同步的{
status=scala.io.StdIn.readLine（）
身份匹配{
案例“s”=>isRunning=false
案例“p”=>isPause=true
案例“r”=>isRunning=true；isPause=false
案例=>isRunning=false；isPause=false
}
println（s“新状态为：$status”）
}
}
}
}
tInput.start
变量计数=0
var pauseCount=0
同时（正在运行和计数<10）{
println（s“仍在运行持久作业！$count”）
如果（计数%3==0）println（（请按[each+ENTER]：s停止，p暂停，r再次运行！））
计数+=1
线程睡眠（2000）//模拟繁重的计算
while（isPause）{
println（s“休息…$pauseCount”）
线程睡眠（1000）
pauseCount+=1
如果（pauseCount>=10）{
isPause=false
pauseCount=0
println（s“正在休息…发生超时！”）
}
}
}
isRunning=false
println（s“计算已停止，请按Enter！”）
tInput.join（）
println（s“好的，谢谢你，再见！”）

我认为可以继续询问，所以即使它存在于其他地方。。。邮件列表格式不是最容易阅读的。@huynhjl确实，造成堆栈溢出的原因之一是搜索邮件列表很糟糕。@huynhjl，我同意。我们中的一些人（我）是通过谷歌找到这个答案的。@Daniel为什么会这样？@ÉbeIsaac您可以在这里查看

val input=readLine（“prompt>”）

参见Scaladoc。直接使用readLine（）是不推荐的。而是导入StdIn中的一个：import scala.io.StdIn.readLine；考虑添加一些解释。“不能解析符号读行”是否缺少某种类型的导入？

import scala.io.StdIn._

object q1 {
  def main(args:Array[String]):Unit={  
    println("Enter your name : ")
    val a = readLine()
    println("My name is : "+a)
  }
}

import java.util.Scanner;

object q1 {
  def main(args:Array[String]):Unit={ 
      val scanner = new Scanner(System.in)
    println("Enter your name : ")
    val a = scanner.nextLine()
    println("My name is : "+a)
  }
}

Using a thread to poll the input-readLine:

// keystop1.sc

// In Scala- or SBT console/Quick-REPL: :load keystop1.sc
// As Script: scala -savecompiled keystop1.sc

@volatile var isRunning = true
@volatile var isPause = false

val tInput: Thread = new Thread {
  override def run: Unit = {
    var status = ""
        while (isRunning) {
            this.synchronized {
                status = scala.io.StdIn.readLine()
                status match {
                    case "s" => isRunning = false
                    case "p" => isPause = true
                    case "r" => isRunning = true;isPause = false
                    case _ => isRunning = false;isPause = false
                }
                println(s"New status is: $status")
            }
        }
    }
}

tInput.start

var count = 0
var pauseCount = 0

while (isRunning && count < 10){
  println(s"still running long lasting job! $count")
  if (count % 3 == 0) println("(Please press [each + ENTER]: s to stop, p to pause, r to run again!)")
  count += 1
  Thread sleep(2000) // simulating heavy computation
  while (isPause){
      println(s"Taking a break ... $pauseCount")
      Thread sleep(1000)
      pauseCount += 1
      if (pauseCount >= 10){
        isPause = false
        pauseCount = 0
        println(s"Taking a break ... timeout occurred!")
      }
  }
}
isRunning = false
println(s"Computation stopped, please press Enter!")
tInput.join()
println(s"Ok, thank you, good bye!")