Kotlin中arrayListOf与ArrayList的区别：使用上的具体差异是什么？

Great question! Let me break down the practical, day-to-day differences between these two in Kotlin—since you already know one's a function and the other's a class, let's focus on when you'd use each and how they behave in code.

Core Practical Differences #

• Simplified Initialization
  arrayListOf() is a top-level Kotlin standard library function built to make creating ArrayLists less verbose. If you want to initialize a list with pre-defined elements, it's way cleaner:

  // Super concise with arrayListOf()
  val veggies = arrayListOf("carrot", "spinach", "broccoli")
  
  // Equivalent with ArrayList class (clunkier)
  val veggies = ArrayList<String>().apply {
      add("carrot")
      add("spinach")
      add("broccoli")
  }
  

• Type Inference Magic
  arrayListOf() automatically infers the generic type of your list based on the elements you pass. This saves you from having to explicitly declare the type most of the time:

  // Automatically becomes ArrayList<Int>
  val numbers = arrayListOf(1, 2, 3, 4)
  
  // With ArrayList class, you have to specify the type (or get ArrayList<Any?>)
  val numbers = ArrayList<Int>()
  numbers.addAll(listOf(1,2,3,4))
  

• Control Over Initialization Parameters
  The ArrayList class gives you direct access to constructors that let you optimize for specific cases:

  • Set initial capacity: If you know your list will hold a large number of elements upfront, you can avoid costly auto-resizes by setting an initial capacity:

    // Pre-allocate space for 1000 elements
    val largeDataset = ArrayList<Double>(1000)
    

  • Create from an existing collection: You can directly initialize an ArrayList using another collection (like a List or Set) without having to unpack elements:

    val existingReadOnlyList = listOf("cat", "dog", "bird")
    // Convert to ArrayList in one step
    val mutableList = ArrayList(existingReadOnlyList)
    

  arrayListOf() can't do either of these directly—you'd have to work around it with extra code.

• Under-the-hood Behavior
  Don't worry about performance differences: arrayListOf() is just a wrapper around ArrayList constructors. For example:

  • arrayListOf() with no arguments calls ArrayList(10) (the default initial capacity for ArrayLists).
  • arrayListOf(element1, element2) creates an ArrayList with enough capacity to hold the elements, then adds them all.

When to Use Which? #

• Use arrayListOf() for most everyday cases: when you need a quick, readable way to create a mutable ArrayList with or without initial elements.
• Use the ArrayList class directly when you need to optimize for capacity, or when you're converting an existing collection to an ArrayList efficiently.

内容的提问来源于stack exchange，提问作者jakchang