I have a string array defined in c# as
string[,] options = new string[100,3];
String[,] options = new string[80,3];
如果这是一个不规则数组，我会根据找到的第一组3个空值的位置来调整其大小。
如果这是一个不规则数组，我就会这样做：
options = options.Where(x => x != null).ToArray();
这个方法相对比较冗长，因为它需要检查每一行两次...
public static string[,] RemoveEmptyRows(string[,] strs)
{
int length1 = strs.GetLength(0);
int length2 = strs.GetLength(1);
// First we count the non-emtpy rows
int nonEmpty = 0;
for (int i = 0; i < length1; i++)
{
for (int j = 0; j < length2; j++)
{
if (strs[i, j] != null)
{
nonEmpty++;
break;
}
}
}
// Then we create an array of the right size
string[,] strs2 = new string[nonEmpty, length2];
for (int i1 = 0, i2 = 0; i2 < nonEmpty; i1++)
{
for (int j = 0; j < length2; j++)
{
if (strs[i1, j] != null)
{
// If the i1 row is not empty, we copy it
for (int k = 0; k < length2; k++)
{
strs2[i2, k] = strs[i1, k];
}
i2++;
break;
}
}
}
return strs2;
}
使用方法如下：
string[,] options = new string[100, 3];
options[1, 0] = "Foo";
options[3, 1] = "Bar";
options[90, 2] = "fiz";
options = RemoveEmptyRows(options);
正如Alexei所建议的，还有另一种方法可以做到这一点：
public static string[,] RemoveEmptyRows2(string[,] strs)
{
int length1 = strs.GetLength(0);
int length2 = strs.GetLength(1);
// First we put somewhere a list of the indexes of the non-emtpy rows
var nonEmpty = new List<int>();
for (int i = 0; i < length1; i++)
{
for (int j = 0; j < length2; j++)
{
if (strs[i, j] != null)
{
nonEmpty.Add(i);
break;
}
}
}
// Then we create an array of the right size
string[,] strs2 = new string[nonEmpty.Count, length2];
// And we copy the rows from strs to strs2, using the nonEmpty
// list of indexes
for (int i1 = 0; i1 < nonEmpty.Count; i1++)
{
int i2 = nonEmpty[i1];
for (int j = 0; j < length2; j++)
{
strs2[i1, j] = strs[i2, j];
}
}
return strs2;
}
if (j < length2) 而不是在跳出循环前将其添加到列表中呢？ - Grundy我遍历所有行，直到找到一个所有值都为null的行：
需要进行一些清理，并且显然会删除在第一个全null行之后出现的非null行。这里要求并不太清楚
编辑：刚看到评论澄清了删除所有空行的要求-我已经进行了微调，以避免获得负面评价，但已经有更全面和更高效的答案被接受了 :)
void Main()
{
string[,] options = new string[100,3];
options[0,0] = "bleb";
options[1,1] = "bleb";
options[2,0] = "bleb";
options[2,1] = "bleb";
options[3,2] = "bleb";
options[4,1] = "bleb";
string[,] trimmed = TrimNullRows(options);
Console.WriteLine(trimmed);
}
public string[,] TrimNullRows(string[,] options)
{
IList<string[]> nonNullRows = new List<string[]>();
for (int x = 0; x < options.GetLength(0); x++)
{
bool allNull = true;
var row = new string[options.GetLength(1)];
for (int y = 0; y < options.GetLength(1); y++)
{
row[y] = options[x,y];
allNull &= options[x,y] == null;
}
if (!allNull)
{
nonNullRows.Add(row);
}
}
var optionsTrimmed = new string[nonNullRows.Count, options.GetLength(1)];
for (int i=0;i<nonNullRows.Count;i++)
{
for (int j=0;j<options.GetLength(1);j++)
{
optionsTrimmed[i, j] = nonNullRows[i][j];
}
}
return optionsTrimmed;
}
使用linq的另一种变体
static string[,] RemoveNotNullRow(string[,] o)
{
var rowLen = o.GetLength(1);
var notNullRowIndex = (from oo in o.Cast<string>().Select((x, idx) => new { idx, x })
group oo.x by oo.idx / rowLen into g
where g.Any(f => f != null)
select g.Key).ToArray();
var res = new string[notNullRowIndex.Length, rowLen];
for (int i = 0; i < notNullRowIndex.Length; i++)
{
Array.Copy(o, notNullRowIndex[i] * rowLen, res, i * rowLen, rowLen);
}
return res;
}
你也可以获取一些帮助程序来在锯齿形和多维表示之间进行转换。当然，这很愚蠢，但对于像你展示的这样小的数组（以及非常稀疏的数组），这将是可以接受的。
void Main()
{
string[,] options = new string[100,3];
options[3, 1] = "Hi";
options[5, 0] = "Dan";
var results =
options
.JagIt()
.Where(i => i.Any(j => j != null))
.UnjagIt();
results.Dump();
}
static class Extensions
{
public static IEnumerable<IEnumerable<T>> JagIt<T>(this T[,] array)
{
for (var i = 0; i < array.GetLength(0); i++)
yield return GetRow(array, i);
}
public static IEnumerable<T> GetRow<T>(this T[,] array, int rowIndex)
{
for (var j = 0; j < array.GetLength(1); j++)
yield return array[rowIndex, j];
}
public static T[,] UnjagIt<T>(this IEnumerable<IEnumerable<T>> jagged)
{
var rows = jagged.Count();
if (rows == 0) return new T[0, 0];
var columns = jagged.Max(i => i.Count());
var array = new T[rows, columns];
var row = 0;
var column = 0;
foreach (var r in jagged)
{
column = 0;
foreach (var c in r)
{
array[row, column++] = c;
}
row++;
}
return array;
}
}
JagIt方法非常简单 - 我们只需迭代行，并yield出单个项。这给我们提供了一个可枚举的可枚举对象，我们可以在LINQ中很容易地使用它们。如果需要，您当然可以将它们转换为数组（例如，Select(i => i.ToArray()).ToArray()）。
UnjagIt方法有点啰嗦，因为我们需要首先创建具有正确维度的目标数组。而且没有unyield指令来简化它:D
当然，这非常低效，但这并不一定是问题。例如，通过将内部可枚举对象保持为array，可以节省一些迭代次数 - 这将使我们无需迭代所有内部项。
我主要将其保留为内存便宜、CPU密集型的替代方案，相对而言，@xanatos的方案则是内存密集、CPU便宜。
当然，主要的好处是它可以用于将任何多维数组视为分段数组，并将它们转换回来。通常，通用解决方案并不是最有效的:D
List<Tuple<string,string,string>>，或者是一个包含三个字符串属性的自定义类实例的列表。 - juharr