/**
 * Description:新建一個類作為map的key
 */
public class Groundhog
{
  protected int number;

  public Groundhog(){
  }
  public Groundhog(int number)
  {
    this.number = number;
  }

  @Override
  public String toString()
  {
    return "Groundhog{" + "number=" + number + '}';
  }
}

/**
 * Description:新建一個類作為map的value
 */
public class Prediction
{
  private boolean shadow=Math.random() > 0.5;

  @Override
  public String toString()
  {
    if (shadow) return "Six more weeks of Winter";
    else return "Early Spring!";
  }
}

/**
 * Description:測試類
 */
public class SpringDetector
{
  public static void detectSpring(Class grondHotClass) throws Exception{
    Constructor constructor = grondHotClass.getConstructor(new Class[]{int.class});
    Map map=new HashMap();
    for (int i=0;i<10;i++){
      map.put(constructor.newInstance(new Object[]{new Integer(i)}),new Prediction());
    }
    System.out.println("map="+map);

    Groundhog groundhog=(Groundhog)constructor.newInstance(new Object[]{new Integer(3)});
    System.out.println(groundhog);

    if (map.containsKey(groundhog)) {//查找這個key是否存在
      System.out.println((Prediction)map.get(groundhog));
    }else {
      System.out.println("key not find:"+groundhog);
    }

  }
  public static void main(String[] args)
  {
    try {
      detectSpring(Groundhog.class);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

/**
 * Description:首先新建一個類作為map中存儲的對象并重寫了hashCode()和equals()方法
 */
public class MPair implements Map.Entry,Comparable
{
  private Object key,value;

  public MPair(Object key,Object value)
  {
    this.key = key;
    this.value=value;
  }
  @Override
  public int compareTo(Object o)
  {
    return ((Comparable)key).compareTo(((MPair)o).key);
  }
  
  @Override
  public Object getKey()
  {
    return key;
  }

  @Override
  public Object getValue()
  {
    return value;
  }

   @Override
  public int hashCode()
  {
    int result = key != null ? key.hashCode() : 0;
    result = 31 * result + (value != null ? value.hashCode() : 0);
    return result;
  }

  @Override
  public boolean equals(Object o)
  {
    return key.equals(((MPair)o).key);
  }

  @Override
  public Object setValue(Object v)
  {
    Object result=value;
    this.value=v;
    return result;
  }
  
  @Override
  public String toString()
  {
    return "MPair{" + "key=" + key + ", value=" + value + '}';
  }

public class SimpleHashMap extends AbstractMap
{
  
  private static final int SZ=3;//定一個初始大小的哈希表容量
  private LinkedList[] linkedLists=new LinkedList[SZ];//建一個hash數組，用linkedList實現
  public Object put(Object key,Object value){
    Object result=null;
    int index=key.hashCode() % SZ;//對key的值做求模法求出index
    if (index<0) index=-index;
    if (linkedLists[index]==null) linkedLists[index]=new LinkedList();//如果這個index位置沒有對象，就新建一個

    LinkedList linkedList = linkedLists[index];//取出這個index的對象linkedList
    MPair mPair = new MPair(key,value);//新建要存儲的對象mPair
    ListIterator listIterator = linkedList.listIterator();
    boolean found =false;
    while (listIterator.hasNext()){//遍歷這個index位置的List,如果查找到跟之前一樣的對象(根據equals來比較)，則更新那個key對應的value
      Object next = listIterator.next();
      if (next.equals(mPair)){
        result = ((MPair) next).getValue();
        listIterator.set(mPair);//更新動作
        found=true;
        break;
      }
    }
    if (!found) linkedLists[index].add(mPair);//如果沒有找到這個對象，則在這index的List對象上新增一個元素。
    return result;

  }

  public Object get(Object key){
    int index = key.hashCode() % SZ;
    if (index<0) index=-index;
    if (linkedLists[index]==null) return null;
    LinkedList linkedList = linkedLists[index];
    MPair mPair=new MPair(key,null);//新建一個空的對象值，因為equals()的比較是看他們的key是否相等，而在List中的遍歷對象的時候，是通過key來查找對象的。
    ListIterator listIterator = linkedList.listIterator();
    while (listIterator.hasNext()){
      Object next = listIterator.next();
      if (next.equals(mPair)) return ((MPair)next).getValue();//找到了這個key就返回這個value
    }
    return null;

  }

  @Override
  public Set<Entry> entrySet()
  {
    Set set=new HashSet();
    for (int i=0;i<linkedLists.length;i++){
      if (linkedLists[i]==null) continue;
      Iterator iterator = linkedLists[i].iterator();
      while (iterator.hasNext()){
        set.add(iterator.next());
      }
    }
    return set;
  }

  public static void main(String[] args)
  {
    SimpleHashMap simpleHashMap=new SimpleHashMap();
    simpleHashMap.put("1", "1");
    simpleHashMap.put("2", "2");
    simpleHashMap.put("3","3");
    simpleHashMap.put("4","4");//這里有四個元素，其中key是1和key是4的index是一樣的，所以index為1的List上面存了兩個元素。
    System.out.println(simpleHashMap);
    Object o = simpleHashMap.get("1");
    System.out.println(o);
    Object o1 = simpleHashMap.get("4");
    System.out.println(o1);

  }
}