Stand: 2017-03-25

Java-Kotlin-Spickzettel

Java und Kotlin mit Code-Beispielen im direkten Vergleich nebeneinander

Inhalt

Anwendung definieren

JavaKotlin
public class MyApplication {
    public static void main(String... args) {
        ...
    }
}
fun main(args: Array<String>) {
    ...
}

In Kotlin können Funktionen direkt auf Paketebene, also außerhalb einer Klasse oder eines Objekts, definiert werden. Deshalb ist für die main-Methode auch keine nutzlose Klasse erforderlich.

Text ausgeben

JavaKotlin
System.out.println("Hallo Welt!");
println("Hallo Welt!")

Variablen und Werte definieren

JavaKotlin
int x = 5;
var x: Int = 5
var x = 5
final int y = 1;
val y: Int = 1
val y = 1

Variablen in Strings

JavaKotlin
String message = 
        String.format("a: %s, x: %s", a, b.x);
        
String message = "a: " + a + "x: " + b.x;
val message = "a: $a, x: ${b.x}"

In Kotlin können Variablen mit vorangestelltem $ direkt in Strings eingebettet werden; komplexe Ausdrücke wie b.x benötigen zusätzlich geschweifte Klammern.

Dokumentation: String Templates

Collections

JavaKotlin
String[] array = { "a", "b", "c"};
val array = arrayOf("a", "b", "c")
final List<String> list = 
    Arrays.asList("a", "b", "c");
val list = mutableListOf("a", "b", "c")
String item = list.get(1);
val item = list[1]
list.set(0, "x");
list[0] = "x"
Set<String> set = new HashSet<>();
set.add("a");
set.add("b");
val set = mutableSetOf("a", "b")
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
val map = mutableMapOf("a" to 1, "b" to 2)
Integer a = map.get("a");
val a = map["a"]
map.put("a", 9);
map["a"] = 9
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
Map<String, Integer> unmodifiableMap = 
    Collections.unmodifiableMap(map);
val unmodifiableMap = mapOf("a" to 1, "b" to 2)

Dokumentation: Collections

Streams

JavaKotlin
list.stream()
    .filter(it -> it.length() == 1)
    .map(String::toUpperCase)
    .collect(Collectors.toSet());
list
    .filter { it.length == 1 }
    .map(String::toUpperCase)
list.stream()
    .collect(Collectors.joining(", "));
list.joinToString(", ")
positions.stream()
    .mapToInt(Position::price)
    .sum();
list.sumBy { it.price }

Weitere Beispiele bei Stackoverflow.com

Bedingungen mit if

JavaKotlin
final String filename;
if (!args.isEmpty())
    filename = args.get(0);
else
    filename = "default.txt"
val filename = 
    if (!args.isEmpty) args[0] 
    else "default.txt"
String a = x < 1 ? "red" : "green";
val a = if (x < 1) "red" else "green"

Dokumentation: if

for-Schleife

JavaKotlin
for (MyItem item : collection) { ... }
for (item in collection) { ... }
for (int i = 0; i < array.size; i++) {
    System.out.println(array[i]);
}
for (i in array.indices) {
    println(array[i])
}
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}
for (i in 1..10) {
    println(i)
}

Dokumentation: for

Schlüssel-Wert-Paare einer Map durchlaufen

JavaKotlin
for (Map.Entry<K,V> entry : map.entrySet()) {
  K key = entry.getKey();
  V value = entry.getValue();
  ...
}
for ((key, value) in map) {
   ... 
}

// oder
map.forEach { (key, value) -> ... }

Durch sogenannte “desctructuring declarations”, kann in Kotlin ein Map-Eintrag in Schlüssel und Wert zerlegt werden.

switch und when

JavaKotlin
  final Color color;
  switch (value) {
    case 0:
      color = Color.RED;
      break;
    case 1:
    case 2:
      color = Color.YELLOW;
      break;
    case 3:
      color = Color.GREEN;
      break;
    default:
    color = Color.GREY;
  }
val color = when(value) {
    0 -> Color.RED
    1, 2 -> Color.YELLOW
    3 -> Color.GREEN
    else -> Color.GREY
}

Dokumentation: when

Gleichheit

JavaKotlin
a.equals(b);
a == b
a == b;
a === b

Dokumentation: Equality

Methoden und Funktionen

JavaKotlin
public int calculate(final int a, final int b) {
    return a + b;
}
fun calculate(a: Int, b: Int) = a + b

fun calculate(a: Int, b: Int): Int {
    return a + b
}
public void show(final String a) {
    System.out.println(a);
}
fun show(a: String) {
    println(a)
}

fun show(a: String): Unit {
    println(a)
}
public void perform(String... args) { 
    ... 
}
fun perform(vararg args: String) {
    ...
}

Dokumentation: Functions

Lambdaausdrücke

JavaKotlin
IntToDoubleFunction square = 
      (int a) -> a * a;
val square =  { a: Int -> a * a }

val square: (Int) -> Int =  { a: Int -> a * a }
Consumer<String> printer = 
      (String a) -> System.out.println(a);
val printer = { a: String -> println(a) }

val printer: (String) -> Unit = 
    { a: String -> println(a) }
Consumer<String> printerWithMethodRef = 
      System.out::println;
val printerWithMethodRef = ::println

val printerWithMethodRef: (String) -> 
      Unit = ::println
Runnable writer = () -> {
    System.out.println("start");
    System.out.println("end");
};
val writer: () -> Unit = {
    println("start")
    println("end")
}
public static void perform(
        IntToDoubleFunction square,
        Consumer printer,
        Runnable writer) {
    square.applyAsDouble(3);
    printer.accept("hi");
    writer.run();
}
fun perform(
        square: (Int) -> Int,
        printer: (String) -> Unit,
        writer: () -> Unit) {
    square(3)
    printer("hi")
    writer()
}

Dokumentation: Lambdas

Exception Handling

JavaKotlin
try {
    ...
} 
catch (SomeExcetion e) {
    ...        
}
finally {
    ...
}
try {
    ...
} 
catch (e: SomeExcetion) {
    ...        
}
finally {
    ...
}
final String a;
try {
    Path path = Paths.get("test.txt");
    a = Files.readAllLines(path).get(0);
} catch (final IOException e) {
    a = "default";
}
val a = try {
    val path = Paths.get("test.txt")
    Files.readAllLines(path)[0]
} catch (e: IOException) {
    "default"
}

Dokumentation: Exceptions

Sichtbarkeit

Dokumentation: Visibility Modifiers

Klassen

Deklaration und Vererbung

JavaKotlin
final class Square {}
class Square
class Square {}
open class Square
public class Square extends Shape {}
class Square : Shape()
public class Square implements Drawable
class Square : Drawable
public class Square extends Shape
        implements Drawable
class Square : Shape(), Drawable

Dokumentation: Classes and Inheritance

Konstruktoren

JavaKotlin
public class Square {

    private final int length;
    private final int area;

    public Square(int length) {
        checkArgument(length > 0);
        this.length = length;
        this.area = length * length;
    }

    public int getLength() {
        return length;
    }

    public int getArea() {
        return area;
    }
}
class Square(val length: Int) {

    init {
        require(length > 0)
    }

    val area = length * length
}
JavaKotlin
public class Square extends Shape 
    implements Drawable {

    private int length;
    private int area;

    public Square(int length) {
        checkArgument(length > 0);
        this.length = length;
        this.area = length * length;
    }

    public Square() {
        this(1);
    }

    public Square(Square blueprint) {
        this(blueprint.length);
    }

    public int getLength() {
        return length;
    }

    public int getArea() {
        return area;
    }
}
class Square(val length: Int) : 
        Drawable, Shape() {

    val area = length * length

    constructor() : this(1)

    constructor(blueprint: Square) : 
        this(blueprint.length)

    init {
        require(length >= 0)
    }
}
JavaKotlin
public class Square extends Shape {
    public Square(int length, Color color) {
        super(color);
    }
}
class Square(val length: Int, color: Color) : 
        Shape(color)
JavaKotlin
    class Service {
        private final Repository repository;

        @Inject
        public Service(Repository repository) {
            this.repository = repository;
        }
    }
class Service @Inject constructor(
    val repository: Repository)

Instantiierung

JavaKotlin
Square s = new Square(2);
val s = Square(2)

Objekte werden in Kotlin ohne das Schlüsselwort new erzeugt.

Getter/Setter und Properties

JavaKotlin
private String name = "nobody";

public void setName(final String name) {
    this.name = name;
}

public String getName() {
    return name;
}
var name = "nobody"
private String name = "nobody";

public String getName() {
    return name;
}
val name = "nobody"
public boolean isEmpy() {
    return size == 0;
}
val isEmpty: Boolean
    get() = size == 0
public void setLength(int length) {
    if (length < 0)
        length = 0;
    else 
        this.length = length;
}

public int getLength() {
    if (length > MAX)
        return MAX;
    return length;
}
var length: Int
    get() = if (length > MAX) MAX else length
    set(value) {
        if (value < 0)
          field = 0
        else
          field = value
    }

Dokumentation: Properties

Statische Elemente

JavaKotlin
public class Rectangle {
    ...
    public static Rectangle createSquare(int l) {
        return new Rectangle(l, l);
    }
}
class Rectangle(
         val width: Int, val height: Int) {
    companion object {
        fun createSquare(l: Int) = 
            Rectangle(l, l)
    }
}
public class Math {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}
fun max(a: Int, b: Int) = 
    if (a > b) a else b

Dokumentation: Companion Objects

Datenklassen

JavaKotlin
public final class Point {

    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
      return x;
    }

    public int getY() {
      return y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) 
            return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}
data class Point(val x: Int, val y: Int)

Dokumentation: Data Classes

Enums

JavaKotlin
public enum Color {
    RED, YELLOW, GREEN
}
enum class Color {
    RED, YELLOW, GREEN
}
public enum Color {

    RED(255, 0, 0),
    YELLOW(255, 255, 0),
    GREEN(0, 255, 0);

    public final int r;
    public final int g;
    public final int b;

    Color(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }
}
enum class Color(
        val r: Int, val g: Int, val b: Int) {
          
    RED(255, 0, 0),
    YELLOW(255, 255, 0),
    GREEN(0, 255, 0)
}

Dokumentation: Enum Classes

Annotationen

JavaKotlin
@Target(ElementType.TYPE)
@interface MyAnnotation {
    String value() default "";
    boolean enabled() default false;
}
@Target(AnnotationTarget.CLASS)
annotation class MyAnnoation(
        val value: String = "",
        val enabled: Boolean = false)
@MyAnnotation(value = "ok", enabled = true)
class Something { }
@MyAnnoation(value = "ok", enabled = true)
class Something

Dokumentation: Annotations

Schnittstellen

JavaKotlin
import static java.util.Arrays.stream;

public interface Something {

    boolean canDo(String task);

    void doIt(String task);

    default void doForeach(
            final String ...tasks) {
        stream(tasks).forEach(this::doIt);
    }
}
interface Something {

    fun canDo(task: String): Boolean

    fun doIt(task: String): Unit

    fun doForeach(vararg tasks: String) {
        tasks.forEach { doIt(it) }
    }
}
class SomethingConcrete implements Something {

    @Override
    public boolean canDo(String task) {
        ...
    }

    @Override
    public void doIt(String task) {
        ...
    }
}
class SomethingConcreteKt : SomethingKt {

    override fun canDo(task: String): Boolean {
        ...
    }

    override fun doIt(task: String) {
        ...
    }
}

Dokumentation: Interfaces

Delegation

JavaKotlin
public class Something implements SomeInterface {

    private final SomeInterface part;

    public Something(SomeInterface part) {
        this part = part;
    }

    public void show(String a) {
        part.show(a);
    }
}
class Something(part: SomeInterface) : 
    SomeInterface by part

In Kotlin sorgt das Schlüsselwort by gefolgt von einer Referenz auf das Objekt, an das delegiert wird, dafür dass die nötigen Methoden erzeugt werden. Damit gibt es in Kotlin endlich eine komfortable Möglichkeit, um das Prinzip “composition over inheritance” umzusetzen.

Dokumentation: Delegation

Import

JavaKotlin
import java.nio.file.Paths;
import java.nio.file.Paths
import static java.util.Collections.max;
import java.util.Collections.max

Dokumentation: Packages

Typprüfung

JavaKotlin
a instanceof B
a is B

Dokumentation: is and !is Operartors

Typumwandlung (Cast)

JavaKotlin
B b = (B) a;
val b: B = a as B
final B b;
try {
    b = (B) a;
} catch (ClassCastException e) {
    // b bleibt null
}
val b: B? = a as? B

Dokumentation: Type Checks and Casts

null

JavaKotlin
public String a = null;
var a: String? = null
a.length();
a!!.length
int len = 0;
if (a != null)
    len =  a.length();
val len = if (a != null) a.length else 0

// oder
val len = a?.length ?: 0

Dokumentation: Null Safety

Java automatisch in Kotlin konvertieren

IntelliJ IDEA kann Java auch automatisch in Kotlin konvertieren. Dazu kannst du im Menü “Code” den Eintrag “Konvert Java File to Kotlin File” auswählen.

Java automatisch in Kotlin konvertieren mit IntelliJ IDEA

In der Online-IDE, try.kotlinlang.org, gibt es am oberen Rand die Funktionalität “Convert from Java”, mit der sich mal schnell ein Code-Schnipsel übersetzen lässt.

Java online in Kotlin konvertieren auf try.kotlinlang.org

In jedem Fall sollte man aber noch mal einen kritischen Blick auf das Ergebnis werfen, denn bei sehr kompliziertem Code kann es auch schon mal zu kleinen Unstimmigkeiten kommen. Und manchmal kann man den erzeugten Kotlin-Code auch noch weiter vereinfachen.

Weitere Informationen