Java 为什么使用for循环会更改这个dictionary类的输出？

我基本上是在创建自己的Dictionary类，它作为堆栈工作。我可以将键值对（我自己创建的另一个类）放入字典中，字典将它们保存在一个数组中。当我通过逐行调整对put（）的每次调用来手动放置键值对时，效果很好。但是当我使用for循环时，它不能正常工作。如果我检查字典中是否有键，则使用for循环创建的字典返回false，使用另一个循环创建的字典返回true。两个字典都使用我创建的方法打印完全相同的内容。但是使用for循环创建的字典在使用方法时不会给出正确的输出

以下是主系统的代码：

有人知道这两本词典为什么不同吗

编辑：我的put（）代码如下

public class Dictionary implements Map<String, Integer> {

    private final static int INITIAL_CAPACITY = 10;
    private final static int INCREMENT = 5;
    private int count;

    Pair[] elems;

    public int getCount() {
      return count;
    }

    public int getCapacity() {
      return elems.length;
    }

    public Dictionary() {
        elems = new Pair[INITIAL_CAPACITY];
        count = 0;
    }

    @Override
    public void put(String key, Integer value) {
        Pair elem = new Pair(key, value);
        elems[count] = elem;
        count++;

        if (count == elems.length) {
          increaseCapacity();
        }

    }

    private void increaseCapacity() {
      Pair[] newElems = new Pair[count + INCREMENT];
      for (int i = 0; i < count; i++) {
        newElems[i] = elems[i];
      }
      elems = newElems;
    }

    @Override
    public boolean contains(String key) {
        for (int i = 0; i < count; i++) {
          if (elems[i].getKey() == key) {
            return true;
          }
        }
        return false;
    }

    @Override
    public Integer get(String key) {
      boolean got = false;
      Integer value = 0;

        for (int i = count - 1; i > - 1; i--) {
          if (elems[i].getKey() == key && !got) {
            value = elems[i].getValue();
            got = true;
          }
        }

        return value;

    }

    @Override
    public void replace(String key, Integer value) {
      Pair newPair;
      for (int i = count - 1; i > - 1; i--) {
        if (elems[i].getKey() == key) {
          newPair = new Pair(key, value);
          elems[i] = newPair;
        }
      }
    }

    @Override
    public Integer remove(String key) {
      Integer saved = null;
      boolean removed = false;
      for (int i = count - 1; i > - 1; i--) {
        if (elems[i].getKey() == key && !removed) {
          removed = true;
          saved = elems[i].getValue();
          elems[i] = null;
        }
      }

      return saved;
    }

    @Override
    public String toString() {
      String res;
      res = "Dictionary: {elems = [";
      for (int i = count-1; i >= 0 ; i--) {
          res += elems[i];
          if (i > 0) {
              res += ", ";
          }
      }
      return res +"]}";
    }

}

公共类字典实现映射{
专用最终静态int初始容量=10；
私有最终静态整数增量=5；
私人整数计数；
成对[]元素；
public int getCount（）{
返回计数；
}
公共int getCapacity（）{
返回元素长度；
}
公共词典（）{
elems=新对[初始容量]；
计数=0；
}
@凌驾
公共void put（字符串键，整数值）{
Pair elem=新对（键、值）；
元素[计数]=元素；
计数++；
如果（计数==元素长度）{
增加容量（）；
}
}
专用void增量容量（）{
Pair[]newElems=新的Pair[计数+增量]；
for（int i=0；i-1；i--）{
if（elems[i].getKey（）==key&&！get）{
value=elems[i].getValue（）；
got=true；
}
}
返回值；
}
@凌驾
公共void替换（字符串键，整数值）{
配对新配对；
对于（int i=count-1；i>-1；i--）{
if（elems[i].getKey（）==key）{
newPair=新对（键、值）；
元素[i]=新对；
}
}
}
@凌驾
公共整数删除（字符串键）{
整数保存=空；
布尔值=假；
对于（int i=count-1；i>-1；i--）{
if（elems[i].getKey（）==key&&！已删除）{
删除=真；
saved=elems[i].getValue（）；
元素[i]=null；
}
}
保存的返回；
}
@凌驾
公共字符串toString（）{
字符串res；
res=“字典：{elems=[”；
对于（int i=count-1；i>=0；i--）{
res+=elems[i]；
如果（i>0）{
res+=“，”；
}
}
返回res+“]}”；
}
}

---

Pair是我创建的另一个类，它只表示一个键值对。

好的，我重复一下您的问题

字典：

public class Dictionary {
    Map<String, Integer> map = new HashMap<>();

    public boolean contains(String key) {
        for(String mapKey : map.keySet()) {
            if(mapKey == key) {
                return true;
            }
        }
        return false;
    }
}

public static void main(String[] args) {
    Dictionary dict = new Dictionary();

    dict.map.put("X" + 0, 0);
    dict.map.put("X" + 1, 1);
    dict.map.put("X" + 2, 2);
    dict.map.put("X" + 3, 3);
    System.out.println(dict.contains("X2")); // true

    Dictionary dict2 = new Dictionary();
    for(int i=0; i<4; i++) {
        dict2.map.put("X" + i, i);
    }
    System.out.println(dict2.contains("X2")); // false
}

公共类字典{
Map Map=newhashmap（）；
公共布尔包含（字符串键）{
for（字符串mapKey:map.keySet（））{
if（mapKey==key）{
返回true；
}
}
返回false；
}
}

Main:

public class Dictionary {
    Map<String, Integer> map = new HashMap<>();

    public boolean contains(String key) {
        for(String mapKey : map.keySet()) {
            if(mapKey == key) {
                return true;
            }
        }
        return false;
    }
}

public static void main(String[] args) {
    Dictionary dict = new Dictionary();

    dict.map.put("X" + 0, 0);
    dict.map.put("X" + 1, 1);
    dict.map.put("X" + 2, 2);
    dict.map.put("X" + 3, 3);
    System.out.println(dict.contains("X2")); // true

    Dictionary dict2 = new Dictionary();
    for(int i=0; i<4; i++) {
        dict2.map.put("X" + i, i);
    }
    System.out.println(dict2.contains("X2")); // false
}

publicstaticvoidmain（字符串[]args）{
Dictionary dict=新字典（）；
dict.map.put（“X”+0,0）；
dict.map.put（“X”+1，1）；
dict.map.put（“X”+2,2）；
dict.map.put（“X”+3,3）；
System.out.println（dict.contains（“X2”）；//true
Dictionary dict2=新字典（）；
对于（int i=0；i为什么不打印这些值并查看它们是什么？我刚刚使用Hashmap制作了您的示例，它工作正常，因此字典实现中存在问题。请将此类的代码放入野生猜测：您的
字典
类使用
=
而不是使用
equals（）比较字符串
@RaV1oLLi我把你所有的字典类代码都放进去了，不仅仅是放方法我把它全部改成了.equals（），它还起作用了。你实现的这个映射来自java.util.map吗？因为在你的例子中，“放”方法应该返回整数，而不是voidNo。这些都是我自己创建的类