Question

我需要能够从列表中删除项目并重新插入它们，同时保持相同的顺序。我的列表以初始的一组项目开始。无法插入新项目。因此，增加的项目和最大的项目数保持不变。

示例：

我的初始列表如下

0=201, 1=402, 2=952, 3=101, 4=-54, 5=0

如果我在2、4个位置上移走物品，我有

0=201, 1=402, 3=101, 5=0

但是，当我将已删除职位的项目添加回列表时； {2，4}，我有

0=201, 1=402, 3=101, 5=0, 2=952, 4=-54

我希望项目按初始顺序添加。即

0=201, 1=402, 2=952, 3=101, 4=-54, 5=0

它们必须按照被删除的原始顺序。这只是一个示例，无法对这些值进行排序。它们的顺序与添加顺序相同。

如果您建议使用原件的备用清单，如何确定当前清单的正确相邻位置？因此，如果原始列表有6个项目，并且值-54在4索引处。我从列表中删除了{2，3，4}个项目。新列表的大小更改为3。我无法将原始列表中4索引处的项目添加到4索引处的新列表中。新列表将只有{0，1，2}作为有效位置。此外，这甚至可能无法保持秩序。

问题是，如何删除元素并将其添加到列表中，并确保保持顺序？

还应该用LinkedList完成吗？如果是，怎么办？

编辑：原始列表是一个ArrayList。我无法修改此类型。当然，在确定正确的索引后，我需要从另一个集合中获取项目。

Answer 1

首先，但在Map <Index, Map<oldValue, NewValue>>中（请根据您的要求）获取原件的备份列表。如果您从ArrayList中删除任何项目，则在Map中将新值标记为null。

Answer 2

您可以使用地图来完成此操作（如果您的第一个数字是ID）...

Answer 3

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")
    }
}

如果有人发现任何性能改进，请发表评论。如果您认为有更好的方法，请添加答案。

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

3 个答案: