按顺序选择所有元素的索引

本文关键字：元素 索引 顺序 选择 | 更新日期: 2023-09-27 18:11:47

使用LINQ，我可以写一个语句返回项目索引的IEnumerable吗?

非常简单的例子:

{1,2,4,5,3}

会返回

{0,1,2,3,4}

和

{1,2,4,5,3}.Where(num => num == 4)

回来
{2}

这不是确切的代码，但它应该能让你明白。

按顺序选择所有元素的索引

var a = new[] {1, 2, 4, 5, 3};
//** First, generates a simple sequence with {0,1,2,3,4} 
//** using the 2 parameter lambda select
var sequence1 = a.Select((_, index) => index);
//** Second, gets an array with all indexes where the value is 4.
// We need both value and index for the next line to work.
var sequence2 = a.Select((value, index) => new {value, index});
// Get all indexes where the value is 4
var indexArray = sequence2.Where(x => x.value == 4)
                          .Select(x => x.index).ToArray();

var numbers = Enumerable.Range(1,10).ToList();
int index = -1;
var indices = numbers.Select(x => i++).ToList();

如果您愿意稍微改变一下语法并使用扩展方法，则可以使用以下方法。我不喜欢它，因为它为每次调用创建一个新的序列。

var sequence = new[] { 1, 2, 4, 5, 3 };
sequence.Indexer().Select(num => num.Item1); // returns {0,1,2,3,4}
sequence.Indexer().Where(num => num.Item2 == 4).Select(num => num.Item1); // returns {2}
private static IEnumerable<Tuple<int, T>> Indexer<T>(this IEnumerable<T> sequence)
{
    return sequence.Select((x, y) => new Tuple<int, T>(y, x));
}

一个更好的方法是改变你写它的方式:

var sequence = new[] { 1, 2, 4, 5, 3 };
sequence.Select((num, index) => new { Num = num, Index = index }).Select(num => num.Index); // returns {0, 1,2,3,4}
sequence.Select((num, index) => new { Num = num, Index = index }).Where(num => num.Num == 4).Select(num => num.Index); // returns {2}

完整的索引集仅取决于项的数量，而不取决于值，因此您可以这样做:

IEnumerable<int> indices = Enumerable.Range(0, 5);

如果您处理的是IEnumerable<T>，您可以执行以下操作来获取与4匹配的项目的索引:

IEnumerable<int> values = new[] { 1, 2, 3, 4, 5 };
int indexOf4 = (
    values.Select((v, i) => new {v, i})
          .FirstOrDefault(vi => vi.v == 4) ?? new {v = 0, i = -1}).i;

这用于处理值源不包含匹配项(返回-1)的情况。

当然，如果您不介意将IEnumerable<T>转换为列表，那么您可以调用IndexOf:

int indexOf4a = values.ToList().IndexOf(4);

但是，我怀疑问题真正寻找的是找到所有索引与特定谓词匹配的值的方法。例如:

IEnumerable<int> big = values.Select((v, i) => new {v, i})
                             .Where(vi => vi.v > 3)
                             .Select (vi => vi.i);

返回值> 3: [3, 4]的索引。

如果谓词不匹配任何值，那么您将得到一个空的可枚举对象作为结果。

IEnumerable<int> seq = new[] { 1, 2, 4, 5, 3 };
// The indexes of all elements.
var indexes = Enumerable.Range(0, seq.Count());
// The index of the left-most element with value 4.
// NOTE: Will return seq.Count() if the element doesn't exist.
var index = seq.TakeWhile(x => x != 4).Count();
// The indexes of all the elements with value 4.
// NOTE: Be careful to enumerate only once.
int current_index = 0;
var all_indexes =
    from e in (
        from x in seq
        select new { x, Index = current_index++ }
    )
    where e.x == 4
    select e.Index;

你可以这样做:

public static IEnumerable<int> WhereIndices<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
    return source.Select(Tuple.Create<T, int>)
        .Where(z => predicate(z.Item1)).Select(z => z.Item2);
}

这是一个扩展方法，所以把它放在一个静态的非嵌套类中。像使用Where一样使用它，即:

.WhereIndices(num => num == 4)

应该可以了。但我不确定它的效率如何……

List<int> list = new List<int>()
{
    1,
    2,
    3,
    4,
    5
};
var indexes = list.Select(item => list.IndexOf(item));
var index = list.Where(item => item == 4).Select(item => list.IndexOf(item));
相关文章：