主页 / coding / 问题 / 78894219
Accepted
J B
Asked: 2024-08-21 03:59:36 +0800 CST

如何在列表中搜索 int[2] 的索引？

  • 772

因此，我正在尝试在列表中搜索 int[2] 的索引，但是运气不佳。

以下是我一直在使用的代码：

var coordinates = new List<int[]>();
coordinates.Add(new int[] { 1, 2 });
coordinates.Add(new int[] { 3, 4 });
coordinates.Add(new int[] { 5, 6 });

//foreach (int[] array in coordinates)
//{
//    Console.WriteLine(string.Join(", ", array));
//}

coordinates.AddRange(new int[3][] { [7, 8], [9, 10], [11, 12] });
foreach (int[] array in coordinates)
{
    Console.WriteLine(string.Join(", ", array));
}

//var index = coordinates.IndexOf([3,4]);
var index = coordinates.IndexOf(new int[] { 3, 4 });
Console.WriteLine(index);

上述两行 IndexOf 都返回了 -1 的值，因此我认为我的语法是错误的（或者我使用了错误的工具，这也是可能的）。有什么建议吗？

c#

6 个回答

  1. C# 中的数组是引用类型。当底层对象相同时，它们彼此相等。

    在您的代码中，您new在搜索匹配数组时使用关键字，这会创建新的底层数组对象，仅具有相同的元素，但底层是不同的对象。

    要正确找到具有所需项目的数组的索引，您可以先找到所需的数组（通过使用FirstOrDefault和SequenceEqual- 注意项目必须是按顺序才能工作），然后查找其索引，如下所示：

    var matchingArray = coordinates.FirstOrDefault(x => x.SequenceEqual(new int[] { 3, 4 }));
var index = coordinates.IndexOf(matchingArray);

    如果您使用 C# 12，则可以使用集合表达式：

    x.SequenceEqual([3, 4])
    • 2
  2. Best Answer

    IndexOf 方法不能直接作用于数组元素，因为它使用数组的 Equals 方法。该方法检查的是引用相等性，而不是内容相等性。因此，您需要手动比较数组的内容。

    因此，我更喜欢使用字符串来表示值，而不是使用 int 数组，这样可以轻松找到值的索引。

    using System.Collections.Generic;

var coordinates = new List<string>();
coordinates.Add("1,2");
coordinates.Add("3,4");
coordinates.Add("5,6");
coordinates.Add("7,8");
coordinates.Add("9,10");
coordinates.Add("11,12");

foreach (string item in coordinates)
{
    Console.WriteLine(item);
}

var _valueToSearch = "7,8";
var index = coordinates.IndexOf(_valueToSearch);
Console.WriteLine(index);

    另外，您可以尝试实现自己的搜索逻辑，如下所示：

    using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var coordinates = new List<int[]>();
        coordinates.Add(new int[] { 1, 2 });
        coordinates.Add(new int[] { 3, 4 });
        coordinates.Add(new int[] { 5, 6 });
        coordinates.AddRange(new int[3][] { new int[] { 7, 8 }, new int[] { 9, 10 }, new int[] { 11, 12 } });

        foreach (int[] array in coordinates)
        {
            Console.WriteLine(string.Join(", ", array));
        }

        var _valueToSearch = new int[] { 3, 4 };

        int index = FindIndex(coordinates, _valueToSearch);
        Console.WriteLine(index);
    }

    static int FindIndex(List<int[]> list, int[] valueToSearch)
    {
        for (int i = 0; i < list.Count; i++)
        {
            if (AreArraysEqual(list[i], valueToSearch))
            {
                return i;
            }
        }
        return -1; // Not found
    }

    static bool AreArraysEqual(int[] array1, int[] array2)
    {
        if (array1.Length != array2.Length)
        {
            return false;
        }

        for (int i = 0; i < array1.Length; i++)
        {
            if (array1[i] != array2[i])
            {
                return false;
            }
        }

        return true;
    }
}
    • 2

  3. 您尝试查找的是new数组的索引，而不是列表中的索引。如果您将数组分配给变量，它就会找到它。

    var yourArray = new int[] { 3, 4 };
coordinates.Add(yourArray);

//...

var index = coordinates.IndexOf(yourArray); //1
    • 1

  4. C# 中的数组相等是指它们是同一个数组，而不是它们具有相同的内容。您需要使用循环或使用 LINQ 方法扫描列表，例如list.First(x => x.SequenceEqual(needle))

    • 1 
  5. using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var coordinates = new List<int[]>();
        coordinates.Add(new int[] { 1, 2 });
        coordinates.Add(new int[] { 3, 4 });
        coordinates.Add(new int[] { 5, 6 });

        coordinates.AddRange(new int[3][] 
        {
            new int[] { 7, 8 }, 
            new int[] { 9, 10 }, 
            new int[] { 11, 12 } 
        });

        foreach (int[] array in coordinates)
        {
            Console.WriteLine(string.Join(", ", array));
         }

        var searchArray = new int[] { 3, 4 };
        var index = coordinates.FindIndex(arr => arr[0] == searchArray[0] 
&& arr[1] == searchArray[1]);
        Console.WriteLine(index); // This should now return the correct 
index.
    }
}
    • 1

  6. 由于您的列表称为坐标，因此我假设列表的所有数组始终都有 2 个元素。由于您的数组不仅仅是一些数字，而且具有实际含义，因此建议创建一个类：

    public class Coordinate
{
   public int X { get; set; }
   public int Y { get; set; }
}

    这是一个很大的改进，因为coordinates[0].Xor会比orcoordinates[0].Y更能告诉你代码中发生了什么。但是，正如其他答案所指出的那样，你仍然会遇到使用方法找到坐标的问题，因为你的坐标是引用类型。因此，明智的做法是实现并创建自己的比较：coordinates[0][0]coordinates[0][1]IndexOfIEquatable<Coordinate>

    public class Coordinate : IEquatable<Coordinate>
{
   public int X { get; set; }
   public int Y { get; set; }

   public bool Equals(Coordinate other)
   {
       return this.X == other?.X && this.Y == other?.Y;
   }

   public override bool Equals(object other)
   {
       return other is Coordinate coordinate && Equals(coordinate);
   }

   public override int GetHashCode()
   {
        return (X,Y).GetHashCode();
   }
   
   public  static bool operator ==(Coordinate left, Coordinate right)
   {
        if(left is null)
        {
            return right is null;
        }
        return left.Equals(right);
   }
   
   public  static bool operator !=(Coordinate left, Coordinate right)
   {
        return !(left == right);
    }
}

    如果您重写 Equals，您还必须重写 GetHashCode，即相等的对象也具有相同的哈希码。我刚刚计算了包含 X 和 Y 属性的值元组的哈希码。为了方便起见，我还重载了==and!=运算符。这意味着，您将能够执行类似的事情if(coord1 == coord2) { }。使用该类，您的代码将变为：

    var coordinates = new List<Coordinate>();
coordinates.Add(new Coordinate { X = 1, Y = 2 });
coordinates.Add(new Coordinate { X = 3, Y = 4 });
coordinates.Add(new Coordinate { X = 5, Y = 6 });
int index = coordinates.IndexOf(new Coordinate {X = 3, Y = 4});

    在线演示：https://dotnetfiddle.net/ZE7BLr

    • 0

相关问题