List和Set及Map用法(1)

本节主要是为了搞懂
1.为什么重写equals方法和hashcode的作用
2.ListIterator的使用
3.Set的不允许重复性的背后

首先新建一个实体类
package utilbag;

public class User {

private String user_id;
private String user_name;

public User(){

}

public User(String user_id,String user_name){
this.user_id=user_id;
this.user_name=user_name;
}


public String getUser_id() {
return user_id;
}

public void setUser_id(String user_id) {
this.user_id = user_id;
}

public String getUser_name() {
return user_name;
}

public void setUser_name(String user_name) {
this.user_name = user_name;
}

public String toString(){
return "[user_id"+user_id+",user_name="+user_name+"]";
}

//重写了equals方法
public boolean equals(Object obj){
                  if (this == obj) {
                            return true;
                  }
if(obj==null){
return false;
}
if(!(obj instanceof User)){
return false;
}
if(this.user_id==null || this.user_name==null){
return false;
}
User u=(User)obj;
return(this.user_id.equals(u.user_id) && this.user_name.equals(u.user_name));

}

//重写hansCode方法
public int hashCode(){
return this.user_id.hashCode()*this.user_name.hashCode();
}

/*String的hashCode()写法如下
  public int hashCode()
  {
    int i = this.hash;
    if (i == 0) {
      int j = this.offset;
      char[] arrayOfChar = this.value;
      int k = this.count;

      for (int l = 0; l < k; ++l) {
        i = 31 * i + arrayOfChar[(j++)];
      }
      this.hash = i;
    }
    return i;
  }
   */
}

//新建测试类
package utilbag;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

public class TestUtil {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//List序列的用法
System.out.println("/***************测试List的用法*****************************/");
List<String> list=new ArrayList<String>();
list.add("100");
list.add("200");
list.add("300");
/***************Iterator单项向前遍历*****************************/
Iterator<String> itera=list.iterator();
while(itera.hasNext()){
System.out.println(itera.next());
}
/***************ListIterator双向遍历*****************************/
ListIterator<String> ite=list.listIterator(2);//从第3个开始遍历
/***************向后遍历*****************************/
while(ite.hasNext()){
System.out.println(ite.next());//指下一个元素
System.out.println(ite.nextIndex());//指下一个元素的下标
}
/***************向前遍历*****************************/
while(ite.hasPrevious()){
System.out.println(ite.previous());//指前一个元素
System.out.println(ite.previousIndex());//指上一元素的下标
}


//Set的用法
System.out.println("/***************测试Set的用法*****************************/");
Set<String> set=new HashSet<String>();
set.add("1");
set.add("2");
set.add("1");//重复的元素不会加到set集合中,加入的对象必须事先hashcode
set.add("3");
Iterator<String> it=set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//打印出：3，2，1这3个元素
Set<User> su=new HashSet<User>();
User u1=new User("1","光光");
System.out.println(u1.hashCode());
su.add(u1);
User u2=new User("2","明明");
su.add(u2);
User u3=new User("3","天天");
su.add(u3);
User u4=new User("3","天天");
su.add(u4);
//注意不重写hashcode的方法则结果会是4个user，重写了hashcode方法，加到set中的结果是3条。//这个就是set容器不允许重复的实现方法
System.out.println("u3.hashCode()="+u3.hashCode());
System.out.println("u4.hashCode()="+u4.hashCode());
System.out.println("u3==u4结果为："+(u3==u4));//不一样是因为他们的地址是不一样的
//在HashMap HashSet中,hashCode()是判断放进容器里的两个对象是否相等的依据。
//如果自己写容器，那就修改覆写改方法
System.out.println("u3.equals(u4)结果为："+(u3.equals(u4)));
/**********怎么会都不相等呢，试试重写他们的equals和hashcode看看************/

Iterator<User> ituser=su.iterator();
while(ituser.hasNext()){
User uu=(User)ituser.next();
System.out.println(uu.hashCode());
System.out.println(uu);
}

String s="hello";
String s1=s;
String s2=s;
System.out.println("s1==s2:"+(s1==s2));

System.out.println("/***************测试Map的用法*****************************/");
Map<String, String> map=new HashMap<String, String>();
map.put("100", "100");
map.put("100", "200");
map.put("200", "300");
map.put("300", "400");
map.put("400", "500");
Iterator<String> imap=map.keySet().iterator();
while(imap.hasNext()){
String k=imap.next();
System.out.println(map.get(k));
//打印出来的值为400、300、500、200（无序）说明map不允许有重复的键（值可以重复）
}
map.clear();
map.put("100", "100");
map.put("500", "500");
map.put("200", null);
map.put("300", null);
map.put("400", null);
Iterator<String> iimap=map.keySet().iterator();
while(iimap.hasNext()){
String k1=iimap.next();
System.out.println(map.get(k1));
//System.out.println(iimap.get(k1));
//打印出来的值为null,null,null,100,500（无序）说明map不允许有重复的键（值可以重复,而且可以为null）
}

Iterator<Entry<String, String>> ie=map.entrySet().iterator();
while(ie.hasNext()){
Map.Entry<String, String> mp=ie.next();
System.out.println(mp.getKey()+":"+mp.getValue());
//打印出来
//300:null
//200:null
//400:null
//100:100
//500:500
}
map.clear();
map.put(null, null);
map.put(null, null);
map.put("100", "2");
map.put("100", null);
Iterator ie1=map.entrySet().iterator();
while(ie1.hasNext()){
Map.Entry<String, String> mpp=(Map.Entry<String, String>)ie1.next();
System.out.println(mpp.getKey()+":"+mpp.getValue());
//打印出来只有一个null:null,100:null因为它覆盖了前面的100:2
//键值不允许重复
}

}

}


总结：

1.在HashMap HashSet中,hashCode()是判断放进容器里的两个对象是否相等的依据。如果自己写容器，那就修改覆写改方法 。

2.判断2个对象相等是看2个对象的地址是否相等。

3.判断2个对象相等必须同时重写equals方法和hashcode方法。例如像set中添加2个user对象，缺少2个方法中的任何一个都不可以。

4.看java源码发现，

当new 一个set时，它是在构造函数中new一个map（它的实现是基于map的）
调用set的add方法时，传过去的值是调用的是map的put方法
put(set的值当作键，new object()当作值);

put时，它使用到了hashcode和equals方法
源码如下：


set中：
public HashSet()
  {
    this.map = new HashMap();
  }

  public boolean add(E paramE)
  {
    return (this.map.put(paramE, PRESENT) == null);
  }

map中：

public V put(K paramK, V paramV)
  {
    if (paramK == null)
      return putForNullKey(paramV);
    int i = hash(paramK.hashCode());
    int j = indexFor(i, this.table.length);
    for (Entry localEntry = this.table[j]; localEntry != null; localEntry = localEntry.next)
    {
      Object localObject1;
      if ((localEntry.hash == i) && ((((localObject1 = localEntry.key) == paramK) || (paramK.equals(localObject1))))) {
        Object localObject2 = localEntry.value;
        localEntry.value = paramV;
        localEntry.recordAccess(this);
        return localObject2;
      }
    }

    this.modCount += 1;
    addEntry(i, paramK, paramV, j);
    return null;
  }

现在我们知道了为什么set是不允许要加入的元素重复的了，而且要加入set的元素必须是重写了hashcode和equals，否则不能实现限制重复添加元素的功能（即set的本质，当然主要是对对象类型来说的）。