C# 如何解决字典中的相同键

本文关键字：字典 何解决 解决 | 更新日期: 2023-09-27 18:30:17

该程序将值及其其他值添加到字典中，一切都很好，直到有相同的键（var eat（.8）和var extra（.8）具有不同的值。 如何确保每次都能使用正确的密钥，即使它们相似？例如，var 示例 = gigantDictionary[.8]（但我想要代码中的 var edmg 值而不是"500"？

var wqat = 1.1;  //| index 0
var rat = .2;    //| index 1
var eat = .8;    //| index 2
var baat = 1.2;  //| index 3
var extra = .8;  //| index 4

var wqdmg = 120; //| index 0
var rdmg = 60;   //| index 1
var edmg = 50;   //| index 2
var badmg = 40;  //| index 3
var extradmg = 500; //| index 4

List<double> theOneList = new List<double>();
List<double> damageList = new List<double>();
theOneList.Add(wqat);
theOneList.Add(rat);
theOneList.Add(eat);
theOneList.Add(baat);

damageList.Add(wqdmg);
damageList.Add(edmg);
damageList.Add(rdmg);
damageList.Add(badmg);
Dictionary<double, double> gigantDictionary = new Dictionary<double, double>();

for (int i = 0; i < theOneList.Count; i++)
{
    gigantDictionary.Add(theOneList[i], damageList[i]);
    gigantDictionary.Add(extra, 500); //this is the malignant similar key

}
 theOneList.Sort((c, p) => -c.CompareTo(p)); //orders the list
List<double> finalList = new List<double>(); 
 for (int i = 0; i < theOneList.Count; i++)
        {
            finalList.Add(gigantDictionary[theOneList[i]]); //grabs damage values and add's it to 'finalList'
           Console.WriteLine(finalList[i]);
        }

所以最终，我想按血统排序"theOneList"，这样我就可以从"gigantDictionary"获得损害并将其放入"finalList"中，现在我有一个我需要的有序损害列表，但由于 2 键相似......这阻碍了我。

*编辑：相同的索引可能是关键吗？ 是桥梁？ 例如，在索引 0 中，我得到 1.1 和 120，也许答案在于相同的索引，我想从"1.1"获得"120"伤害，注意两者都有索引 0，这可能有效

C# 如何解决字典中的相同键

它们的键不是"相似"的，而是"相同的"。 如果键只是"相似"，那么就字典而言，它与"完全不同"没有什么不同。 从字典的角度来看，项目要么相等，要么不相等。

例如

var example = gigantDictionary[.8]

（但我想要代码中的 var edmg 值而不是"500"？

但是字典怎么可能知道呢？ 它怎么知道你是否真的想得到 500？

是否要防止添加重复的键，而是始终使用与每个键配对的第一个值？ 如果是这样，只需在添加新密钥之前检查密钥是否存在。

如果存在重复项，是否只想获取与键关联的所有值？ 然后有一个字典，其中的值是一个集合，并将与该键关联的所有值添加到集合中。

实际上

有没有办法区分键，使它们实际上并不相同？ 然后这样做。 只有一个双精度（首先用作字典的键是一个非常糟糕的类型，因为浮点舍入错误很容易导致您认为等效的相似但不同的双精度）没有好方法可以做到这一点，但是如果您的实际键可以以区分两个键的方式不同， 然后每个都可以指向一个唯一的值。

现在，您有两个单独的值列表，必须放在一起。更好的方法是创建一个具有两个值的结构并保留单个列表。

public class Thing
{
    public string Name { get; set; }
    public double TheOne { get; set; }
    public double Dmg { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        List<Thing> list=new List<Thing>() {
            new Thing() { Name = "wq", TheOne = 1.1, Dmg=120 },
            new Thing() { Name = "r", TheOne = 0.2, Dmg=60 },
            new Thing() { Name = "e", TheOne = 0.8, Dmg=50 },
            new Thing() { Name = "ba", TheOne = 1.2, Dmg=40 },
            new Thing() { Name = "extra", TheOne = 0.8, Dmg=500 },
        };
        list.Sort((t1, t2) => t1.TheOne.CompareTo(t2.TheOne));
        double[] dmg_list=list.Select((t) => t.Dmg).ToArray();
    }
}

编辑 1

要Thing的构造函数可用于通过一个操作分配值。

public class Thing
{
    // Constructor sets all the values
    public Thing(string name, double theone, double dmg)
    {
        this.Name=name;
        this.TheOne=theone;
        this.Dmg=dmg;
    }
    public string Name { get; private set; }
    public double TheOne { get; private set; }
    public double Dmg { get; private set; }
}
class Program
{
    static void Main(string[] args)
    {
        List<Thing> list=new List<Thing>();
        list.Add(new Thing("wq", 1.1, 120));
        list.Add(new Thing("r", 0.2, 60));
        list.Add(new Thing("e", 0.8, 50));
        list.Add(new Thing("ba", 1.2, 40));
        list.Add(new Thing("extra", 0.8, 500));

        list.Sort((t1, t2) => t1.TheOne.CompareTo(t2.TheOne));
        double[] dmg_list=list.Select((t) => t.Dmg).ToArray();
    }
}
相关文章：