请问对一个对象标准输出，是默认后调用了对象的toString() 方法吗？但是

Question

但是 为什么会有如下输出
hashcode
hashcode
{hi56=mmmmyn, hi=jinglong}
package Map;import java.util.*;public class SimpleHashMap<K, V> extends AbstractMap<K, V>{
static final int SIZE=997;
LinkedList<MapEntry<K,V>>[] buckets=new LinkedList[SIZE];
public V put(K key, V value){
V oldValue=null;
boolean found=false;
int index=Math.abs(key.hashCode())%SIZE;

if(buckets[index]==null){
buckets[index]=new LinkedList<MapEntry<K, V>>();
}
LinkedList<MapEntry<K, V>> bucket=buckets[index];
MapEntry<K, V> pair=new MapEntry<K,V>(key,value);
ListIterator<MapEntry<K, V>> it=(ListIterator<MapEntry<K, V>>) bucket.listIterator();
while(it.hasNext()){
MapEntry<K, V> ipairs=it.next();
if(ipairs.getKey().equals(key)){
 oldValue=ipairs.getValue();
found=true;
it.set(pair);
break;
}
}
if(!found){
//System.out.println(index);
buckets[index].add(pair);

}
return oldValue;
}
@Override
public Set<Map.Entry<K, V>> entrySet() {
Set<Map.Entry<K,V>> set=new HashSet<Map.Entry<K,V>>();
for(LinkedList<MapEntry<K, V>> bucket:buckets){
if(bucket==null){continue;}
for(MapEntry<K,V> mpair:bucket){
set.add(mpair);
}
}
return set;
}

public static void main(String[] args){
SimpleHashMap<String, String> s=new SimpleHashMap<String, String>();
s.put("hi", "jinglong");
s.put("hi56", "mmmmyn");
System.out.println(s);


}}
package Map;
import java.util.*;
public class MapEntry<K,V> implements Map.Entry<K,V>{
private K key;
private V value;
public MapEntry(K key,V value){
this.key=key;
this.value=value;

}
@Override
public K getKey() { return key;
} @Override
public V getValue() {
// TODO Auto-generated method stub
return value;
} @Override
public V setValue(V v) {
V result =value;
value=v;
return result;
}
public int hashCode(){
System.out.println("hashcode");
return (key==null?0:key.hashCode())^(value==null?0:value.hashCode());
}
public boolean equals(Object o){
System.out.println("equals");
return true;
}
public String toString(){
return "sb";
}
public static void main(String[] args){
MapEntry m1=new MapEntry<Integer, Integer>(1, 1);
MapEntry m2=new MapEntry<Integer, Integer>(2, 1);
System.out.println(m1.equals(m2));
}}也就是说调用了MapEntry  里的int hashCode() 的方法这是什么意思   明白的解答一下

Answer 1

看看toString()方法是怎么写的你就知道了

Answer 2

Object对象的

Answer 3

输出对象时，确实是默认调用了对象的toString()方法，由于你的SimpleHashMap对象没有重写toString()方法，所以默认会调用父类的，也就是AbstractMap对象的toString()，代码如下：
public String toString() {
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (! i.hasNext())
            return "{}";        StringBuilder sb = new StringBuilder();
        sb.append('{');
        for (;;) {
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key);
            sb.append('=');
            sb.append(value == this ? "(this Map)" : value);
            if (! i.hasNext())
                return sb.append('}').toString();
            sb.append(',').append(' ');
        }
    }

Answer 4

是的，是默认调用toString()方法
这里有个非常有趣的现象：
如果你自己新建的类没有覆盖toString方法，也就是自己重写，那么默认的就是调用Object类的toString方法，所以显示的结果会是一个类名（没记错的话）加上@然后再是一串哈希码所以你自建类重写的话就会调用你自己的。建议这样写，貌似换平台方便点：
@Override
public String toString() {
String str = "";
str += number + "\t";
str += name + "\t";
str += price;
return str;

Answer 5

我自己总结了一下，明白了其 然不知其所以然。 各位老哥 说的不是不对 ，只不过对于我这道题来说不对。当然是我认为的，有大神指出错误也是极好的。
下面是我自己的看法。
首先我问的是 为什么输出s 即一个simplehash类型的对象会像4楼老哥说的那样调用父类tostring;但是却输出了2次hashcode;这就说明
在迭代的时候对于entrySet()返回的set中的俩个Entry对象都进行了int hashcode()调用。我是不明白这里 各位说的我略懂一点

Answer 6

真的希望有人说一下这个迭代器为什么会对迭代集合的元素进行哈希值计算？或者说是迭代器本身也算一个容器保遍历集合的元素的引用？为了防止重复元素的遍历而进行hash计算和equals判断？