Versus
    32-bit vs 64-bit
    Annotations vs Decorators
    BigQuery vs Bigtable
    Block Storage vs File Storage vs Object Storage
    C vs C++
    Canvas vs SVG
    Constructor vs Init() vs Factory
    Containers vs Virtual Machines (VMs)
    DOM vs Virtual DOM vs Shadow DOM
    DQL vs DDL vs DCL vs DML
    Dagger vs Guice
    Data Mining vs Machine Learning vs Artificial Intelligence vs Data Science
    Flux vs Redux
    GCP API Gateway vs Cloud Endpoint
    GCP Cloud Run vs Cloud Functions vs App Engine
    GCP DataFlow vs Dataproc
    Google Analytics 4 vs Universal Analytics
    Google Internal vs Open Source
    HEIC vs HEIF vs HEVC vs JPEG
    Java vs C++
    Jetty vs Netty
    Kotlin vs Java
    LLVM vs JVM
    Linux vs BSD
    Microcontroller vs Microprocessor vs Computer
    Node.js vs Erlang
    POSIX vs SUS vs LSB
    Pass-by-value vs Pass-by-reference
    Proto2 vs Proto3
    PubSub vs Message Queue
    REST vs SOAP
    React vs Flutter vs Angular
    Rust vs C++
    SLI vs SLO vs SLA
    SRAM vs DRAM
    SSD vs HDD
    Software Engineer vs Site Reliability Engineer
    Spanner vs Bigtable
    Stack based VM vs Register based VM
    Stateless vs Stateful
    Static Site Generation vs Server-side Rendering vs Client-side Rendering
    Strong Consistency vs Eventual Consistency
    Subroutines vs Coroutines vs Generators
    Symlinks vs Hard Links
    Tensorflow vs PyTorch
    Terminal vs Shell
    Vi vs Vim vs gVim vs Neovim
    WAL vs rollback journal
    gtag vs Tag Manager
    stubs vs mocks vs fakes

Kotlin vs Java

Updated: 2022-03-25

Null Safety

  • Java: variables are nullable. NullPointerException is a common issue.
  • Kotlin: variables are non-nullable by default (to avoid NPE); use ? for nullable variables, e.g. var a: String?

Data Class and Records

Kotlin data class is similar to Java record, with some differences:

  • Java record does not have copy() method.
  • data class variables can be var or val; record variables are all final.
  • data class can inherit from other non-data classes; record has no inheritance.
  • data class can define non-constructor mutable variables; record can define only static variables.

Coroutines

  • Kotlin supports coroutines in an extension library kotlinx.coroutines. (Not at the language level or in the standard library.)
  • Java: Project Loom is trying to add coroutines / fibers to Java but it is not finished yet.

Extensions

  • Kotlin: provides the ability to extend a class with new functionality without having to inherit from the class or use design patterns such as Decorator.
  • Java: you have to create a new class and inhrit from the parent class.

Checked Exceptions

  • Kotlin: no checked exceptions, developers do not need to declare or catch exceptions.
  • Java: have both checked and unchecked exceptions.

Companion Object

  • Java: use static keyword to declare class members (used without an instance).
  • Kotlin: no static keyword but can use a companion object.

Class Inheritance

  • Java: methods can be overridden by default; a final class cannot be subclassed.
  • Kotlin: classes cannot be inherited by default; a open class can.

Sealed Class

Both Kotlin and Java (since Java 17) support Sealed Class.

Before Java 17, Java has the following options for inheritance control:

  • A final class can have no subclasses.
  • A package-private class can only have subclasses in the same package.

switch vs when

  • Java uses switch:

    switch ( ... ) {
      case X:
        ...
      case Y:
        ...
      default:
        ...
    }
  • Kotlin uses when:

    when ( ... ) {
      condition -> ...
      condition -> ...
      else -> ...
    }

Operator Overloading

  • Kotlin supports operator overloading; Java does not.