搜索List的最佳方法是什么 <List<string> &gt;？

Question

Say I have the following list:

List 1:
{{"John", "Doe", "Tall", "Old"},
{"John", "Doe", "Short", "Old"},
{"Jane", "Doe", "Tall", "Young"},
{"Jane", "Doe", "Short", "Old"}}

And I want to search the list for {"John", "Doe", "Short", "Old"}.

What is the best way to search for this nested list entry and ensure I don't get {"John", "Doe", "Tall", "Old"} instead?

If the nested list contained only one string item instead of four, I would use LINQ to flatten the list and search the resulting List<string>. ie:

List<string> newList = oldList.SelectMany(x => x).Distinct().ToList();
newList.Contains("string");

Is there something similar I can do for a list that contains more than one string item per each nested list?

Answer 1

So the list must contain all strings in that order? Then you can use Enumerable.SequenceEqual . If the order is not important use Enumerable.All with Contains , so:

var names = new[]{"John", "Doe", "Short", "Old"};
List<List<string>> result = list
    .Where(l => l.SequenceEqual(names)).ToList();

or

result = list
    .Where(l => l.All(name => names.Contains(name))).ToList();

Output:

foreach(List<string> l  in result)
    Console.WriteLine(string.Join(",", l));  // John,Doe,Short,Old

Demo

Side-note: you could make the second approach more efficient if you convert the collection you are searching to a HashSet<T> :

var names = new HashSet<string>(new[]{"John", "Doe", "Short", "Old"});
result = list.Where(l => l.All(names.Contains)).ToList();

As Servy has mentioned, the second approach does not prevent you from getting lists that contain all the items but also more. You could add a Count check to ensure it.

Answer 2

您可以使用允许传递自定义相等比较器（ IEqualityComparer<T> ）的Contains方法的重载版本。

Answer 3

One way of "flattening" the list would be as follows:

var people = list1.
    Select(lst => new {
        First  = lst[0]
    ,   Last   = lst[1]
    ,   Height = lst[2]
    ,   Age    = lst[3]
    });

Now you can search for containment as follows:

bool hasShortOldJohnDoe = people
    .Contains(p => p.First=="John"
                && p.Last=="Doe"
                && p.Height == "Short"
                && p.Age=="Old");

Answer 4

You can try the following:

List<List<string>> mainList = new List<List<string>>

{
    new List<string>(){"John", "Doe", "Tall", "Old"},
    new List<string>(){"John", "Doe", "Short", "Old"},
    new List<string>(){"Jane", "Doe", "Tall", "Young"},
    new List<string>(){"Jane", "Doe", "Short", "Old"},
};
List<string> searchList = new List<string>() { "John", "Doe", "Short", "Old" };

var temp = mainList[0].Except(searchList).Count();
List<List<string>> result  = mainList
                                .Where(r => r.Except(searchList).Count() == 0)
                                .ToList();

It will give you one item in the result .

Or:

var  result = mainList
                  .Where(r => !r.Except(searchList).Any());

Answer 5

Here is a couple of ways:

 [Test]
    public void Using_String_Join()
    {
        var l = new List<List<string>>
        {
            new List<string> {"John", "Doe", "Tall", "Old"},
            new List<string> {"John", "Doe", "Short", "Old"},
            new List<string> {"Jane", "Doe", "Tall", "Young"},
            new List<string> {"Jane", "Doe", "Short", "Old"}
        };

        var l2 = new List<string> {"John", "Doe", "Short", "Old"};

        Assert.That(l.Count(inner => string.Join(",", inner).Equals(string.Join(",", l2))), Is.EqualTo(1));
    }

    [Test]
    public void Using_SequenceEqual()
    {
        var l = new List<List<string>>
        {
            new List<string> {"John", "Doe", "Tall", "Old"},
            new List<string> {"John", "Doe", "Short", "Old"},
            new List<string> {"Jane", "Doe", "Tall", "Young"},
            new List<string> {"Jane", "Doe", "Short", "Old"}
        };

        var l2 = new List<string> {"John", "Doe", "Short", "Old"};

        Assert.That(l.Count(inner => inner.SequenceEqual(l2)), Is.EqualTo(1));
    }