我正在尝试接受来自 Kotlin 控制台的输入，但这很困难，因为我对语法不太确定。
我从主要开始
fun main(args: Array<String>) {
}
之后我应该输入什么？我知道println() 和readline() 参与其中，但我不知道如何构建它们。
目的：提示用户输入一个数字，输入的数字乘以6，程序将结果返回到控制台显示。
【问题讨论】：
标签： input console stdin kotlin
以下是 Kotlin 中从标准输入读取的 A+B 示例：
fun main() {
val (a, b) = readLine()!!.split(' ')
println(a.toInt() + b.toInt())
}
或
fun main(vararg args: String) {
val (a, b) = readLine()!!.split(' ').map(String::toInt)
println(a + b)
}
或
fun readInts() = readLine()!!.split(' ').map { it.toInt() }
fun main(vararg args: String) {
val (a, b) = readInts()
println(a + b)
}
或
import java.util.Scanner
fun main() {
val input = Scanner(System.`in`)
val a = input.nextInt()
val b = input.nextInt()
println(a + b)
}
或
with(Scanner(System.`in`)) {
val a = nextInt()
val b = nextInt()
println(a + b)
}
竞争性编程
必读简介：https://kotlinlang.org/docs/tutorials/competitive-programming.html
必看 Kotlin 生产力视频：https://www.jetbrains.com/icpc/
这是一个（受文章启发）扩展的一组辅助函数，用于读取所有可能的类型、列表、数组、二维数组等：
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)
注意Scanner 是somewhat slow。这在某些情况下可能很重要，例如竞争性编程，只需将Scanner 替换为普通的readLine，就可以使程序在大输入上的执行速度提高两倍。甚至我的次优readString() 实现通过序列进行标记化是slightly faster。与 Kotlin 的内置 readLine() 不同，它允许读取输入标记直到任何下一个空格。
我hope 总有一天会在 Kotlin 标准库中引入简洁、跨平台、高性能、通用的控制台和文件输入解析支持。像readInt、readLong 等全局和Reader 扩展函数。
这不仅对于竞争性编程非常有用，而且对于将 Kotlin 作为第一语言学习也是非常有用的。
阅读数字的概念不需要首先解释集合、lambda 和 monad。
奖金
有时您从控制台输入/输出开始，但随后需要切换到文件。 在每次读取或写入调用之前添加文件流变量变得太乏味了。
这是 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)
}
}
当需要切换回控制台时，可以快速注释掉换行。
【讨论】：
Scanner 是最好的
System.`in`.bufferedReader().readLine()!! 是最快的。我有多个测试用例失败，因为 std-lib 的 readLine()!! 很慢。
使用 readLine() 从用户那里获取输入， ATQ：
fun main(args:Array<String>){
print("Enter a number")
var variableName:Int = readLine()!!.toInt() // readLine() is used to accept the String value and ".toInt()" will convert the string to Int.
var result:Int= variableName*6
print("The output is:$result")
}
【讨论】：
有多种方法可以使用 Kotlin 处理控制台 I/O。
1.使用 Kotlin 标准库：Kotlin 标准库为我们提供了基于 JDK 类处理 I/O 的扩展。
要在控制台中打印，我们可以使用print 函数。如果我们运行以下 sn-p：
print("Hello from Kotlin")
我们将在终端上看到以下消息：
Hello from 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()
请注意，我们使用反引号对 in 属性进行转义，因为它是 Kotlin 中的关键字。
2.2.使用 BufferedReader 类：要使用BufferedReader 类从标准输入流中读取，我们首先需要使用System.in 进行实例化：
val reader = BufferedReader(InputStreamReader(System.`in`))
然后我们可以使用它的方法——例如，readLine()：
val readText = reader.readLine()
2.3.使用控制台类：与前两个类不同，Console 类具有处理控制台 I/O 的额外方法，例如 readPassword 和 printf。
为了使用Console 类，我们需要从System 类中获取实例：
val console = System.console()
val readText = console.readLine()
此外，由于 Kotlin 与 Java 的互操作性，我们可以使用额外的 Java 库来处理 I/O。
在您的情况下，在读取输入后，您可以使用 toInt() 函数将 String 值转换为 Int。
【讨论】：
fun readInts(separator: Char = ' ') =
readLine()!!.split(separator).map(String::toInt)
fun main(args: Array<String>) {
var A : List<Int> = 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<String>) {
val sc = Scanner(System.`in`)
val num1 = sc.nextInt()
val num2 = sc.nextInt()
val sum = solveMeFirst(num1, num2)
println(sum)
}
【讨论】：
只需创建一个扫描功能
fun scan():String{
var str ="";
while ( str==""){
str = readLine().toString()
}
return str;
}
使用喜欢
fun main() {
println("Enter number 1")
val a = scan().toInt()
println("Enter number 2")
val b = scan().toInt()
println(a + b);
}
【讨论】：
您可以使用readLine()。
fun main(args: Array<String>) {
println("What's your name?")
val inputText = readLine()
println(“Your name is " + inputText)
}
【讨论】：