通过数组循环项目的最佳实践[关闭]答案

【问题标题】：Best practice for cycling items through an array [closed]通过数组循环项目的最佳实践[关闭]
【发布时间】：2019-07-29 09:47:02
【问题描述】：

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

基本上，我有一个 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);
}

两者看起来都有点难看，有没有更快或更清洁的方法？

【问题讨论】：

在codereview 上发布您的完整工作解决方案，并在那里询问如何改进它。
我们至少需要看看您是如何反序列化数据的。您使用的结构类型（Array、List<T>、JArray 等）将决定给出什么建议。请注意，几乎所有结构都有在特定索引处插入元素的方法...
您可以为此使用 ArrayList：docs.microsoft.com/en-us/dotnet/api/…
@sinatr 检查我的编辑

标签： c# .net json uwp

【解决方案1】：

听起来你需要的是Queue。

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

此类将队列实现为循环数组。存储在 a 中的对象队列在一端插入并从另一端移除。

【讨论】：

不错，这正是我想要的。又好又干净！永远不会猜到会在我的搜索查询中寻找“队列”！

【解决方案2】：

正如另一个答案所述，在这种情况下，循环 Queue 可能有意义，但如果您需要以任何一种方式循环，Linked List 也可能很有效。对于具有多个同时循环的非常大的集合（例如学术数组循环练习），也可以选择Array.Copy，支付一些分配价格并完全跳过迭代。

有很多方法可以实现这一点，而最高效的算法取决于具体的用例和语言。

由于这篇文章被标记为 C#，这里有一个队列的示例扩展方法，它将为您执行循环。假设只有一个通过这种方法入队，它的最大值为 O(n*2)，其中 N 是要添加的项目数，再加上在容量需要增加时复制底层数组的时间（队列实现为循环数组）。对于预先知道总容量的逐项轮班来说，这足够好了，因此您不会受到阵列调整的影响。但是，对于容量未知和班次计数未知的用例，可以采取更有效的方法。

        /// <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 的完全反序列化和重新序列化。需要发生的原因是什么？

【讨论】：