Removing items in a MutableList with Kotlin - kotlin

Question

I could have a list like
["1", "2", "3", ".", "4", "."]
After the first occurrence of my delimiter, I want the duplicates removed
In my case, the above list should become
["1", "2", "3", ".", "4"]
I want all duplicates of "." removed after the first occurrence. Whats the best way?

Answer 1

You can use a temporary MutableSet to easily check if values are duplicates.
fun <T> MutableList<T>.removeDuplicates(): Boolean {
val set = mutableSetOf<T>()
return retainAll { set.add(it) }
}
Explanation: MutableList.retainAll is a function that removes every item for which the lambda returns false. When you add an item to a Set, it returns false if the item already exists in the set. So the first occurrence of each unique item will return true while subsequent occurrences will return false
Edit: It occurred to me that maybe you are interested only in the specific delimiter entry having duplicates. In that case, instead of a Set, I would use just a Boolean to track if it's been found yet. And I use removeAll instead of retainAll to make it easier to read.
fun <T> MutableList<T>.removeDuplicatesOf(delimiter: T): Boolean {
var firstInstanceFound = false
return removeAll { it == delimiter && firstInstanceFound.also { firstInstanceFound = true } }
}
Explanation: removeAll will remove anything for which the lambda returns true. Due to logical short-circuiting, anything that isn't the delimiter will return false before the part after the && is reached. When the first delimiter is found, firstInstanceFound will be false, so the logical statement evaluates to false. The also branch is also hit, so firstInstanceFound will be true for any subsequent delimiters found.

Answer 2

I found two ways. The first is the most 'Java':
// Setup values
val list = mutableListOf("1", "2", "3", ".", "4", ".")
val delim = "."
// Check if list is empty
val size = list.size - 1
if (size < 0) return
// Get first delim index
val firstMatch = list.indexOf(delim) + 1
if (firstMatch < 1) return
// Reverse-iterate the list until delim location
for (i in size downTo minOf(firstMatch, size)) {
if (list[i] == delim) list.removeAt(i)
}
println(list)
Here is smaller Kotlin-style solution:
val list = mutableListOf("1", "2", "3", ".", "4", ".")
val delim = "."
val firstMatch = list.indexOf(delim)
if (firstMatch < 0) return
val newList = list.filterIndexed { index, s -> s != delim || index == firstMatch }
println(newList)

Answer 3

The easy way to do this is using distinct() function, that returns a list without duplicated values
val list = listOf('1', '2', '3', '.', '4', '.')
println(list.distinct()) // [1, 2, 3, ., 4]

Answer 4

To remove these apply for loops and add the items in a new list.Steps
First Convert list into mutable list
val list = listOf("1", "2", "3", ".", "4", ".")
val mutablelist =list.toMutableList()
after this apply for loop and storing data in new Outcoming list
val outcominglist= ArrayList<String>()
for(i in list){
val item = mutablelist[0]
mutablelist.removeAt(0)
if(outcominglist.contains(item)){
}
else{
outcominglist.add(item)
}
}
To print Outcoming list.
print(outcominglist)
Second and the Simplest Method(Use .distinct Method)
val list = listOf('1', '2', '3', '.', '4', '.')
val newlist =list.distinct()
print(newlist)

Answer 5

Since you're using Kotlin, you have the advantage of immutable data types and functions without side-effects. Here's how to do it with an immutable list in a function that doesn't expose any state externally, by making use of fold():
val originalList = listOf("1", "2", "3", ".", "4", ".")
val (filteredList, _) = originalList.fold(
Pair(emptyList<String>(), false)
) { (newList, found), item ->
if (item == "." && !found) Pair(newList + item, true)
else if (item == ".") Pair(newList, true)
else Pair(newList + item, found)
}
println(filteredList)
Result:
[1, 2, 3, ., 4]
fold() takes an initial accumulator value, then applies the function for each element of list, updating the accumulator as it goes.
Here we set the accumulator to a Pair of an empty list, where we will build up the new list, and a boolean, to track if we've already seen ..
For each element of the original list, we return a new pair, adding the item to the new list (if necessary) and updating whether we have already seen .. newList + item doesn't add the item to the immutable list, it returns a new immutable list with the item appended to it. Because we pass the Bool tracking if we've seen . as part of the pair to each iteration, there's no need for a temporary variable outside the function to track this.
Finally, because the accumulated value is a Pair, we use destructuring to extract only the accumulated list (the first value) of the pair with val (filteredList, _) = pair.
For your list, the returned Pair values will look like this:
([1], false)
([1, 2], false)
([1, 2, 3], false)
([1, 2, 3, .], true)
([1, 2, 3, ., 4], true)
([1, 2, 3, ., 4], true)