[java] What's the Kotlin equivalent of Java's String[]?

I see that Kotlin has ByteArray, ShortArray, IntArray, CharArray, DoubleArray, FloatArray, which are equivalent to byte[], short[], int[],char[], double[], float[] in Java.

Now I'm wondering, is there any StringArray equivalent to Java's String[]?

For Strings and other types, you just use Array<*>. The reason IntArray and others exist is to prevent autoboxing.

So int[] relates to IntArray where Integer[] relates to Array<Int>.

use arrayOf, arrayOfNulls, emptyArray

var colors_1: Array<String> = arrayOf("green", "red", "blue")
var colors_2: Array<String?> = arrayOfNulls(3)
var colors_3: Array<String> = emptyArray()

Some of the common ways to create a String array are

1. var arr = Array(5){""}

This will create an array of 5 strings with initial values to be empty string.

2. var arr = arrayOfNulls<String?>(5)

This will create an array of size 5 with initial values to be null. You can use String data to modify the array.

3. var arr = arrayOf("zero", "one", "two", "three")

When you know the contents of array already then you can initialise the array directly.

4. There is an easy way for creating an multi dimensional array of strings as well.

   var matrix = Array(5){Array(6) {""}}

   This is how you can create a matrix with 5 rows and 6 columns with initial values of empty string.

To create an empty Array of Strings in Kotlin you should use one of the following six approaches:

First approach:

val empty = arrayOf<String>()

Second approach:

val empty = arrayOf("","","")

Third approach:

val empty = Array<String?>(3) { null }

Fourth approach:

val empty = arrayOfNulls<String>(3)

Fifth approach:

val empty = Array<String>(3) { "it = $it" }

Sixth approach:

val empty = Array<String>(0, { _ -> "" })

you can use too:

val frases = arrayOf("texto01","texto02 ","anotherText","and ")

for example.

This example works perfectly in Android

In kotlin you can use a lambda expression for this. The Kotlin Array Constructor definition is:

Array(size: Int, init: (Int) -> T)

Which evaluates to:

skillsSummaryDetailLinesArray = Array(linesLen) {
        i: Int -> skillsSummaryDetailLines!!.getString(i)
}

Or:

skillsSummaryDetailLinesArray = Array<String>(linesLen) {
        i: Int -> skillsSummaryDetailLines!!.getString(i)
}

In this example the field definition was:

private var skillsSummaryDetailLinesArray: Array<String>? = null

Hope this helps

Those types are there so that you can create arrays of the primitives, and not the boxed types. Since String isn't a primitive in Java, you can just use Array<String> in Kotlin as the equivalent of a Java String[].