Kotlin: a better Java

Kotlin: a better Java Nils Breunese March 2016

Java • Proven technology • Stable • Good performance • Lots of libraries • Good tooling support • But...

No Semicolons // Java System.out.println("Hello world!); // Kotlin println("Hello world!")

No Primitives // Java int a = 1; short s = 2; boolean b; // Kotlin var a: Int = 1 var s: Short = 2 var b: Boolean

No 'new' // Java Boa boa = new Boa(); // Kotlin val boa = Boa()

No Checked Exceptions // Java code often looks like this StringBuilder sb = new StringBuilder(); try { sb.append(message); } catch (IOException ignored) { // Must be safe } // Kotlin has no checked exceptions

Type Declaration // Java Int a = 1; String b = "b"; Program p; // Kotlin var a: Int = 1 var b: String = "b" var p: Program

Type Inference // Java Int a = 1; String b = "b"; Program p; // Kotlin var a = 1 var b = "b" var p: Program

Immutable Values // Java final Int a = 1; final String b = "b"; final Program p; // Kotlin val a = 1 val b = "b" val p: Program

String Templates // Java String s = String.format("%s has %d apples", name, count); // Kotlin val s = "$name has $count apples"

Raw Strings // Java doesn't have raw strings String text = "n for (c in "foo"n print(c)n"; // Kotlin val text = """ for (c in "foo") print(c) """

Functions // Java String getName(Person person) { return person.getName(); } // Kotlin fun getName(person: Person): String { return person.name }

Expression Body // Java Int sum(Int a, Int b) { return a + b; } // Kotlin fun sum(a: Int, b: Int): Int { return a + b }

Expression Body // Java Int sum(Int a, Int b) { return a + b; } // Kotlin fun sum(a: Int, b: Int): Int { return a + b } fun sum(a: Int, b: Int) = a + b

Extension Functions // Kotlin fun String.spaceToCamelCase() { ... } "Convert to camelcase".spaceToCamelCase()

If Expression // Java Int max; if (a > b) { max = a } else { max = b }; // OK, Java has a ternary operator Int max = a > b ? a : b; // Kotlin's 'if' is an expression, // so it has a value val max = if (a > b) a else b

When Expression // Java has switch switch(x) { case 1: log.info("x == 1"); break; case 2: log.info("x == 2"); break; default: log.info("x is neither 1 nor 2"); } // Kotlin's when is cleaner and more powerful when (x) { 1 -> log.info("x == 1") 2 -> log.info("x == 2") else -> log.info("x is neither 1 nor 2") }

When Expression when (x) { in 0,1 -> print("x is too low") in 2..10 -> print("x is in range") !in 10..20 -> print("x outside range") parseInt(s) -> print("s encodes x") is Program -> print("It's a program!") else -> print("None of the above") }

Try Expression // In Java 'try' is not an expression Int a = null; try { a = parseInt(input); } catch (NumberFormatException ignored) {} // Kotlin val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

Nullable Types // Java types can be null Program program = null; ProgramType type = program.getType(); ==> NullPointerException when executed // Kotlin var program: Program = null ==> Compiler error, type not nullable var program: Program? = null val type = program?.type

Not Null Shorthand // Java Program p = mediaService.getProgram(123); String programTypeName = null; if (p != null && p.getType() != null) { programTypeName = p.getType().getName(); } // Kotlin val p = mediaService.getProgram(123) val typeName = p?.type?.name

Not Null Or Else // Java File[] files = new File("test").listFiles(); int count = files != null ? files.size : 0; // Kotlin val files = File("test").listFiles() val count = files?.size ?: 0

Ranges // Java IntStream.rangeClosed(1, 5) .forEach(x -> ...); // Kotlin for (x in 1..5) { ... }

Ranges // Kotlin if (x in 1..y-1) { ... } if (x !in 0..array.lastIndex) { ... }

Collections // Java for (String name : names) { ... } if (names.contains(text)) { ... } // Kotlin for (name in names) { ... } if (text in names) { ... }

Read-Only Collections // Kotlin encourages read-only collections listOf(1, 2, 3, 4) mapOf(1 to "A", 2 to "B") setOf("Hello", "World")

Collections // But it’s easy to create mutable // collections too arrayListOf("Hello", "World") linkedListOf("Hello", "World") hashMapOf(1 to "A", 2 to "B") linkedMapOf(1 to "A", 2 to "B") sortedMapOf(1 to "A", 2 to "B") sortedSetOf(1, 2, 3)

Maps // Java System.out.println(map.get("key")); map.put("key", value); for (Map.Entry<K, V> entry : map.entrySet()) { ... } // Kotlin println(map["key"]) map["key"] = value for ((k, v) in map) { ... }

Lambdas names.stream() .filter(n -> n.startWith("A")) .sorted((n1, n1) -> Integer.compare(n1.length(), n2.length())) .collect(Collectors.toList()); names .filter { n -> n.startsWith("A") } .sortedBy { n -> n.length } .map { n -> n.toUpperCase() }

Lambdas names.stream() .filter(n -> n.startWith("A")) .sorted((n1, n1) -> Integer.compare(n1.length(), n2.length())) .collect(Collectors.toList()); names .filter { it.startsWith("A") } .sortedBy { it.length } .map { it.toUpperCase() }

Classes // Java class Person { String firstName; Person(String firstName) { this.firstName = firstName; } } // Kotlin class with primary constructor class Person(firstName: String)

Classes // Java final class Unextendable { ... } // Kotlin classes are final by default class Unextendable { ... } // Declare as 'open' to allow extension open class Extendable { ... } // Abstract classes are automatically open abstract class Abstract { ... }

Sealed Classes // Kotlin sealed class restricts hierarchy sealed class Expr { class Const(val number: Double) : Expr() class Sum(val e1: Expr, val e2: Expr) : Expr() object NotANumber : Expr() } when(expr) { is Const -> expr.number is Sum -> eval(expr.e1) + eval(expr.e2) NotANumber -> Double.NaN // no 'else' }

DTO's // Java class Broadcaster { final String name; Broadcaster(String n) { name = n; } String getName() { return name; } void setName(String n) { name = n; } int equals() { ... } hashCode() { ... } toString() { ... } copy() { ... } }

DTO's // Kotlin data class Broadcaster(var name: String) // Using 'val' omits the setter data class Broadcaster(val name: String)

Default Arguments // Java doesn't have default arguments void foo(Int a, String b) { if (a == null) { a = 0; } if (b == null) { b = ""; } (...) } // Kotlin fun foo(a: Int = 0, b: String = "") { (...) }

Named Arguments // Kotlin fun reformat( str: String, normalizeCase: Boolean = true, upperCaseFirstLetter: Boolean = true, divideByCamelHumps: Boolean = false, wordSeparator: Char = ' ') { ... } reformat(str, wordSeparator = '_')

Smart Cast // Java Object obj = getObject(); if (obj instanceof String) { return ((String)obj).length() } // Kotlin val obj = getObject() if (obj is String) { return obj.length }

JavaScript Kotlin can also target JavaScript instead of the Java Virtual Machine

Etc., etc. Properties, better generics, delegation, operator overloading, tail recursion, infix functions, destructuring, type-safe builders, with, object expressions, object declarations, companion objects, extension properties, companion object extensions, vararg modifier, ...

Getting started • kotlinlang.org / try.kotlinlang.org • Kotlin Koans • Kotlin Educational Plugin (IDEA 2016.1) • Plugins for Maven and Gradle, Ant tasks (you can mix Java & Kotlin!) • Slack: kotlinslackin.herokuapp.com

Kotlin: a better Java

More Related Content

What's hot

Similar to Kotlin: a better Java

More from Nils Breunese

Recently uploaded

Kotlin: a better Java