examples added

Author: adam-arold

build.gradle

@@ -1,14 +1,12 @@
 buildscript {
     ext {
-        kotlinVersion = '1.1.1'
+        kotlinVersion = '1.1.3-2'
     }
     repositories {
         mavenCentral()
     }
     dependencies {
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
-        classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
-        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
     }
 }
 
@@ -22,4 +20,4 @@ repositories {
 
 dependencies {
     compile("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")
-}
+}

gradle.properties

@@ -1,3 +1,2 @@
-version=0.0.1-SNAPSHOT
-group=org.codetome.examples.javatokotlin
-kotlin.incremental=true
+version=1.0.0
+group=org.codetome.kotlin.examples

src/main/java/org/codetome/kotlin/examples/data/HexagonValueObject.java

@@ -0,0 +1,56 @@
+package org.codetome.kotlin.examples.data;
+
+import java.util.Objects;
+
+
+/**
+ * A plain old java object with all the boilerplate.
+ */
+public class HexagonValueObject {
+
+    private final int x;
+    private final int y;
+    private final int z;
+
+    public HexagonValueObject(int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public int getZ() {
+        return z;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        HexagonValueObject hexagon = (HexagonValueObject) o;
+        return getX() == hexagon.getX() &&
+                getY() == hexagon.getY() &&
+                getZ() == hexagon.getZ();
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getX(), getY(), getZ());
+    }
+
+    @Override
+    public String toString() {
+        return "HexagonValueObject{" +
+                "x=" + x +
+                ", y=" + y +
+                ", z=" + z +
+                '}';
+    }
+}

src/main/java/org/codetome/kotlin/examples/exceptions/JavaLineLoader.java

@@ -0,0 +1,26 @@
+package org.codetome.kotlin.examples.exceptions;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Old school IO in java. Note the try with resources block!
+ */
+public class JavaLineLoader {
+
+    public List<String> loadLines(String path) {
+        List<String> lines  = new ArrayList<>();
+        try(BufferedReader br = new BufferedReader(new FileReader(path))) {
+            String line;
+            while((line = br.readLine()) != null) {
+                lines.add(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return lines;
+    }
+}

src/main/java/org/codetome/kotlin/examples/extensions/ListPresenterDecorator.java

@@ -0,0 +1,38 @@
+package org.codetome.kotlin.examples.extensions;
+
+import java.util.AbstractList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Writing decorators in java is cumbersome and they are not perfect.
+ * In this case you can't implement `List` because it would need you to
+ * implement a lot of other methods so you have to extend `AbstractList`.
+ *
+ * If you need to decorate something which does not provide useful base
+ * classes like `AbstractList` or is a `final` class you are out of luck.
+ */
+public class ListPresenterDecorator<T> extends AbstractList<T> {
+
+    private List<T> list;
+
+    public ListPresenterDecorator(List<T> list) {
+        this.list = list;
+    }
+
+    public String present() {
+        return list.stream()
+                .map(Object::toString)
+                .collect(Collectors.joining(", "));
+    }
+
+    @Override
+    public T get(int index) {
+        return list.get(index);
+    }
+
+    @Override
+    public int size() {
+        return list.size();
+    }
+}

src/main/java/org/codetome/kotlin/examples/fp/JavaUser.java

@@ -0,0 +1,36 @@
+package org.codetome.kotlin.examples.fp;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class JavaUser {
+
+    static class Address {
+        String city;
+
+        public String getCity() {
+            return city;
+        }
+    }
+
+    private final String firstName;
+    private final String lastName;
+    private final List<Address> addresses;
+
+    public JavaUser(String firstName, String lastName, List<Address> addresses) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.addresses = addresses;
+    }
+
+    /**
+     * Using the Stream API data transformation is rather easy.
+     */
+    public static Set<String> fetchCitiesOfUsers(List<JavaUser> users) {
+        return users.stream()
+                .flatMap(user -> user.addresses.stream())
+                .map(JavaUser.Address::getCity)
+                .collect(Collectors.toSet());
+    }
+}

src/main/java/org/codetome/kotlin/examples/inference/JavaUser.java

@@ -0,0 +1,25 @@
+package org.codetome.kotlin.examples.inference;
+
+import java.util.List;
+
+public class JavaUser {
+
+    static class Address {
+        String city;
+    }
+
+    private final String firstName;
+    private final String lastName;
+    private final List<Address> addresses;
+
+    public JavaUser(String firstName, String lastName, List<Address> addresses) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.addresses = addresses;
+    }
+
+    public Address getFirstAddress() {
+        Address firstAddress = addresses.get(0);
+        return firstAddress;
+    }
+}

src/main/java/org/codetome/kotlin/examples/interop/KotlinInterop.java

@@ -0,0 +1,12 @@
+package org.codetome.kotlin.examples.interop;
+
+public class KotlinInterop {
+
+    public void helloJava() {
+        System.out.println("Hello from Java!");
+    }
+
+    public void helloKotlin() {
+        JavaInterop.createInstance().helloKotlin();
+    }
+}

src/main/java/org/codetome/kotlin/examples/lambdas/JavaFilterOperation.java

@@ -0,0 +1,35 @@
+package org.codetome.kotlin.examples.lambdas;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class JavaFilterOperation {
+
+    private List<String> items;
+
+    /**
+     * Since there is no syntax for method parameter types
+     * we have to create an interface for it.
+     */
+    @FunctionalInterface
+    interface FilterOperation {
+        Boolean filter(String element);
+    }
+
+    /**
+     * The method which takes a function looks like this.
+     * Note that we could use `Function<String, Boolean>` here but
+     * it only works for functions with one parameter!
+     */
+    private List<String> filterBy(FilterOperation fn) {
+        return items.stream()
+                .filter(fn::filter) // applying the function
+                .collect(Collectors.toList());
+    }
+
+    public void doFilter() {
+        filterBy((element) -> {
+            return element.length() > 0; // calling the function with an actual lambda
+        });
+    }
+}

src/main/java/org/codetome/kotlin/examples/nullsafety/JavaUser.java

@@ -0,0 +1,37 @@
+package org.codetome.kotlin.examples.nullsafety;
+
+import java.util.List;
+
+/**
+ * Checking for `null` values involves a lot of boolean expressions and
+ * a lot of boilerplate.
+ * You can work around this with the `Optional` class but what if the
+ * reference to an `Optional` is `null`?
+ */
+public class JavaUser {
+
+    static class Address {
+        String city;
+    }
+
+    private final String firstName;
+    private final String lastName;
+    private final List<Address> addresses;
+
+    public JavaUser(String firstName, String lastName, List<Address> addresses) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.addresses = addresses;
+    }
+
+    public static String getFirstCity(JavaUser user) {
+        if(user != null && user.addresses != null && !user.addresses.isEmpty()) {
+            for(Address address : user.addresses) {
+                if(address.city != null) {
+                    return address.city;
+                }
+            }
+        }
+        throw new IllegalArgumentException("This User has no cities!");
+    }
+}

src/main/java/org/codetome/kotlin/examples/strings/JavaUser.java

@@ -0,0 +1,27 @@
+package org.codetome.kotlin.examples.strings;
+
+/**
+ * String manipulation in java is painful.
+ * It can be alleviated by using `String.format` but
+ * it will still remain painful.
+ */
+public class JavaUser {
+    private final String name;
+    private final int age;
+
+    public JavaUser(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String toHumanReadableFormat() {
+        return "JavaUser{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                '}';
+    }
+
+    public String toHumanReadableFormatWithStringFormat() {
+        return String.format("JavaUser{name='%s', age=%s}", name, age);
+    }
+}

src/main/kotlin/org/codetome/kotlin/examples/data/HexagonDataClass.kt

@@ -0,0 +1,10 @@
+package org.codetome.kotlin.examples.data
+
+/**
+ * Data classes in Kotlin give you
+ * - equals + hashCode and
+ * - toString in addition to
+ * - getters and setters.
+ * You can also `copy` them.
+ */
+data class HexagonDataClass(val x: Int, val y: Int, val z: Int)

src/main/kotlin/org/codetome/kotlin/examples/exceptions/KotlinLineLoader.kt

@@ -0,0 +1,13 @@
+package org.codetome.kotlin.examples.exceptions
+
+import java.io.File
+
+class KotlinLineLoader {
+
+    /**
+     * Kotlin does away with checked exceptions *and*
+     * it also adds commonly used functionality to existing
+     * java classes (like `readLines` here).
+     */
+    fun loadLines(path: String) = File(path).readLines()
+}

src/main/kotlin/org/codetome/kotlin/examples/extensions/ListPresenterExtension.kt

@@ -0,0 +1,7 @@
+package org.codetome.kotlin.examples.extensions
+
+/**
+ * This method acts as a decorator for all `List`s.
+ * Compared to the java alternative this one-liner is much simpler.
+ */
+fun <T> List<T>.present() = this.joinToString(", ")

src/main/kotlin/org/codetome/kotlin/examples/fp/KotlinUser.kt

@@ -0,0 +1,27 @@
+package org.codetome.kotlin.examples.fp
+
+data class KotlinUser(val firstName: String,
+                      val lastName: String,
+                      val addresses: List<Address> = listOf()) {
+
+    data class Address(val city: String)
+
+    companion object {
+
+        /**
+         * The differences from Java are rather subtle here:
+         * - There is no explicit conversion to streams since all Kotlin
+         *   collections support it out of the box
+         * - Not having to pass a lambda to `flatMap` here is a direct
+         *   consequence of this
+         * - Collecting the result is also automatic (no need for
+         *   `Collectors.to*` method calls. We only had to use `toSet`
+         *   here because we want to return a `Set`
+         */
+        fun fetchCitiesOfUsers(users: List<KotlinUser>) = users
+                .flatMap(KotlinUser::addresses)
+                .map(Address::city)
+                .toSet()
+    }
+
+}