Question

我有几种方法可以做到这一点，但是我不确定它们是否是最佳实践，我只是想在继续之前就您对这个概念的想法。

基本上，我有一个JSON数组

 "new-samples": [ "Sample5", "Sample4", "Sample3", "Sample2", "Sample1" ]

示例的长度为5个项目，但是，如果我想添加一个项目，则我不希望数组的长度变为6个项目，而是希望其循环，就像这样-

添加1个项目：

 "new-samples": [ "Sample6", "Sample5", "Sample4", "Sample3", "Sample2" ]

添加2个项目

"new-samples": [ "Sample7", "Sample6", "Sample5", "Sample4", "Sample3" ]

所以我当前正在做的是反序列化，删除最后一个项目，将所有先前的项目设置为增加1，这使[0]为空以向其中添加新样本。我要么这样做，要么创建一个新数组，在[0]处添加新项目，然后从旧数组中获取项目[1] [2] [3] [4]并将其粘贴在新数组中。

这是我要求的示例代码：未经测试的

JObject lpl = JObject.Parse(lpljson);
JArray jarray = (JArray)lpl["new-samples"];
List<string> nlpl = new List<string>();
nlpl.Add(AppNameBox.Text);
foreach (var item in jarray)
{
   nlpl.Add(item.ToString());
}

nlpl.RemoveAt(5);
jarray.RemoveAll();
foreach (var item in nlpl)
{
   jarray.Add(item);
}

两者看上去都有点丑陋，有没有更快或更清洁的方式？

Answer 1

听起来您需要的是Queue。

代表对象的先进先出集合。

此类将队列实现为循环数组。对象存储在   队列插入一端，另一端删除。

Answer 2

正如另一个答案所述，在这种情况下，骑单车Queue可能很有意义，但是如果您需要以任何一种方式骑车，Linked List也会很有效。对于具有多个同时周期的非常大的馆藏（例如，学术性阵列自行车练习），也可以参加Array.Copy，付出一定的分配价格，并完全跳过迭代。

有很多方法可以实现这一目标，而最有效的算法取决于确切的用例和语言。

由于此帖子被标记为C＃，因此这是Queue的示例扩展方法，该方法将为您执行循环。假设仅通过此方法排队，则最大为O（n * 2），其中N是要添加的项目数，以及每当容量需要增加时就需要复制基础数组的时间（Queue被实现为循环数组）。对于预先了解总容量的逐项转移来说，它已经足够好了，因此您不会受到阵列调整的打击。但是，对于容量未知，班次计数未知的用例，可以采用更为有效的方法。

        /// <summary>
        /// Enqueues the given object.
        /// If the new queue size would be greater than <paramref name="capacity"/> then
        /// this method makes room for the new item by dequeueing until there is a spot.
        /// </summary>
        /// <typeparam name="T">The type of object to enqueue.</typeparam>
        /// <param name="queue">The queue to apply this extension on.</param>
        /// <param name="item">The object to enqueue.</param>
        /// <param name="capacity">
        /// The maximum queue capacity to enforce.
        /// If the new queue size would be greater than this value then items are dequeued until there is space for the new item.
        /// This value must greater than zero.
        /// </param>
        public static void Enqueue<T>(this Queue<T> queue, T item, int capacity)
        {
            if (queue == null) throw new ArgumentNullException(nameof(queue));
            if (capacity < 1) throw new ArgumentOutOfRangeException(nameof(capacity), capacity, $"Capacity is {capacity} but must be greater than zero.");

            // make room for the new item
            while (queue.Count > capacity - 1)
            {
                queue.Dequeue();
            }

            // enqueue the new item
            queue.Enqueue(item);
        }

上面所说的，阻碍效率的主要因素似乎是对JSON的完全反序列化和重新序列化。需要发生什么原因？

通过数组循环项目的最佳实践

2 个答案: