当前位置：首页 > 软件库 > 手机/移动开发 > >

from-java-to-kotlin

授权协议 Apache-2.0 License

开发语言 Kotlin

所属分类手机/移动开发

软件类型开源软件

地区不详

投递者翟丰茂

操作系统 Android

开源组织无

适用人群未知

软件概览

From Java To Kotlin

From Java To Kotlin - Your Cheat Sheet For Java To Kotlin

中文支持

Português

Español

Print to Console

Java

System.out.print("Amit Shekhar");
System.out.println("Amit Shekhar");

Kotlin

print("Amit Shekhar")
println("Amit Shekhar")

Constants and Variables

Java

String name = "Amit Shekhar";
final String name = "Amit Shekhar";

Kotlin

var name = "Amit Shekhar"
val name = "Amit Shekhar"

Assigning the null value

Java

String otherName;
otherName = null;

Kotlin

var otherName : String?
otherName = null

Verify if value is null

Java

if (text != null) {
  int length = text.length();
}

Kotlin

text?.let {
    val length = text.length
}
// or simply
val length = text?.length

Verify if value is NotNull OR NotEmpty

Java

String sampleString = "Shekhar";
if (!sampleString.isEmpty()) {
    myTextView.setText(sampleString);
}
if(sampleString!=null && !sampleString.isEmpty()){
    myTextView.setText(sampleString); 
}

Kotlin

var sampleString ="Shekhar"
if(sampleString.isNotEmpty()){  //the feature of kotlin extension function
    myTextView.text=sampleString
}
if(!sampleString.isNullOrEmpty()){
   myTextView.text=sampleString 
}

Concatenation of strings

Java

String firstName = "Amit";
String lastName = "Shekhar";
String message = "My name is: " + firstName + " " + lastName;

Kotlin

var firstName = "Amit"
var lastName = "Shekhar"
var message = "My name is: $firstName $lastName"

New line in string

Java

String text = "First Line\n" +
              "Second Line\n" +
              "Third Line";

Kotlin

val text = """
        |First Line
        |Second Line
        |Third Line
        """.trimMargin()

Substring

Java

String str = "Java to Kotlin Guide";
String substr = "";

//print java
substr = str.substring(0, 4);
System.out.println("substring = " + substr);

//print kotlin
substr = str.substring(8, 14);
System.out.println("substring = " + substr);

Kotlin

var str = "Java to Kotlin Guide"
var substr = ""

//print java
substr = str.substring(0..3) //
println("substring $substr")

//print kotlin
substr = str.substring(8..13)
println("substring $substr")

Ternary Operations

Java

String text = x > 5 ? "x > 5" : "x <= 5";

String message = null;
log(message != null ? message : "");

Kotlin

val text = if (x > 5) "x > 5" else "x <= 5"

val message: String? = null
log(message ?: "")

Bitwise Operators

Java

final int andResult  = a & b;
final int orResult   = a | b;
final int xorResult  = a ^ b;
final int rightShift = a >> 2;
final int leftShift  = a << 2;
final int unsignedRightShift = a >>> 2;

Kotlin

val andResult  = a and b
val orResult   = a or b
val xorResult  = a xor b
val rightShift = a shr 2
val leftShift  = a shl 2
val unsignedRightShift = a ushr 2

Check the type and casting

Java

if (object instanceof Car) {
	Car car = (Car) object;
}

Kotlin

if (object is Car) {
var car = object as Car
}

// if object is null
var car = object as? Car // var car = object as Car?

Check the type and casting (implicit)

Java

if (object instanceof Car) {
   Car car = (Car) object;
}

Kotlin

if (object is Car) {
   var car = object // smart casting
}

// if object is null
if (object is Car?) {
   var car = object // smart casting, car will be null
}

Multiple conditions

Java

if (score >= 0 && score <= 300) { }

Kotlin

if (score in 0..300) { }

Multiple Conditions (Switch case)

Java

int score = // some score;
String grade;
switch (score) {
	case 10:
	case 9:
		grade = "Excellent";
		break;
	case 8:
	case 7:
	case 6:
		grade = "Good";
		break;
	case 5:
	case 4:
		grade = "OK";
		break;
	case 3:
	case 2:
	case 1:
		grade = "Fail";
		break;
	default:
	    grade = "Fail";				
}

Kotlin

var score = // some score
var grade = when (score) {
	9, 10 -> "Excellent"
	in 6..8 -> "Good"
	4, 5 -> "OK"
	else -> "Fail"
}

For-loops

Java

for (int i = 1; i <= 10 ; i++) { }

for (int i = 1; i < 10 ; i++) { }

for (int i = 10; i >= 0 ; i--) { }

for (int i = 1; i <= 10 ; i+=2) { }

for (int i = 10; i >= 0 ; i-=2) { }

for (String item : collection) { }

for (Map.Entry<String, String> entry: map.entrySet()) { }

Kotlin

for (i in 1..10) { }

for (i in 1 until 10) { }

for (i in 10 downTo 0) { }

for (i in 1..10 step 2) { }

for (i in 10 downTo 0 step 2) { }

for (item in collection) { }

for ((key, value) in map) { }

Collections

Java

final List<Integer> listOfNumber = Arrays.asList(1, 2, 3, 4);

final Map<Integer, String> keyValue = new HashMap<Integer, String>();
map.put(1, "Amit");
map.put(2, "Ali");
map.put(3, "Mindorks");

// Java 9
final List<Integer> listOfNumber = List.of(1, 2, 3, 4);

final Map<Integer, String> keyValue = Map.of(1, "Amit",
                                             2, "Ali",
                                             3, "Mindorks");

Kotlin

val listOfNumber = listOf(1, 2, 3, 4)
val keyValue = mapOf(1 to "Amit",
                     2 to "Ali",
                     3 to "Mindorks")

for each

Java

// Java 7 and below
for (Car car : cars) {
  System.out.println(car.speed);
}

// Java 8+
cars.forEach(car -> System.out.println(car.speed));

// Java 7 and below
for (Car car : cars) {
  if (car.speed > 100) {
    System.out.println(car.speed);
  }
}

// Java 8+
cars.stream().filter(car -> car.speed > 100).forEach(car -> System.out.println(car.speed));
cars.parallelStream().filter(car -> car.speed > 100).forEach(car -> System.out.println(car.speed));

Kotlin

cars.forEach {
    println(it.speed)
}

cars.filter { it.speed > 100 }
      .forEach { println(it.speed)}

// kotlin 1.1+
cars.stream().filter { it.speed > 100 }.forEach { println(it.speed)}
cars.parallelStream().filter { it.speed > 100 }.forEach { println(it.speed)}

Splitting arrays

java

String[] splits = "param=car".split("=");
String param = splits[0];
String value = splits[1];

kotlin

val (param, value) = "param=car".split("=")

Defining methods

Java

void doSomething() {
   // logic here
}

Kotlin

fun doSomething() {
   // logic here
}

Default values for method parameters

Java

double calculateCost(int quantity, double pricePerItem) {
    return pricePerItem * quantity;
}

double calculateCost(int quantity) {
    // default price is 20.5
    return 20.5 * quantity;
}

Kotlin

fun calculateCost(quantity: Int, pricePerItem: Double = 20.5) = quantity * pricePerItem

calculateCost(10, 25.0) // 250
calculateCost(10) // 205

Variable number of arguments

Java

void doSomething(int... numbers) {
   // logic here
}

Kotlin

fun doSomething(vararg numbers: Int) {
   // logic here
}

Defining methods with return

Java

int getScore() {
   // logic here
   return score;
}

Kotlin

fun getScore(): Int {
   // logic here
   return score
}

// as a single-expression function

fun getScore(): Int = score

// even simpler (type will be determined automatically)

fun getScore() = score // return-type is Int

Returning result of an operation

Java

int getScore(int value) {
    // logic here
    return 2 * value;
}

Kotlin

fun getScore(value: Int): Int {
   // logic here
   return 2 * value
}

// as a single-expression function
fun getScore(value: Int): Int = 2 * value

// even simpler (type will be determined automatically)

fun getScore(value: Int) = 2 * value // return-type is int

Constructors

Java

public class Utils {

    private Utils() {
      // This utility class is not publicly instantiable
    }

    public static int getScore(int value) {
        return 2 * value;
    }

}

Kotlin

class Utils private constructor() {

    companion object {

        fun getScore(value: Int): Int {
            return 2 * value
        }

    }
}

// another way

object Utils {

    fun getScore(value: Int): Int {
        return 2 * value
    }

}

Getters and Setters

Java

public class Developer {

    private String name;
    private int age;

    public Developer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Developer developer = (Developer) o;

        if (age != developer.age) return false;
        return name != null ? name.equals(developer.name) : developer.name == null;

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Developer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Kotlin

data class Developer(var name: String, var age: Int)

Cloning or copying

Java

public class Developer implements Cloneable {

    private String name;
    private int age;

    public Developer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return (Developer)super.clone();
    }
}

// cloning or copying
Developer dev = new Developer("Mindorks", 30);
try {
    Developer dev2 = (Developer) dev.clone();
} catch (CloneNotSupportedException e) {
    // handle exception
}

Kotlin

data class Developer(var name: String, var age: Int)

// cloning or copying
val dev = Developer("Mindorks", 30)
val dev2 = dev.copy()
// in case you only want to copy selected properties
val dev2 = dev.copy(age = 25)

Class methods

Java

public class Utils {

    private Utils() {
      // This utility class is not publicly instantiable
    }

    public static int triple(int value) {
        return 3 * value;
    }

}

int result = Utils.triple(3);

Generics

Java

// Example #1
interface SomeInterface<T> {
    void doSomething(T data);
}

class SomeClass implements SomeInterface<String> {
    @Override
    public void doSomething(String data) {
        // some logic
    }
}

// Example #2
interface SomeInterface<T extends Collection<?>> {
    void doSomething(T data);
}

class SomeClass implements SomeInterface<List<String>> {

    @Override
    public void doSomething(List<String> data) {
        // some logic
    }
}

interface SomeInterface<T> {
    fun doSomething(data: T)
}

class SomeClass: SomeInterface<String> {
    override fun doSomething(data: String) {
        // some logic
    }
}

interface SomeInterface<T: Collection<*>> {
    fun doSomething(data: T)
}

class SomeClass: SomeInterface<List<String>> {
    override fun doSomething(data: List<String>) {
        // some logic
    }
}

Kotlin

fun Int.triple(): Int {
  return this * 3
}

var result = 3.triple()

Defining uninitialized objects

Java

Person person;

Kotlin

internal lateinit var person: Person

enum

Java

public enum Direction {
        NORTH(1),
        SOUTH(2),
        WEST(3),
        EAST(4);

        int direction;

        Direction(int direction) {
            this.direction = direction;
        }

        public int getDirection() {
            return direction;
        }
    }

Kotlin

enum class Direction(val direction: Int) {
    NORTH(1),
    SOUTH(2),
    WEST(3),
    EAST(4);
}

Sorting List

Java

List<Profile> profiles = loadProfiles(context);
Collections.sort(profiles, new Comparator<Profile>() {
    @Override
    public int compare(Profile profile1, Profile profile2) {
        if (profile1.getAge() > profile2.getAge()) return 1;
        if (profile1.getAge() < profile2.getAge()) return -1;
        return 0;
    }
});

Kotlin

val profile = loadProfiles(context)
profile.sortedWith(Comparator({ profile1, profile2 ->
    if (profile1.age > profile2.age) return@Comparator 1
    if (profile1.age < profile2.age) return@Comparator -1
    return@Comparator 0
}))

Anonymous Class

Java

AsyncTask<Void, Void, Profile> task = new AsyncTask<Void, Void, Profile>() {
    @Override
    protected Profile doInBackground(Void... voids) {
        // fetch profile from API or DB
        return null;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // do something
    }
};

Kotlin

val task = object : AsyncTask<Void, Void, Profile>() {
    override fun doInBackground(vararg voids: Void): Profile? {
        // fetch profile from API or DB
        return null
    }

    override fun onPreExecute() {
        super.onPreExecute()
        // do something
    }
}

Initialization block

Java

public class User {
    {  //Initialization block
        System.out.println("Init block");
    }
}

Kotlin

class User {
        init { // Initialization block
            println("Init block")
        }
    }

Important things to know in Kotlin

Found this project useful ❤️

Support by clicking the ⭐ button on the upper right of this page. ✌️

Check out Mindorks awesome open source projects here

License

   Copyright (C) 2017 MINDORKS NEXTGEN PRIVATE LIMITED

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

Contributing to From Java To Kotlin

Just make a pull request. You are in!

使用案例

Kotlin与Java的异同（一）

本文章只为了方便查阅。 Kotlin简介 Kotlin是一种针对Java 平台的新编程语言。Kotlin简洁、安全、务实，并且专注于与Java代码的互操作性。它几乎可以用在现在Java使用的任何地方：服务端开发、Android应用等等。Kotlin 可以很好地和所有现存的Java库和框架一起工作，而且性能和Java旗鼓相当。 Kotlin 特点： Kotlin 是静态类型语言并支持类型推导，允许维
kotlin(十七)Kotlin和Java相互调用

1.Kotlin调用Java的方法和属性 1）定义java类 public class JavaClass { private String javaString = "java"; public void sayHello(String name) { System.out.println("Hello " + name); } public
从 Java 开始进入 Kotlin的世界： From Java to Kotlin: JKotlinor

从 Java 开始进入 Kotlin的世界： From Java to Kotlin: JKotlinor 最新上架！！！《 Kotlin极简教程》陈光剑（机械工业出版社）可直接打开京东，淘宝，当当===> 搜索： Kotlin 极简教程 http://www.jianshu.com/p/35b487734339 Kotlin与Java对比在前面的内容里，我们已经看到了Java与Kotli
Does Kotlin really have a chance to replace Java, or is it just wishful thinking by Google/JetBrains...

Yes, it's already doing it! Zhenxu Ke, Full Stack Engineer (2016-present) Answered Sep 8 Kotlin have a chance to replace Java but it largely depends on Java (technically on its owner, Oracle). Firstly
Kotlin vs Java: Will Kotlin Replace Java?

Kotlin vs Java: Will Kotlin Replace Java? An article mained to describe all the main beauties of the two languages for Android mobile development - Kotlin and Java respectively. The article dates back
Java 和 Kotlin

Java 与 Kotlin 比较表以下是对照表：比较的基础 Java Kotlin 空值安全在 Java 中，NullPointerExceptions 给开发人员带来了巨大的挫败感。它允许用户将 null 分配给任何变量，但是在访问具有 null 值的对象引用时会引发用户需要处理的空指针异常。在 Kotlin 中，默认情况下，所有类型的变量都是不可为空的（即我们不能为任何类型的变量/对象
Java转Kotlin

for循环 for (i in 0 until locationData.size) { val city = locationData.getJsonMap(i) val value = city.getString("Value") options1Items.add(value) } until 代表结束数量-1 for (i in cityData.indices)
从Java到Kotlin

作为一位Andorid开发者，或者说一名前端开发者，实在是感概“日新月异，一山更比一山高”。2016年的夏天我还在解决从Android4.0到5.0时的权限适配问题，以为这已经是一个很大的跨度了，但是到今年我已经要开始考虑Android7.0的安全适配问题了，然后如期而至的Anroid8.0也到来。这只反应出一个问题——前端开发者必须时刻紧跟时代的步伐，去吸收，接纳新鲜事物，和新技术。暂且不管，
java调用kotlin

java调用kotlin 在Java代码中，可以轻松的调用Kotlin，无缝对接，然而两者之间有一些不同的地方需要注意。属性一个kotlin属性会编译成下面java元素： getter setter private field 例如var firstName: String会被编译成下面这样： private String firstName; public String getFirstN
kotlin 和 Java

kotlin简介 kotlin是一种基于JVM的静态类型编程语言，kotlin可以编译成Java字节码，也可以编译成JavaScript，kotlin是强类型的语言，kotlin要求所有的变量必须先声明、后使用。 kotlin与java kotlin可与java进行100%的互操作，使用kotlin过程中有任何问题可随时切换回java。 kotlin优势完全兼容Java 空指针安全支持lamb
Kotlin-44.Java调用kotlin之二(Call Kotlin from Java)

官方文档: http://kotlinlang.org/docs/reference/java-to-kotlin-interop.html 4.静态字段(Static Fields) 在对象(object)或伴生对象(companion object)中声明的Kotlin属性,有静态的幕后字段(backing fields)! 这些静态字段是私有private,但可通过以下方式暴露(公开publ
【深入kotlin】 - 与Java互操作：kotlin调用java

Kotlin 调用 Java 比如如下 Java 类： public class Person{ private String name; private boolean married; private int age; ...... } 在 kotlin 中调用 Person: fun main(args:Array<String>){ val list = ArrayList<S
【深入kotlin】 - 与Java互操作：java调用kotlin

Java 调用 kotlin 属性 Kotlin 类的一个属性编译后，会产生 3 种 Java 对象： get 方法，getXxx set 方法，setXxx 私有字段，字段名与 kotlin 属性名完全匹配。 class Test { var name: String = "" } 如果 kotlin 属性名为 is 开头（Bool 类型），get 方法名 = 属性名，set 方法名则是将
Kotlin(十三)之Kotlin调用java

属性 Kotlin调用属性本质就是调用getter和setter方法，因此只要java提供setter、getter方法，kotlin就可以直接读取或者写入如果getter方法的返回值类型是boolean，并且该getter方法名以is开头，此时Kotlin会将其当作属性名与getter方法同名的属性，比如boolean isFlag 可以作为Kotlin的只读属性，该属性名为isFlag 方法
Kotlin概述与Java的比较&我为什么放弃java学习Kotlin？

Kotlin概述与Java的比较我为什么放弃java学习Kotlin？
From Java To Kotlin

打印日志 Java System.out.print("Amit Shekhar"); System.out.println("Amit Shekhar"); Kotlin print("Amit Shekhar") println("Amit Shekhar") 常量与变量 Java String name = "Amit Shekhar"; final String name = "Amit
Kotlin vs Java on Android

Kotlin vs Java onAndroid 1. Pre Kotlin是一门与Swift类似的静态类型JVM语言，由JetBrains设计开发并开源。与Java相比，Kotlin的语法更简洁、更具表达性，而且提供了更多的特性，比如，高阶函数、操作符重载、字符串模板。它与Java高度可互操作，可以同时用在一个项目中。按照JetBrains的说法，根据他们多年的Java平台开发经验，他们认
《From Java To Kotlin》-Kotlin与Java的简单对比

前言：原文来自https://github.com/MindorksOpenSource/from-java-to-kotlin 本文也只是简单比较kotlin与java的不同之处，实际学习kotlin还是去官网学习比较好。我个人学习的一个网站贴出来：Kotlin中文网打印日志 Java System.out.print("Amit Shekhar"); System.out.println(

from-java-to-kotlin

From Java To Kotlin

中文支持

Português

Español

Print to Console

Constants and Variables

Assigning the null value

Verify if value is null

Verify if value is NotNull OR NotEmpty

Concatenation of strings

New line in string

Substring

Ternary Operations

Bitwise Operators

Check the type and casting

Check the type and casting (implicit)

Multiple conditions

Multiple Conditions (Switch case)

For-loops

Collections

for each

Splitting arrays

Defining methods

Default values for method parameters

Variable number of arguments

Defining methods with return

Returning result of an operation

Constructors

Getters and Setters

Cloning or copying

Class methods

Generics

Defining uninitialized objects

enum

Sorting List

Anonymous Class

Initialization block

Important things to know in Kotlin

Found this project useful ❤️

License

Contributing to From Java To Kotlin

同类工具

相关阅读

相关文章

相关问答

相关文档