27
val mutableList1: MutableList<TeamInvitationData?>?
val mutableList2: MutableList<TeamInvitationData?>?

addAll method can be use to merge nullable mutable list but, here it throws me compile time error.

Example:

val map1 = listOne?.map { TeamInvitationData(it) }
val map2 = listTwo?.map { TeamInvitationData(it) }
map1.addAll(map2)

Type interface failed ,Please try to specify type argument explicitly.

Here Any way can I merge this two array , thanks in advance.

QuokMoon
  • 4,387
  • 4
  • 26
  • 50
  • On what line did the error occur? Why don't you show the code you actually wrote? – Marko Topolnik Jan 12 '18 at 11:42
  • this one have same code actually I did and unbox from the other element. – QuokMoon Jan 12 '18 at 12:07
  • You have shown no code that attempts to use `addAll`. You don't show any line of code that would need type inference, either. – Marko Topolnik Jan 12 '18 at 12:17
  • You pasted two snippets that don't combine into a whole. My best guess is that you expect `map1` and `map2` to be `MutableList` because `listOne` and `listTwo` are mutable, but `map` actually returns an immutable `List` and so you can't call `addAll` on it. While your question is about merging mutable lists, your code doesn't attempt that. – Marko Topolnik Jan 12 '18 at 16:37

4 Answers4

42

Here are couple of solutions.

  1. In case if you need to add all elements to mutableList1:

    val mutableList1: MutableList<Any?>? = ...
val mutableList2: MutableList<Any?>? = ...

mutableList1?.let { list1 -> mutableList2?.let(list1::addAll) }

  2. In case if you need new nullable list as result:

    val mutableList1: MutableList<Any?>? = ...
val mutableList2: MutableList<Any?>? = ...

val list3: List<Any?>? = mutableList1?.let { list1 ->
    mutableList2?.let { list2 -> list1 + list2 }
}

  3. In case if you need new nullable mutable list as result: 

    val mutableList1: MutableList<Any?>? = ...
val mutableList2: MutableList<Any?>? = ...

val list3: MutableList<Any?>? = mutableList1
        ?.let { list1 -> mutableList2?.let { list2 -> list1 + list2 } }
        ?.toMutableList()

  4. In case if you need new non-null list as result:

    val mutableList1: MutableList<Any?>? = ...
val mutableList2: MutableList<Any?>? = ...

val list3: List<Any?> = mutableList1.orEmpty() + mutableList2.orEmpty()
hluhovskyi
  • 9,556
  • 5
  • 30
  • 42
5

plus. Returns an List containing all elements of the original collection and then the given Iterable. source

Collection<T>.plus(elements: Iterable<T>): List<T>

Another Good read here

Ayush Jain
  • 563
  • 7
  • 11
1

Based on your snippets, which don't make a consistent whole, I made some guesses as to what you actually wanted to achieve:

val mutableList1: MutableList<String?>? = ...
val mutableList2: MutableList<String?>? = ...

val mapped1 = mutableList1?.mapTo(ArrayList()) { TeamInvitationData(it) }
val mapped2 = mutableList2?.mapTo(ArrayList()) { TeamInvitationData(it) }

mapped1?.addAll(mapped2.orEmpty())

The key point to note is that map() returns an immutable list regardless of the type of the input list. To get a mutable list you must use mapTo(destination) { ... }. Once that is fixed, you can use addAll() as shown in the last line.

Marko Topolnik
  • 195,646
  • 29
  • 319
  • 436
0

The answer given by @hluhovskyi is a good one, but there is one more posibility from his second option, where you need new nullable list as result:

In case if you need new nullable list as result:

val mutableList1: MutableList<Any?>? = ... val mutableList2: MutableList<Any?>? = ...

val list3: List<Any?>? = mutableList1?.let { list1 -> mutableList2?.let { list2 -> list1 + list2 } }

In this exmaple, in case mutableList1 is empty, you will have automatically and empty list ignoring if the mutableList2 has elements.

So, if you need the sum of the two lists and need a nullable list only if the two lists are null, you will need to do:

val mutableList1: MutableList<Any?>? = ...
val mutableList2: MutableList<Any?>? = ...

val list3: List<Any?>? = mutableList1?.let { list1 ->
    mutableList2?.let { list2 -> list1 + list2 } 
    ?: list1
} ?: mutableList2

So, now you will have as result:

  1. Null list if both were null at the begining
  2. The sum of both list if both were not null
  3. In case one is null and the other have elemnts, it will return the list with elements.
Sebastián Outeiro
  • 1
  • 2