Input 在Kotlin中读取控制台输入

我试图在Kotlin中接受来自控制台的输入，但这很困难，因为我对语法不太确定

我从主线开始

fun main(args: Array<String>) {

}

fun main（args:Array）{
}

在这之后我应该进入什么？我知道涉及到

println（）

和

readline（）

，但我不知道如何构造它们

---

目标：提示用户输入数字，输入的数字乘以6，程序将结果返回控制台显示屏

以下是从stdin读取的Kotlin中的A+B示例：

fun main() {
  val (a, b) = readLine()!!.split(' ')
  println(a.toInt() + b.toInt())
}

或

或

或

或

---

竞争性节目

必须阅读简介：

必须观看Kotlin生产力视频：

以下是一组扩展的帮助函数（受本文启发），用于读取所有可能的类型、列表、数组、2d数组等：

private fun readln() = readLine()!!
private fun readlnByte() = readln().toByte()
private fun readlnShort() = readln().toShort()
private fun readlnInt() = readln().toInt()
private fun readlnLong() = readln().toLong()
private fun readlnFloat() = readln().toFloat()
private fun readlnDouble() = readln().toDouble()
private fun readlnBigInt(radix: Int = 10) = readln().toBigInteger(radix)
private fun readlnBigDecimal() = readln().toBigDecimal()

private fun lineSequence(limit: Int = Int.MAX_VALUE) = generateSequence { readLine() }.constrainOnce().take(limit)
private fun readlnStrings() = readln().split(' ')
private fun readlnBytes() = readlnStrings().map { it.toByte() }
private fun readlnShorts() = readlnStrings().map { it.toShort() }
private fun readlnInts() = readlnStrings().map { it.toInt() }
private fun readlnLongs() = readlnStrings().map { it.toLong() }
private fun readlnFloats() = readlnStrings().map { it.toFloat() }
private fun readlnDoubles() = readlnStrings().map { it.toDouble() }

private fun readByteArray() = readlnStrings().run { ByteArray(size) { get(it).toByte() } }
private fun readShortArray() = readlnStrings().run { ShortArray(size) { get(it).toShort() } }
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }
private fun readLongArray() = readlnStrings().run { LongArray(size) { get(it).toLong() } }
private fun readFloatArray() = readlnStrings().run { FloatArray(size) { get(it).toFloat() } }
private fun readDoubleArray() = readlnStrings().run { DoubleArray(size) { get(it).toDouble() } }

private fun readlnByteArray(n: Int) = ByteArray(n) { readlnByte() }
private fun readlnShortArray(n: Int) = ShortArray(n) { readlnShort() }
private fun readlnIntArray(n: Int) = IntArray(n) { readlnInt() }
private fun readlnLongArray(n: Int) = LongArray(n) { readlnLong() }
private fun readlnFloatArray(n: Int) = FloatArray(n) { readlnFloat() }
private fun readlnDoubleArray(n: Int) = DoubleArray(n) { readlnDouble() }

private fun readByteArray2d(rows: Int, cols: Int) = Array(rows) { readByteArray().also { require(it.size == cols) } }
private fun readShortArray2d(rows: Int, cols: Int) = Array(rows) { readShortArray().also { require(it.size == cols) } }
private fun readLongArray2d(rows: Int, cols: Int) = Array(rows) { readLongArray().also { require(it.size == cols) } }
private fun readIntArray2d(rows: Int, cols: Int) = Array(rows) { readIntArray().also { require(it.size == cols) } }
private fun readFloatArray2d(rows: Int, cols: Int) = Array(rows) { readFloatArray().also { require(it.size == cols) } }
private fun readDoubleArray2d(rows: Int, cols: Int) = Array(rows) { readDoubleArray().also { require(it.size == cols) } }

private fun isWhiteSpace(c: Char) = c in " \r\n\t"

// JVM-only targeting code follows next

// readString() via sequence is still slightly faster than Scanner
private fun readString() = generateSequence { System.`in`.read().toChar() }
        .dropWhile { isWhiteSpace(it) }.takeWhile { !isWhiteSpace(it) }.joinToString("")
private fun readByte() = readString().toByte()
private fun readShort() = readString().toShort()
private fun readInt() = readString().toInt()
private fun readLong() = readString().toLong()
private fun readFloat() = readString().toFloat()
private fun readDouble() = readString().toDouble()
private fun readBigInt(radix: Int = 10) = readString().toBigInteger(radix)
private fun readBigDecimal() = readString().toBigDecimal()

private fun readBytes(n: Int) = generateSequence { readByte() }.take(n)
private fun readShorts(n: Int) = generateSequence { readShort() }.take(n)
private fun readInts(n: Int) = generateSequence { readInt() }.take(n)
private fun readLongs(n: Int) = generateSequence { readLong() }.take(n)
private fun readFloats(n: Int) = generateSequence { readFloat() }.take(n)
private fun readDoubles(n: Int) = generateSequence { readDouble() }.take(n)

注意这一点。这在某些情况下可能很重要，比如竞争性编程，在这种情况下，程序在大输入上的执行速度可以提高两倍，只需将其替换为平原即可。甚至我的次优的

readString（）

实现通过序列进行标记化也是如此。与Kotlin内置的

readLine（）

有一天，Kotlin stdlib中会引入一种简洁、跨平台、高性能、通用的控制台和文件输入解析支持。像
readInt
，
readLong
等全局和
Reader
扩展功能。
这不仅对竞争性编程非常有用，而且对学习Kotlin作为第一语言也非常有用。
阅读数字的概念不需要首先解释集合、lambda和monad


奖金

有时您从控制台输入/输出开始，但需要切换到文件。
用file stream变量在每个读或写调用前加上前缀会变得太繁琐

这是Kotlin的一个和平魔法，它允许只使用几行代码包装未更改的控制台代码，强制它读写文件，同时确保它们正确关闭：

fun <T : Closeable, R> T.useWith(block: T.() -> R): R = use { with(it, block) }

File("a.in").bufferedReader().useWith {
    File("a.out").printWriter().useWith {
        val (a, b) = readLine()!!.split(' ').map(String::toInt)
        println(a + b)
    }
}

Scanner(File("b.in")).useWith {
    PrintWriter("b.out").useWith {
        val a = nextInt()
        val b = nextInt()
        println(a + b)
    }
}

funt T.useWith（block:T.（）->R）：R=use{with（it，block）}
文件（“a.in”）.bufferedReader（）.useWith{
文件（“a.out”）.printWriter（）.useWith{
val（a，b）=readLine（）！！.split（“”）.map（String:：toInt）
println（a+b）
}
}
扫描仪（文件（“b.in”）。用于{
PrintWriter（“b.out”）。用于{
val a=nextInt（）
val b=nextInt（）
println（a+b）
}
}

当需要切换回控制台时，包装行可以快速注释掉。
使用readLine（）从用户处获取输入，
ATQ:

fun main（args:Array）{
打印（“输入数字”）
var variableName:Int=readLine（）！！.toInt（）//readLine（）用于接受字符串值，.toInt（）将字符串转换为Int。
变量结果：Int=variableName*6
打印（“输出为：$result”）
}
fun readInts（分隔符：Char=''）=
readLine（）！！。拆分（分隔符）.map（字符串：：toInt）
趣味主线（args:Array）{
变量A:List=readInts（）
}
默认情况下，readLine将输入作为字符串
toInt可用于将其转换为整数

fun main(args:Array<String>){
    var first: Int
    var second: Int
    println("Enter the first number")
    first = readLine()!!.toInt()
    println("Enter the second number")
    second= readLine()!!.toInt()
    println("The sum is ${first + second}")
}

fun main（args:Array）{
var-first:Int
第二个变量：Int
println（“输入第一个数字”）
first=readLine（）！！.toInt（）
println（“输入第二个数字”）
第二个=readLine（）！！.toInt（）
println（“总和为${first+second}”）
}
使用Kotlin处理控制台I/O有多种选择

1。使用Kotlin标准库：Kotlin标准库为我们提供了基于JDK类处理I/O的扩展

要在控制台中打印，我们可以使用
print
功能。如果我们运行以下代码段：

print("Hello from Kotlin")

我们将在终端上看到以下消息：

你好，来自Kotlin

在幕后，此函数使用Java
System.out.print
方法。此外，库还为我们提供了
println
替代函数，它在消息末尾添加了行分隔符

为了从控制台读取，我们可以使用
readLine
功能：

val inputText = readLine()

2。使用Java标准库：Kotlin与Java具有良好的互操作性。因此，如果需要，我们可以在程序中使用JDK中的标准I/O类

2.1。使用Scanner类：使用
Scanner
类非常简单；我们只需要创建一个实例并使用
nextLine
方法：

val scanner = Scanner(System.`in`)

val readText = scanner.nextLine()

请注意，我们使用backticks转义in属性，因为它是Kotlin中的一个关键字

2.2。使用BufferedReader类：要使用
BufferedReader
类读取标准输入流，我们首先需要使用
系统进行实例化。在
中：

val reader = BufferedReader(InputStreamReader(System.`in`))

然后我们可以使用它的方法-例如，
readLine（）
：

2.3。使用Console类：与前两个类不同，
Console
类具有处理控制台I/O的附加方法，如
readPassword
和
printf

为了使用
控制台
类，我们需要从
系统
类获取实例：

val console = System.console()

val readText = console.readLine()

另外，由于Kotlin与Java的互操作性，我们可以使用额外的Java库来处理I/O

在您的情况下，在阅读输入后，您可以使用
toInt（）
函数将
String
值转换为
Int
。
谢谢。可以给我这些的链接吗？@siur，
扫描仪是最好的one@SimpleFellow，我用这个稍微弱一点的问题来分享几个简单的方法，这些方法有额外的知识，比单个提问者更适合于更广泛的受众。我想这就是所谓的一切。我在这里看到了很多流行的非常详细的
fun main(args:Array<String>){
    var first: Int
    var second: Int
    println("Enter the first number")
    first = readLine()!!.toInt()
    println("Enter the second number")
    second= readLine()!!.toInt()
    println("The sum is ${first + second}")
}

print("Hello from Kotlin")

val inputText = readLine()

val scanner = Scanner(System.`in`)

val readText = scanner.nextLine()

val reader = BufferedReader(InputStreamReader(System.`in`))

val readText = reader.readLine()

val console = System.console()

val readText = console.readLine()