วิธีการเริ่มต้นอาร์เรย์ใน Kotlin ด้วยค่า?

ใน Java อาร์เรย์สามารถเริ่มต้นได้เช่น:

int numbers[] = new int[] {10, 20, 30, 40, 50}

การกำหนดค่าเริ่มต้นอาร์เรย์ของ Kotlin มีลักษณะอย่างไร

val numbers: IntArray = intArrayOf(10, 20, 30, 40, 50)

ดูKotlin - ประเภทพื้นฐานสำหรับรายละเอียด

คุณยังสามารถจัดเตรียมฟังก์ชัน initializer เป็นพารามิเตอร์ตัวที่สอง:

val numbers = IntArray(5) { 10 * (it + 1) }
// [10, 20, 30, 40, 50]

มูลค่าการกล่าวขวัญว่าเมื่อใช้ builtines Kotlin (เช่นintArrayOf(), longArrayOf(), arrayOf()ฯลฯ ) ที่คุณไม่สามารถที่จะเริ่มต้นอาร์เรย์ที่มีค่าเริ่มต้น (หรือค่าทั้งหมดเป็นค่าที่ต้องการ) สำหรับขนาดที่กำหนดแทนคุณต้องทำการเริ่มต้นผ่านทางโทรตามคอนสตรัคชั้น .

// Array of integers of a size of N
val arr = IntArray(N)

// Array of integers of a size of N initialized with a default value of 2
val arr = IntArray(N) { i -> 2 }

นี่คือตัวอย่าง:

fun main(args: Array<String>) {
    val arr = arrayOf(1, 2, 3);
    for (item in arr) {
        println(item);
    }
}

คุณยังสามารถใช้สนามเด็กเล่นเพื่อทดสอบคุณสมบัติภาษา

ใน Kotlin มีหลายวิธี

var arr = IntArray(size) // construct with only size

จากนั้นเพียงแค่เริ่มต้นค่าจากผู้ใช้หรือจากคอลเลกชันอื่นหรือทุกที่ที่คุณต้องการ

var arr = IntArray(size){0}  // construct with size and fill array with 0
var arr = IntArray(size){it} // construct with size and fill with its index

นอกจากนี้เรายังสามารถสร้างอาร์เรย์ที่มีฟังก์ชั่นในตัวเช่น -

var arr = intArrayOf(1, 2, 3, 4, 5) // create an array with 5 values

อีกวิธีหนึ่ง

var arr = Array(size){0} // it will create an integer array
var arr = Array<String>(size){"$it"} // this will create array with "0", "1", "2" and so on.

คุณยังสามารถใช้doubleArrayOf()หรือDoubleArray()หรือประเภทดั้งเดิมใด ๆ แทน Int

ใน Kotlin เราสามารถสร้างอาร์เรย์ใช้arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(),longArrayOf()ฟังก์ชั่น

ตัวอย่างเช่น:

var Arr1 = arrayOf(1,10,4,6,15)  
var Arr2 = arrayOf<Int>(1,10,4,6,15)  
var Arr3 = arrayOf<String>("Surat","Mumbai","Rajkot")  
var Arr4 = arrayOf(1,10,4, "Ajay","Prakesh")  
var Arr5: IntArray = intArrayOf(5,10,15,20)  

คำถามเก่า แต่ถ้าคุณต้องการใช้ช่วง:

var numbers: IntArray = IntRange(10, 50).step(10).toList().toIntArray()

ผลตอบแทนใกล้เคียงกับ:

var numbers = Array(5, { i -> i*10 + 10 })

ผล: 10, 20, 30, 40, 50

ฉันคิดว่าตัวเลือกแรกนั้นสามารถอ่านได้มากกว่านี้เล็กน้อย ทั้งงาน

คุณสามารถใช้วิธีนี้

var numbers=Array<Int>(size,init)
var numbers=IntArray(size,init)
var numbers= intArrayOf(1,2,3)

ตัวอย่าง

var numbers = Array<Int>(5, { i -> 0 })

init หมายถึงค่าเริ่มต้น (เริ่มต้น)

Kotlin ภาษามีความเชี่ยวชาญชั้นเรียนสำหรับตัวแทนอาร์เรย์ชนิดดั้งเดิมโดยไม่ต้องมวยค่าใช้จ่าย: เช่น - IntArray, ShortArray, ByteArrayฯลฯ ฉันจำเป็นต้องบอกว่าชั้นเรียนเหล่านี้ไม่มีความสัมพันธ์มรดกแก่ผู้ปกครองArrayชั้น แต่พวกเขามีชุดเดียวกับวิธีการและคุณสมบัติ แต่ละคนยังมีฟังก์ชั่นโรงงานที่สอดคล้องกัน ดังนั้นในการเริ่มต้นอาร์เรย์ด้วยค่าใน Kotlin คุณเพียงแค่พิมพ์สิ่งนี้:

val myArr: IntArray = intArrayOf(10, 20, 30, 40, 50)

... หรือด้วยวิธีนี้:

val myArr = Array<Int>(5, { i -> ((i+1) * 10) })

myArr.forEach { println(it) }                                // 10, 20, 30, 40, 50

ตอนนี้คุณสามารถใช้มัน:

myArr[0] = (myArr[1] + myArr[2]) - myArr[3]

หวังว่านี่จะช่วยได้

ฉันคิดว่าสิ่งหนึ่งที่ควรค่าแก่การกล่าวถึงและไม่ง่ายพอจากเอกสารก็คือเมื่อคุณใช้ฟังก์ชั่นจากโรงงานเพื่อสร้างอาร์เรย์และคุณระบุขนาดของมันอาร์เรย์จะเริ่มต้นด้วยค่าที่เท่ากับค่าดัชนีของพวกเขา ยกตัวอย่างเช่นในอาร์เรย์เช่นนี้: val array = Array(5, { i -> i })ค่าเริ่มต้นที่ได้รับมอบหมายเป็นและไม่ได้พูดว่า[0,1,2,3,4] [0,0,0,0,0]นั่นคือเหตุผลที่มาจากเอกสารประกอบval asc = Array(5, { i -> (i * i).toString() })สร้างคำตอบของ["0", "1", "4", "9", "16"]

คุณสามารถสร้าง Int Array ดังนี้:

val numbers = IntArray(5, { 10 * (it + 1) })

5 คือขนาด Int Array ฟังก์ชั่นแลมบ์ดาเป็นฟังก์ชั่นเริ่มต้นองค์ประกอบ ช่วง 'it' ใน [0,4], บวก 1 ทำให้ช่วงเป็น [1,5]

ฟังก์ชั่นกำเนิดคือ:

 /**
 * An array of ints. When targeting the JVM, instances of this class are 
 * represented as `int[]`.
 * @constructor Creates a new array of the specified [size], with all elements 
 *  initialized to zero.
 */
 public class IntArray(size: Int) {
       /**
        * Creates a new array of the specified [size], where each element is 
        * calculated by calling the specified
        * [init] function. The [init] function returns an array element given 
        * its index.
        */
      public inline constructor(size: Int, init: (Int) -> Int)
  ...
 }

คลาส IntArray ที่กำหนดใน Arrays.kt

คุณสามารถลองสิ่งนี้:

var a = Array<Int>(5){0}

คุณสามารถใช้วิธีไลบรารีมาตรฐานที่มีอยู่ตามที่แสดงที่นี่:

val numbers = intArrayOf(10, 20, 30, 40, 50)

มันอาจสมเหตุสมผลที่จะใช้ตัวสร้างพิเศษแม้ว่า:

val numbers2 = IntArray(5) { (it + 1) * 10 }

คุณผ่านขนาดและแลมบ์ดาที่อธิบายถึงวิธีการเริ่มต้นค่า นี่คือเอกสารประกอบ:

/**
 * Creates a new array of the specified [size], where each element is calculated by calling the specified
 * [init] function. The [init] function returns an array element given its index.
 */
public inline constructor(size: Int, init: (Int) -> Int)

ฉันสงสัยว่าทำไมไม่มีใครให้คำตอบที่ง่ายที่สุด:

val array: Array<Int> = [1, 2, 3]

ตามหนึ่งในความคิดเห็นต่อคำตอบเดิมของฉันฉันตระหนักว่านี่จะใช้ได้เฉพาะเมื่อใช้ในการขัดแย้งคำอธิบายประกอบ (ซึ่งไม่คาดคิดจริงๆสำหรับฉัน)

ดูเหมือนว่า Kotlin ไม่อนุญาตให้สร้างตัวอักษรแถวนอกคำอธิบายประกอบ

ตัวอย่างเช่นดูรหัสนี้โดยใช้ @Option จากไลบรารี args4j:

    @Option (
        name = "-h",
        aliases = ["--help", "-?"],
        การใช้ = "แสดงความช่วยเหลือนี้"
    )
    var help: Boolean = false

อาร์กิวเมนต์ตัวเลือก "aliases" เป็นประเภท Array<String>

ในกรณีของฉันฉันต้องเริ่มต้นรายการลิ้นชักของฉัน ฉันกรอกข้อมูลด้วยรหัสด้านล่าง

    val iconsArr : IntArray = resources.getIntArray(R.array.navigation_drawer_items_icon)
    val names : Array<String> = resources.getStringArray(R.array.navigation_drawer_items_name)


    // Use lambda function to add data in my custom model class i.e. DrawerItem
    val drawerItems = Array<DrawerItem>(iconsArr.size, init = 
                         { index -> DrawerItem(iconsArr[index], names[index])})
    Log.d(LOGGER_TAG, "Number of items in drawer is: "+ drawerItems.size)

โมเดลที่กำหนดเองคลาส -

class DrawerItem(var icon: Int, var name: String) {

}

ประกาศ int array ที่ global

var numbers= intArrayOf()

ถัดไปในการสร้างวิธีการเริ่มต้นอาร์เรย์ของคุณด้วยค่า

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //create your int array here
    numbers= intArrayOf(10,20,30,40,50)
}

ใน Java อาร์เรย์สามารถเริ่มต้นได้เช่น:

int numbers[] = new int[] {10, 20, 30, 40, 50}

แต่ใน Kotlin อาร์เรย์เริ่มต้นได้หลายทางเช่น:

อาเรย์ประเภททั่วไปใด ๆ ที่คุณสามารถใช้ฟังก์ชัน arrayOf () :

val arr = arrayOf(10, 20, 30, 40, 50)

val genericArray = arrayOf(10, "Stack", 30.00, 40, "Fifty")

การใช้ฟังก์ชั่นยูทิลิตี้ของ Kotlin อาร์เรย์สามารถเริ่มต้นได้

val intArray = intArrayOf(10, 20, 30, 40, 50)

วิธีง่าย ๆ :

สำหรับจำนวนเต็ม:

var number = arrayOf <Int> (10, 20, 30, 40, 50)

พักข้อมูลทุกประเภท

var number = arrayOf (10, "ค่าสตริง", 10.5)

จัดเรียงอาร์เรย์ด้วยวิธีนี้: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

ด้วยวิธีนี้คุณสามารถเริ่มต้นอาร์เรย์ int ใน koltin

 val values: IntArray = intArrayOf(1, 2, 3, 4, 5,6,7)

คำตอบของฉันเติม @maroun เหล่านี้เป็นวิธีการเริ่มต้นอาร์เรย์:

ใช้อาร์เรย์

val numbers = arrayOf(1,2,3,4,5)

ใช้อาร์เรย์ที่เข้มงวด

val numbers = intArrayOf(1,2,3,4,5)

ประเภทผสมของเมทริกซ์

val numbers = arrayOf(1,2,3.0,4f)

ทำรังอาร์เรย์

val numbersInitials = intArrayOf(1,2,3,4,5)
val numbers = arrayOf(numbersInitials, arrayOf(6,7,8,9,10))

ความสามารถในการเริ่มต้นด้วยรหัสแบบไดนามิก

val numbers = Array(5){ it*2}