删除常规数组的元素

我有一个Foo对象的数组。如何删除数组的第二个元素？删除常规数组的元素

我需要类似于RemoveAt()的东西，但对于一个常规数组。

2009-01-19 leora

使用`System.Collections.ObjectModel.Collection `。 – abatishchev 2009-01-19 12:46:27

对于我的游戏，我使用了“null at index”数据结构。基本上，内部数组（缓冲区）是静态大小，而不是删除索引和调整数组大小，我只是使索引为空。当我需要添加一个项目时，我只找到第一个非空索引并将其放在那里。工作得很好，但显然不适合所有事情。 – Krythic 2016-09-17 15:00:59

148

如果你不想使用List：

var foos = new List<Foo>(array); 
foos.RemoveAt(index); 
return foos.ToArray();

你可以试试，我没有实际测试过这种扩展方法：

public static T[] RemoveAt<T>(this T[] source, int index) 
{ 
    T[] dest = new T[source.Length - 1]; 
    if(index > 0) 
     Array.Copy(source, 0, dest, 0, index); 

    if(index < source.Length - 1) 
     Array.Copy(source, index + 1, dest, index, source.Length - index - 1); 

    return dest; 
}

而且使用它像：

Foo[] bar = GetFoos(); 
bar = bar.RemoveAt(2);

来源

2009-01-19 12:56:14

在此答案给出的第一个例子是比所述第二效率要低得多。它需要两个阵列副本和索引之后的所有内容，而不是一个选择性阵列副本。 – 2009-01-19 19:25:31

当然+1，但我们也可以用列表太升列表名单=新名单（GetFoos（））; list.Remove（my_foo）; list.RemoveAt（2）; GetFoos（）将返回Foos数组！ – shahjapan 2009-12-18 10:28:45

方法内的第一行应该说'source.Length'而不是'array.Length'。 – Nelson 2010-08-06 17:17:13

这里是我是如何做到的？

public static ElementDefinitionImpl[] RemoveElementDefAt(
     ElementDefinition[] oldList, 
     int removeIndex 
    ) 
    { 
     ElementDefinitionImpl[] newElementDefList = new ElementDefinitionImpl[ oldList.Length - 1 ]; 

     int offset = 0; 
     for (int index = 0; index < oldList.Length; index++) 
     { 
      ElementDefinitionImpl elementDef = oldList[ index ] as ElementDefinitionImpl; 
      if (index == removeIndex) 
      { 
       // This is the one we want to remove, so we won't copy it. But 
       // every subsequent elementDef will by shifted down by one. 
       offset = -1; 
      } 
      else 
      { 
       newElementDefList[ index + offset ] = elementDef; 
      } 
     } 
     return newElementDefList; 
    }

来源

2009-01-19 12:40:49

阵列的本质是它们的长度是不变的。您不能添加或删除任何数组项目。

您将不得不创建一个短一个元素的新数组，并将旧项目复制到新数组中，但不包括要删除的元素。

因此，最好使用List而不是数组。

来源

2009-01-19 12:41:11

阵列转换到列表`列表阵列=新列表（arrayofmydatatype）` – 2013-02-15 09:16:26

在普通数组中，您必须将所有大于2的数组输入进行混洗，然后使用Resize方法调整它的大小。使用ArrayList可能会更好。

来源

2009-01-19 12:41:15 gkrogers

这是一个旧版本，它适用于.NET框架的1.0版本，并且不需要generi c类型。

public static Array RemoveAt(Array source, int index) 
{ 
    if (source == null) 
     throw new ArgumentNullException("source"); 

    if (0 > index || index >= source.Length) 
     throw new ArgumentOutOfRangeException("index", index, "index is outside the bounds of source array"); 

    Array dest = Array.CreateInstance(source.GetType().GetElementType(), source.Length - 1); 
    Array.Copy(source, 0, dest, 0, index); 
    Array.Copy(source, index + 1, dest, index, source.Length - index - 1); 

    return dest; 
}

这用于这样的：

class Program 
{ 
    static void Main(string[] args) 
    { 
     string[] x = new string[20]; 
     for (int i = 0; i < x.Length; i++) 
      x[i] = (i+1).ToString(); 

     string[] y = (string[])MyArrayFunctions.RemoveAt(x, 3); 

     for (int i = 0; i < y.Length; i++) 
      Console.WriteLine(y[i]); 
    } 
}

来源

2009-01-19 15:30:01

我使用用于从一个对象数组移除元素此方法。在我的情况下，我的阵列长度很小。所以如果你有大阵列，你可能需要另一种解决方案。

private int[] RemoveIndices(int[] IndicesArray, int RemoveAt) 
{ 
    int[] newIndicesArray = new int[IndicesArray.Length - 1]; 

    int i = 0; 
    int j = 0; 
    while (i < IndicesArray.Length) 
    { 
     if (i != RemoveAt) 
     { 
      newIndicesArray[j] = IndicesArray[i]; 
      j++; 
     } 

     i++; 
    } 

    return newIndicesArray; 
}

来源

2010-12-12 18:42:39 EdHellyer

不完全相同的方式去了解这一点，但如果情况是琐碎和你珍惜你的时间，你可以尝试一下本作空类型。

Foos[index] = null

和更高版本检查逻辑中的空条目..

来源

2011-10-08 02:42:34 nawfal

-4

第一步
您需要将数组转换成列表，你可以这样写

// Convert An array of string to a list of string 
public static List<string> ConnvertArrayToList(this string [] array) { 

    // DECLARE a list of string and add all element of the array into it 

    List<string> myList = new List<string>(); 
    foreach(string s in array){ 
     myList.Add(s); 
    } 
    return myList; 
}

第二步
扩展方法写一个扩展方法来转换回列表到一个数组

// convert a list of string to an array 
public static string[] ConvertListToArray(this List<string> list) { 

    string[] array = new string[list.Capacity]; 
    array = list.Select(i => i.ToString()).ToArray(); 
    return array; 
}

最后的步骤
写下您的最后一个方法，但要记住转换回像代码阵列之前删除索引的元素显示

public static string[] removeAt(string[] array, int index) { 

    List<string> myList = array.ConnvertArrayToList(); 
    myList.RemoveAt(index); 
    return myList.ConvertListToArray(); 
}

例子代码可以在my blog被发现，保持跟踪。

来源

2012-04-17 12:27:56

这是删除一个数组元素，如净3.5的一种方式，而不会复制到另一个阵列 - 使用相同的阵列实例与Array.Resize<T>：

来源

2013-07-24 18:08:28 infografnet

像往常一样，我迟到了派对......

我想添加另一个选项到已经存在的很好的解决方案列表中。 =）
我认为这是扩展的好机会。

参考： http://msdn.microsoft.com/en-us/library/bb311042.aspx

所以，我们定义了一些静态类，并在其中，我们的方法。
之后，我们可以继续使用我们的扩展方法。 =）

using System; 

namespace FunctionTesting { 

    // The class doesn't matter, as long as it's static 
    public static class SomeRandomClassWhoseNameDoesntMatter { 

     // Here's the actual method that extends arrays 
     public static T[] RemoveAt<T>(this T[] oArray, int idx) { 
      T[] nArray = new T[oArray.Length - 1]; 
      for(int i = 0; i < nArray.Length; ++i) { 
       nArray[i] = (i < idx) ? oArray[i] : oArray[i + 1]; 
      } 
      return nArray; 
     } 
    } 

    // Sample usage... 
    class Program { 
     static void Main(string[] args) { 
      string[] myStrArray = { "Zero", "One", "Two", "Three" }; 
      Console.WriteLine(String.Join(" ", myStrArray)); 
      myStrArray = myStrArray.RemoveAt(2); 
      Console.WriteLine(String.Join(" ", myStrArray)); 
      /* Output 
      * "Zero One Two Three" 
      * "Zero One Three" 
      */ 

      int[] myIntArray = { 0, 1, 2, 3 }; 
      Console.WriteLine(String.Join(" ", myIntArray)); 
      myIntArray = myIntArray.RemoveAt(2); 
      Console.WriteLine(String.Join(" ", myIntArray)); 
      /* Output 
      * "0 1 2 3" 
      * "0 1 3" 
      */ 
     } 
    } 
}

来源

2014-01-02 17:03:35 Duncan

LINQ单行溶液：

myArray = myArray.Where((source, index) => index != 1).ToArray();

在实施例中的1是元素的索引，以除去 - 在这个例子中，每原来的问题，所述第二元件（其中1是C＃中基于零的数组索引的第二个元素）。

一个更完整的例子：

string[] myArray = { "a", "b", "c", "d", "e" }; 
int indexToRemove = 1; 
myArray = myArray.Where((source, index) => index != indexToRemove).ToArray();

运行的片段后，myArray值将是{ "a", "c", "d", "e" }。

来源

2014-09-11 18:00:35

private int[] removeFromArray(int[] array, int id) 
    { 
     int difference = 0, currentValue=0; 
     //get new Array length 
     for (int i=0; i<array.Length; i++) 
     { 
      if (array[i]==id) 
      { 
       difference += 1; 
      } 
     } 
     //create new array 
     int[] newArray = new int[array.Length-difference]; 
     for (int i = 0; i < array.Length; i++) 
     { 
      if (array[i] != id) 
      { 
       newArray[currentValue] = array[i]; 
       currentValue += 1; 
      } 
     } 

     return newArray; 
    }

来源

2015-06-21 21:06:02 user2884232

下面是我根据一些现有答案生成的一小组帮助方法。它利用两个扩展和静态方法与最大idealness参考参数：

public static class Arr 
{ 
    public static int IndexOf<TElement>(this TElement[] Source, TElement Element) 
    { 
     for (var i = 0; i < Source.Length; i++) 
     { 
      if (Source[i].Equals(Element)) 
       return i; 
     } 

     return -1; 
    } 

    public static TElement[] Add<TElement>(ref TElement[] Source, params TElement[] Elements) 
    { 
     var OldLength = Source.Length; 
     Array.Resize(ref Source, OldLength + Elements.Length); 

     for (int j = 0, Count = Elements.Length; j < Count; j++) 
      Source[OldLength + j] = Elements[j]; 

     return Source; 
    } 

    public static TElement[] New<TElement>(params TElement[] Elements) 
    { 
     return Elements ?? new TElement[0]; 
    } 

    public static void Remove<TElement>(ref TElement[] Source, params TElement[] Elements) 
    { 
     foreach (var i in Elements) 
      RemoveAt(ref Source, Source.IndexOf(i)); 
    } 

    public static void RemoveAt<TElement>(ref TElement[] Source, int Index) 
    { 
     var Result = new TElement[Source.Length - 1]; 

     if (Index > 0) 
      Array.Copy(Source, 0, Result, 0, Index); 

     if (Index < Source.Length - 1) 
      Array.Copy(Source, Index + 1, Result, Index, Source.Length - Index - 1); 

     Source = Result; 
    } 
}

在性能方面，它是体面的，但它很可能得到改善。Remove依靠IndexOf和要通过调用RemoveAt删除的每个元素创建一个新的阵列。

IndexOf是因为它并不需要返回原始数组的唯一扩展方法。 New接受某种类型的多个元素来产生一个新的这种类型的数组。所有其他方法必须接受原始数组作为参考，所以不需要在后面分配结果，因为这已经在内部发生了。

我已经定义了一个Merge方法用于合并两个阵列;然而，通过传递一个实际的数组与多个单独的元素，已经可以用Add方法完成。因此，Add可以通过以下两种方式来连接两个组元素：

Arr.Add<string>(ref myArray, "A", "B", "C");

或者

Arr.Add<string>(ref myArray, anotherArray);

来源

2017-04-23 15:14:00

删除常规数组的元素

回答

相关问题