将字节数组分为偶数和奇数字节数组并存储在文件中

Question

我正在按字节数组逐字节读取.pst（ 文件结构 ）文件，现在我想将数据分为偶数和奇数两部分，并将其存储在另外两个文件中，一个为偶数，另一个为奇数。 以下是我被困在的代码

        byte[] array = File.ReadAllBytes("PST_Sample.pst");
        for (int index = 0; index < even.Length; index++)
        {

            //Console.WriteLine(index + " : " + array[index]);
            if ((array[index] % 2) == 0)
            {
                even[index] = array[index];
            }
            else
            {
                odd[index] = array[index];
            }
        }

在FOR循环中，我尝试了array.length，even.length无效。

Answer 1

该array比even和odd组长两倍。
请尝试以下代码：

for (int index = 0; index < even.Length; index++)
{
    even[index] = array[index * 2];
    odd[index] = array[index * 2 + 1];
}

Answer 2

仅将源数组中的索引增加2，而将目标数组中的索引仅增加1。 这样，您就可以将字节分配给一堆中的odd和even数组，而无需其他的偶数/奇数测试。

for (int src = 0, dst = 0; src < array.Length; src += 2, dst++)
{
    even[dst] = array[src];
    odd[dst] = array[src + 1];
}

如果数组长度为奇数，则odd[]必须比even[] 。 另外，必须特别注意避免遇到索引超出范围的异常。

一个解决方案也适用于奇数数组长度，并避免在循环内进行其他测试：

byte[] array = { 0, 1, 2, 3, 4 };
bool isOdd = array.Length % 2 == 1;

byte[] even = new byte[(array.Length + 1) / 2];
byte[] odd = new byte[array.Length / 2];

int length = isOdd ? array.Length - 1 : array.Length;
for (int src = 0, dst = 0; src < length; src += 2, dst++) {
    even[dst] = array[src];
    odd[dst] = array[src + 1];
}

if (isOdd) { // If array length is odd, the last index is even (= length - 1).
    // Assign the last remaining entry.
    even[even.Length - 1] = array[array.Length - 1];
}

Answer 3

您的测试是错误的。 您正在测试数据中的字节，而不是索引。 它应该是：

 for (int index = 0; index < array.Length; index++)
    {

        //Console.WriteLine(index + " : " + array[index]);
        if ((index % 2) == 0)
        {
            even[index/2] = array[index];
        }
        else
        {
            odd[(index - 1)/2] = array[index];
        }
    }

Answer 4

如果您只是在寻找解决方案，而不必在寻找如何修复代码，那么最简单的方法就是使用LINQ。

byte[] array = new byte[] 
{
    55, 56, 57, 58, 89, 90, 91, 92
};
var even = array.Where((b, i) => i % 2 == 0);
var odd = array.Except(even);

如果需要even和odd作为byte[]则只需将.ToArray()添加到每一行。

如果您想将这些值重新交织在一起，则这是该方法的扩展方法（删除static方法，如果只需要常规方法，则删除this方法）。 我借用并修改了这个问题的可接受答案，即使在一个集合大于另一个集合时也可以使它交错。

public static IEnumerable<T> Interleave<T>(this IEnumerable<T> first, IEnumerable<T> second)
{
    using (var firstEnumerator = first.GetEnumerator())
    using (var secondEnumerator = second.GetEnumerator())
    {
        var firstMoved = firstEnumerator.MoveNext();
        var secondMoved = secondEnumerator.MoveNext();

        while (firstMoved || secondMoved)
        {
            if (firstMoved)
                yield return firstEnumerator.Current;
            if (secondMoved)
                yield return secondEnumerator.Current;

            firstMoved = firstEnumerator.MoveNext();
            secondMoved = secondEnumerator.MoveNext();
        }
    }
}

Answer 5

您的主数组的长度是结果两个数组的两倍。 您的代码中可能有2或3个设计错误，具体取决于您的数据是什么

第一个缺点是您同时对所有阵列使用相同的索引。 因此for对于偶数或奇数阵列，您在每次通过时都跳过一个存储单元，并且由于限制是偶数阵列的大小，因此您只能遍历主阵列的一半。

第二个缺陷是，根据数据，您可能需要为偶数和奇数数组设置不同的大小，因为如果您有46个奇数和20个偶数，则每个数组的大小仍然为33

第三缺陷 ，也许是最关键的：结合第一缺陷和第二缺陷，您肯定会获得超出范围的异常索引。 如果您有25个偶数和67个奇数，则由于您使用相同的索引，因此代码将一直工作到index >= 25为止，此时您将获得界外索引，因为偶数数组的最后一个索引为32。

我还建议您使用列表而不是数组，因为它们旨在存储任意数量的数据。

您可以通过以下方式编写代码来避免这些缺陷：

byte[] array = File.ReadAllBytes("PST_Sample.pst");
List<byte> even = new List<byte>();
List<byte> odd = new List<byte>();

for (int index = 0; index < array.Length; index++)
{
    if ((array[index] % 2) == 0)
    {
        even.Add(array[index]);
    }
    else
    {
        odd.Add(array[index]);
    }
}

File.WriteAllBytes("even_file.pst", even.ToArray());
File.WriteAllBytes("odd_file.pst", odd.ToArray());