问在添加或删除项目时，保持初始列表项的顺序

EN

import org.junit.Test

class Fixing60945040 {

    private val originalItems = mutableListOf(
        201, 402, 952, 101, -54, 19
    )

    /**
     * a backup map of original items
     *
     * Why LinkedHashMap? HashMap works with access-order implementation.
     * Items do not keep insertion order in HashMap. So, inserting original
     * items will look like: 402, 19, 101, -54, 952, 201
     *
     * LinkedHashMap keeps insertion-order by default.
     *
     * Map<Int, Boolean> = (value, hidden)
     *
     * So, items like 201, 402 etc are keys for the map
     * and boolean tells us if this item is visible
     */
    private lateinit var backupMap: LinkedHashMap<Int, Boolean>

    /**
     * create a backup of original items
     */
    private fun createBackupMap(): LinkedHashMap<Int, Boolean> {

        val backupMap = LinkedHashMap<Int, Boolean>()
        for (item in originalItems) {
            backupMap[item] = true
        }
        return backupMap
    }

    private fun removeItem(item: Int) {
        println("Removing: $item")

        assert(originalItems.contains(item)) { "Can't remove an item that doesn't exist in the list." }

        // remove this value from original list
        val modified = originalItems.remove(item)
        if (modified) {
            // item was removed. Now, mark this item as hidden in the backup map
            backupMap[item] = false
        }
    }

    private fun insertItem(item: Int) {
        println("Inserting: $item")

        assert(!originalItems.contains(item)) { "Can't insert duplicate item." }
        assert(backupMap.containsKey(item)) { "Can't insert unknown new item." }

        // mark this item as visible in the backup map
        backupMap[item] = true

        // to know the insertion index, we need to iterate through
        // backup map
        var insertionIndex = 0
        for (entry in backupMap) {

            if (!entry.value /* !isVisible */ ) {
                /* not visible, this item is marked as hidden; ignoring */
                continue
            }

            // Is this key same as the item to be inserted?
            if (entry.key == item) {
                // It is. Insert the item.
                originalItems.add(insertionIndex, item)
                break
            } else {
                // It isn't, increase the index; check the next key.
                insertionIndex++
            }
        }
    }



    @Test
    fun test() {
        backupMap = createBackupMap()

        println("list: $originalItems \n")

        removeItem(952)
        removeItem(-54)
        println("list: $originalItems \n")

        removeItem(101)
        println("list: $originalItems \n")

        insertItem(-54)
        println("list: $originalItems \n")

        insertItem(101)
        println("list: $originalItems \n")

        insertItem(952)
        println("list: $originalItems \n")
    }
}