Kotlin 的 'const val num = 1' 的类型是什么？ 他们如何定义它？

Question

Mostly, I use Int , Double and String , Char . Recently, I got interested in saving memory and I realized even small amount of bytes can be much larger and it affects the program and even the mobile speed and battery life.(Especially, data resources of its memory)

So, I am trying to use Byte , Short when the data doesn't need to store big numbers. For example, byte for -128 ~ 127 , Short for -32,768 ~ 32,767 .

Is it a good idea?

And My main question is I want to know the data type of const val in Kotlin since it automatically defines the datatype.

const val THIS_IS_STRING = "HelloWorld"
const val THIS_IS_CHAR = 'C'
const val NUMBER_1 = -124
const val NUMBER_2 = 31000
const val NUMBER_3 = 1000000
const val NUMBER_4 = 1232188777777344444
const val NUMBER_5 = 29128812312732881231273712
const val NUMBER_6 = 0.423
const val NUMBER_7 = 0.2121222222441
const val NUMBER_8 = 0.813881281237123991827312324
const val NUMBER_9 = 0.5123090982307037412398190092340239423094803820432423423209823092342342348209384023984023480923840923840009930923094029848901

What are the data types of them(The numbers)?

Or should I define like these for saving the resources? Or I don't need to?

const val MIN:Byte = -124
const val MID:Short = 31000
const val MAX:Int = 1000000
...
``

Answer 1

It is dependent on you whether you want to provide data type allocation to kotlin or self. If your saving the values by providing resource type. You can save data or you can depend on the kotlin.

But if your saving the data i will advice you to provide the data type:

Let's take this as an example for you:

fun main() {
    var b: Any = 124
    println(b)
    if(b is Float) {
        println("Float")
    }
    else if(b is Double) {
        println("Double")
    }else if(b is Byte){
        println("byte")
    }else if(b is Int){
        println("int")
    }else if(b is Short){
        println("short")
    }
}

It will provide the output as Int .

So i suggest provide data type.

Answer 2

Kotlin Type inference - In Kotlin most of the time, you won't need to specify the type of the objects you are working with, as long as the compiler can infer it.

So, we just need to write var or val depending on the type of variable we want to generate, and the type can normally be inferred. We can always specify a type explicitly as well. Say, for instance, you define val REQUEST_CODE = 100 . Behind the scenes, REQUEST_CODE initializes with the Int datatype since the value of REQUEST_CODE is of type Int , the compiler infers that REQUEST_CODE is also a Int . Note that Kotlin is a statically-typed language. This means that the type is resolved at compile time and never changes.

Although Kotlin uses Type Inference ( automatically identify something ), which means we also have the option to specify the data type when we initialize the variable like below:

val REQUEST_CODE: Int = 100

Both act the same while converting it to byte code.

What the heck, How do Kotlin determine the data type of numbers if we use implicit declaration?

Good question, Kotlin provides a set of built-in types that represent numbers. For integer numbers, there are four types with different sizes and, hence, value ranges.

All variables initialized with integer values not exceeding the maximum value of Int have the inferred type Int . If the initial value exceeds this value, then the type is Long . To specify the Long value explicitly, append the suffix L to the value. So, whenever you strictly want to save memory it is advisable to use explicit type declaration for data types like Byte & Short as mentioned by Animesh in the accepted answer.

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1

Reference

• https://kotlinlang.org/docs/reference/basic-types.html

Answer 3

Type inference is described in https://kotlinlang.org/docs/reference/basic-types.html

Basically the default types when not specified for a number in range of -2 ³¹ to 2 ³¹ -1 is Int and higher than that is Long . To specify the Long value explicitly, append the suffix L to the value. So, whenever you strictly want to save memory it is advisable to use explicit type declaration for Byte and Short .

val one = 1                    // inferred as Int
val threeBillion = 3000000000  // inferred as Long
val oneL = 1L                  // explicitly specify Long type by appending with L
val oneLong: Long = 1L         // explicitly specify Long by type
val oneByte: Byte = 1          // explicitly specify Byte for saving memory

For floating point numbers default type is Double , you can switch to float by either specifying type or appending f .

val pi = 3.14               // Double
val piFloat: Float = 3.14   // explicitly specify Float by type
val e = 2.7182818284        // Double
val eFloat = 2.7182818284f  // explicitly specify Float by appending with f

The characters and strings by nature having single data type so it is Char and String by default, and there is no need to change it explicitly.

It is generally Advisable to specify types to save memory because it is constant and will never change so conservation is a better choice, but it is all upto you.

Answer 4

I'm surprised there are so many answers here ignoring this, but using Byte and Short for properties will not save you memory. The backing variables still take up 4 bytes of memory for each. They only save you memory when you use them in ByteArray and ShortArray . They also can cause a performance penalty for doing arithmetic with them instead of Int or Long , but that's insignificant in most applications.

As other answers have mentioned Int is implicit unless the number is big enough to be a Long . And this is what you want because it is more performant and takes up the same amount of memory.

Answer 5

Const is a compilation time constant. This means that a value must be allocated during the compilation time, unlike the value that can be performed at run-time, meaning that the const cannot be assigned to a function or class constructor and should only be allocated as character series or basic data type .