简洁的.跨平台.乐趣.

开始使用

JetBrains 和开源贡献者开发

多平台

根据您的条件并针对不同平台共享代码

服务器端

拥有熟悉 JVM 技术的现代开发经验

多平台库

创建一个跨多个平台运行的库

Android

Google 推荐用于构建 Android 应用程序

数据科学

简单的

异步

面向对象

Functional

非常适合测试

fun main() {
    val name = "stranger"        // Declare your first variable
    println("Hi, $name!")        // ...and use it!
    print("Current count:")
    for (i in 0..10) {           // Loop over a range from 0 to 10
        print(" $i")
    }
}

import kotlinx.coroutines.*

suspend fun main() {                                // A function that can be suspended and resumed later
    val start = System.currentTimeMillis()
    coroutineScope {                                // Create a scope for starting coroutines
        for (i in 1..10) {
            launch {                                // Start 10 concurrent tasks
                delay(3000L - i * 300)              // Pause their execution
                log(start, "Countdown: $i")
            }
        }
    }
    // Execution continues when all coroutines in the scope have finished
    log(start, "Liftoff!")
}

fun log(start: Long, msg: String) {
    println("$msg " +
            "(on ${Thread.currentThread().name}) " +
            "after ${(System.currentTimeMillis() - start)/1000F}s")
}

abstract class Person(val name: String) {
    abstract fun greet()
}

interface FoodConsumer {
    fun eat()
    fun pay(amount: Int) = println("Delicious! Here's $amount bucks!")
}

class RestaurantCustomer(name: String, val dish: String) : Person(name), FoodConsumer {
    fun order() = println("$dish, please!")
    override fun eat() = println("*Eats $dish*")
    override fun greet() = println("It's me, $name.")
}

fun main() {
    val sam = RestaurantCustomer("Sam", "Mixed salad")
    sam.greet() // An implementation of an abstract function
    sam.order() // A member function
    sam.eat()   // An implementation of an interface function
    sam.pay(10) // A default implementation in an interface
}

fun main() {
    // Who sent the most messages?
    val frequentSender = messages
        .groupBy(Message::sender)
        .maxByOrNull { (_, messages) -> messages.size }
        ?.key                                                 // Get their names
    println(frequentSender) // [Ma]

    // Who are the senders?
    val senders = messages
        .asSequence()                                         // Make operations lazy (for a long call chain)
        .filter { it.body.isNotBlank() && !it.isRead }        // Use lambdas...
        .map(Message::sender)                                 // ...or member references
        .distinct()
        .sorted()
        .toList()                                             // Convert sequence back to a list to get a result
    println(senders) // [Adam, Ma]
}

data class Message(                                           // Create a data class
    val sender: String,
    val body: String,
    val isRead: Boolean = false,                              // Provide a default value for the argument
)

val messages = listOf(                                        // Create a list
    Message("Ma", "Hey! Where are you?"),
    Message("Adam", "Everything going according to plan today?"),
    Message("Ma", "Please reply. I've lost you!"),
)

// Tests
// The following example works for JVM only
import org.junit.Test
import kotlin.test.*

class SampleTest {
    @Test
    fun `test sum`() {                  // Write test names with whitespaces in backticks
        val a = 1
        val b = 41
        assertEquals(42, sum(a, b), "Wrong result for sum($a, $b)")
    }

    @Test
    fun `test computation`() {
        assertTrue("Computation failed") {
            setup()                     // Use lambda returning the test subject
            compute()
        }
    }
}

// Sources
fun sum(a: Int, b: Int) = a + b
fun setup() {}
fun compute() = true

开始使用 ↗

Concise

Safe

Expressive

Asynchronous

Interoperable

// More than 30% fewer lines of code compared to Java
// (based on the experience of Duolingo and other companies)

data class Book (
    val title: String,                         // + automatically generated equals(),
    val year: Int                              // hashCode(), toString(), and copy()
)
fun century(year: Int) = (year - 1) / 100 + 1  // Top-level function,
                                               // single-expression body
fun main() {
    val books = listOf(                        // Construct a list
        Book("Don Quixote", 1605),             // No `new` keyword
        Book("The Lord of the Rings", 1955)
    )
    val classics = books.filter { century(it.year) < 20 } // Trailing single-argument lambda
    println("Classic books: $classics")                   // Calls toString() for Book
}

// Apps built with Kotlin are 20% less likely to crash
// (based on Google's internal data)

fun printMessagesUppercased(messages: List<String?>) { // List elements can be nulls
    // messages.add(Message("Java"))                   // ERROR: List is read-only
    messages.onEachIndexed { index, msg ->
        print("\nMessage #$index: ")
        // print(msg.uppercase())                      // ERROR: `msg` can be null
        msg?.let {                                     // Print only if `msg` is not null
            print(it.uppercase())                      // OK, `it` is String
        }
    }
}
fun main() {
    val messages = mutableListOf("hello", null, "world")
    // messages = mutableListOf("!!!")                 // ERROR: can't reassign a value
    messages.add("Kotlin")                             // OK: the list is mutable
    printMessagesUppercased(messages)                  // Pass the list as read-only
}

import kotlin.math.absoluteValue

fun main() {
//sampleStart
    val dates = listOf(1 to "January", 13 to "May", 22 to "September", 23 to "December")
    dates.forEach { (day, month) ->                 // Traverse a list of pairs with a trailing lambda
        println("${day.ordinal()} of $month")       // Use the Int.ordinal() extension function
    }
    createEmptyWindow()
        .apply {                                    // Configure properties of an object
            width = 300
            height = 200
            isVisible = true
        }.also { w ->                               // Perform an additional operation on a call chain
            showWindow(w)
        }
    issueById["13456"]
        ?.takeIf { it.status == Status.FIXED }      // Use the value only if the condition is true
        ?.let {                                     // Do something only if the value is not null
            println("We've fixed this: $it")
        }
//sampleEnd
}

// Extension function
fun Int.ordinal() = this.absoluteValue.let { iAbs ->
    val suffix = if (iAbs % 100 in 11..13) "th" else
        when (iAbs % 10) {
            1 -> "st"
            2 -> "nd"
            3 -> "rd"
            else -> "th"
        }
    "$this$suffix"
}
data class Window(var width: Int, var height: Int, var isVisible: Boolean)
fun createEmptyWindow() = Window(0, 0, false)
fun showWindow(window: Window) {
    println("Showing $window")
}
enum class Status { OPEN, FIXED, IN_PROGRESS }
data class Issue(val status: Status)
val issueById = mutableMapOf(
    "13456" to Issue(Status.FIXED)
)

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

//sampleStart
// More than 50% of professional developers who use coroutines
// report increased productivity
// (based on Google's internal data)

fun main() = runBlocking {
    val start = System.currentTimeMillis()
    coroutineScope {                                 // Create a scope for coroutines
        val waitingJob = launch {                    // Launching a coroutine
            waiting(start, 150)
        }
        countdownSignals(10, 300).collect { value -> // Collecting flow elements
            log(start, "Countdown: $value")
        }
        waitingJob.cancel()                          // Cancelling a coroutine
    }
    log(start, "Liftoff!")                           // Execution continues when all
}                                                    // coroutines have finished
//sampleEnd
fun countdownSignals(n: Int, delayMillis: Long): Flow<Int> = flow { // Flow builder
    for (i in (1..n).reversed()) {
        delay(delayMillis)                           // Delay in emitting signals
        emit(i)                                      // Emit the flow element
    }
}

// A function that can be suspended and resumed later
suspend fun waiting(start: Long, delayMillis: Long) {
    while (currentCoroutineContext().isActive) {     // Check coroutine's context
        log(start, "Waiting...")
        delay(delayMillis)                           // Waiting concurrently
    }
}

fun log(start: Long, msg: String) {
    println("$msg after ${(System.currentTimeMillis() - start)/1000F}s")
}

// Use any existing JVM library or framework
// Call Kotlin code from Java without an issue

@SpringBootApplication
class DemoApplication

fun main(args: Array<String>) {
    runApplication<DemoApplication>(*args)
}

@RestController
class MessageResource {
    @GetMapping
    fun index(): List<Message> = listOf(
        Message("1", "Hello!"),
        Message("2", "Bonjour!"),
        Message("3", "Privet!"),
    )
}

data class Message(val id: String?, val text: String)

开始使用 ↗