Java(2012/2/1)

二、Java集合接口，学习目标：a.理解Java集合框架  b.熟练使用java.util包中的相关类于接口进行编程开发 c.改善程序性能，今后进行程序编写时将大量使用集合类与相关接口

          Set：HashSe和TreeSet

           HashSet：

          1）当使用HashSet时，hashCode（）方法就会得到调用，判断已经存储在集合中的对象的hashCode值是否与增加对象的hashCode值一致；如果不一致，就直接放入HashSet中；如果一致，再进行equals方法比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。

          2）如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。

           这里有一个问题需要注意：如果需要把一个对象放入HashSet中，如果重写该对象对应类的equals方法，也应该重写其hashCode方法，其规则是：

           ①如果这两个对象通过equals方法比较返回true，两个对象的hashCode方法返回值也应该相同；

           ②如果两个对象通过equals方法比较返回ture，但这两个对象的hashCode方法返回不同的值，这将导致HashSet将会把这两个对象保存在HashSet中的不同位置；

           ③如果两个对象hashCode方法返回值相同，但通过equals比较返回为false时将更麻烦：因为两个对象的hashCode值相同，HashSet试图将他们保存在同一位置，但实际上又不行（否则只剩下一个对象），所以处理起来比较复杂；而且HashSet访问集合元素时也是根据元素的hashCode值来访问的，如果HashSet中包含两个元素有相同hashCode值，将会导致性能下降。

           注意：如果需要某个类的对象保存到HashSet集合中，重写这个类的equal（）方法和hashCode（）方法时，应尽量保证两个对象equals比较返回为true时，他们的hashCode返回值也相等。

          3）例题：有一个Person类（有个name（String类型）属性），如果Person的对象的名字相同，就不能加到HashCode当中

                public class People
                {
                            String name;
   
                            public People(String name)
                            {
                                        this.name = name;
                            }
   
                            public boolean equals(Object obj)
                            {
                                        if(this == obj)
                                        {
                                                 return true;
                                         }
 
                                         if(obj instanceof People)
                                         {
                                                 People people = (People)obj;
                                                 return this.name.equals(people.name);
                                         }
 
                                        return false;
                             }
   
                             public int hashCode()
                             {
                                       return this.name.hashCode();
                             }
               }

             4）iterator迭代器用法              

                   //iterator迭代器仅用于遍历集合，当使用Iterator对集合元素进行迭代时，Iterator并不是把集合元素本身传给了迭代变量，而是把集合元素的值传给了迭代变量，所以修改迭代变量的值对集合元素本身没有任何改变

                   HashSet set = new HashSet();

                   Iterator iter = set.iterator();

                   while(iter.hasNext())

                   {

                             String value = (String)iter.next();

                             System.out.println(value);

                    }

                  使用foreach方法遍历集合  //foreach循环中的迭代变量也不是集合元素本身，系统只是依次把集合元素的值赋给迭代变量，因此在foreach中修改迭代变量的值没有任何意义               

                TreeSet：

          1）实现自己的Comparator：自定义排序规则

                 按学生的成绩升序排列：

                 public class TreeSetTest implements Comparator
                 {
                           public int compare(Object o1, Object o2)
                           {
                                    Student s1 = (Student)o1;
                                    Student s2 = (Student)o2;
 
                                    if(s1.score > s2.score)
                                    {
                                               return 1;            //return -1  降序排列
                                    }
 
                                    else if(s1.score == s2.score)
                                    {
                                               return 0;
                                    }
 
                                    return -1;                      //return 1   降序排列
                             }
    
                   public static void main(String[] args)
                   {
                             TreeSetTest test = new TreeSetTest();
                             TreeSet tree = new TreeSet(test);
 
                             Student s1 = new Student(10);
                             Student s2 = new Student(20);
                             Student s3 = new Student(30);
                             Student s4 = new Student(40);
 
                              tree.add(s1);
                              tree.add(s2);
                              tree.add(s3);
                              tree.add(s4);
 
                              System.out.println(tree);
    
                        }
                 }

*Arrays类用来辅助数组用的，Collections类用来辅助集合的，用的时候再学

三、Map（映射）详解

        1）Map的keySet（）方法会返回key的集合，因为Map的键值是不能重复的，因此keySet（）方法的返回类型是Set；而Mpa的值是可以重复的，因此values（）方法的返回类型是Collection，可以容纳重复的元素。

        2）HashMap的两种遍历方式：

             ①HashMap map = new HashMap();

                map.put("1","zhangsan");
                map.put("2","lisi");
                map.put("3","wangwu");
                map.put("4","maliu");
 
                 Set set = map.keySet();
 
                 for(Iterator iter = set.iterator(); iter.hasNext();)
                 {
                            String key = (String)iter.next();
                            String value = (String)map.get(key);
     
                            System.out.println(key + " : " + value);
                 }

              ② HashMap map = new HashMap();
 
                   map.put("1","zhangsan");
                   map.put("2","lisi");
                   map.put("3","wangwu");
                   map.put("4","maliu");
 
                   Set set = map.entrySet();
 
                   for(Iterator iter = set.iterator(); iter.hasNext();)
                   {
                               Map.Entry entry = (Map.Entry)iter.next();
    
                               String value = (String)entry.getValue();
                               String key = (String)entry.getKey();
     

                               System.out.println(key + ":" + value);
                    }
             3）用TreeMap实现下面例题：随机生成50个数字（整数），每个数字的范围是[10,50]，统计每个数字出现的次数以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，如果某个数字出现次数为0，则不需要打印它，打印时按照数字的降序排列。

package com.xy3;

import java.util.Comparator;

public class TestComparator implements Comparator
{
    public int compare(Object o1, Object o2)
    {
 Integer t1 = (Integer)o1;
 Integer t2 = (Integer)o2;
 return -(t1.intValue() - t2.intValue());
    }
}

package com.xy3;

import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test
{
    public static void main(String[] args)
    {
 Map map = new TreeMap(new TestComparator());
 for(int i = 0; i < 50; i++)
 {
     int number = (int)(Math.random() * 41 + 10);
     Integer in = new Integer(number);
     if(map.get(in) == null)
     {
  map.put(in, new Integer(1));
     }
     else
     {
  Integer value = (Integer)map.get(in);
  value = new Integer(value.intValue() + 1);
  map.put(in, value);
     }
 }
 
 Set set = map.entrySet();
 for(Iterator iter = set.iterator(); iter.hasNext(); )
 {
     Map.Entry entry = (Map.Entry)iter.next();
     Integer key = (Integer)entry.getKey();
     Integer value = (Integer)entry.getValue();
     System.out.println(key.toString() + "出现次数：" + value.toString());
 }
 
 
 Integer max = (Integer)Collections.max(map.values());
 System.out.println("出现次数最多：" + max.intValue());
 
 for(Iterator iter = set.iterator(); iter.hasNext(); )
 {
     Map.Entry entry = (Map.Entry)iter.next();
     Integer key = (Integer)entry.getKey();
     Integer value = (Integer)entry.getValue();
     if(value.intValue() == max.intValue())
     {
  System.out.println(key.toString());
     }

 }
    }
}