集合类

       集合框架是一套用来创建集合类(collection class)的泛型.定义在java.util包中.

       集合类不过是诸如链表或下堆栈之类的方式组织一套给定类型的对象的类.

       术语集合描述的是一种代表一套聚集在一起且在内存中以特殊方式组织的对象! 

         定义集合对象的类被称为容器类(container class).集合有好多组织对象的方式,主要有三种类型的集合,称为集(set)、序列(sequence)、映射(map).

         集(set)是无序的且不能包含有重复对象的.

         序列(sequence)按先后顺序,可以有重复的元素.列表(list)和队列是序列的一个子群.

        映射(map)与上面两种迥然不同,映射中包含的是一对对象.有时也被称为字典(dictionary).每个对象都有一个与之相关联的键(key)对象.对象与它的键成对存储.要获取对象时,必须获取对应的键.

        还有种集合叫Bags，它是没有顺序且允许重复的。

       老师在上课的时候讲到hashCode()方法,也就是为对象生成散列码的方法!我当时为什么要有hashCode()这个方法,不过现在明白了!通过键确定映射中键/对象对的存储位置的过程被称为散列法(hashing).散列法对键对象进行处理,生成被称为散列码的整数值.

       迭代器(iterator)

      是按次序一个一个获取集合中所有对象的对象.包括三个方法:

      T next()                            从第一个对象开始返回类型为T的对象.

      boolean hasNext()       如果有下一个可调用next()方法获取对象就返回true

      void remove()               删除调用next()返回的最后一个对象,不是所有的迭代器都支持该方法

     例子:

     Myclass item;

      while(iter.hasNext()){

             item=iter.next();  

            //Do something with item...

     }

     也可以用collection-base for循环来替代迭代器,但是必须是这个集合实现了接口Iterable<>

课堂中讲的例子:

  策略模式:一个类用到的算法交个另一个类去实现...符合开闭原则!

( 开闭原则:尽量使用组合,避免使用继承,这样扩展性更好.)

  import java.util.*;
  public class TestTree
  { 
      public static void main(String[] args)
      {
       TreeSet ts = new TreeSet(new MyComparator());/*按下面定义的比较器进行比较

                                                                                                这就是设计模式之策略 模式.*/
       ts.add(new Person(33,160));
       ts.add(new Person(23,170));
       ts.add(new Person(45,180));
       Iterator it = ts.iterator();
       while(it.hasNext())
       {
        System.out.println (it.next());
       }
      }
  }
  
  class MyComparator implements Comparator//定义一个比较器类,实现Comparator接口.
  {
   public int compare(Object obj1,Object obj2)
   {
    Person p1 = (Person)obj1;
    Person p2 = (Person)obj2;
    return (p1.age > p2.age ? 1 : (p1.age == p2.age ? 0 : -1));
   }
  }

  class Person //implements Comparable
  {
   public int age;
   public int height;
   public Person(int age,int height)
   {
    this.age = age;
    this.height = height;
   }
   public String toString()
   {
    return (this.age + " : " + this.height);
   }
     
   //重写Comparable接口的compareTo方法
   /*
   public int compareTo(Object obj)
   {
    if(obj instanceof Person)
    {
     Person p = (Person)obj;
     return (this.height > p.height ? 1 : (this.height == p.height ? 0 : -1));
    }
    return 1;
   }*/
  }

 (2).
  import java.util.*;
  
  public class TestHashSet
  {
   public static void main(String[] args)
      {
       HashMap<String,String> hm = new HashMap<String,String>();
       hm.put("a","aaa");
       hm.put("b","bbb");
       hm.put("c","ccc");
       
       //第一种取值的方法
       Set s = hm.keySet();
       Iterator e = s.iterator();
       while(e.hasNext())
       {
        Object o = e.next();
        System.out.println (o + ":" + hm.get(o));
       }
       
       //第二种方法
       Set<Map.Entry<String,String>> ss = hm.entrySet();
       for(Map.Entry<String,String> me : ss)
       {
        System.out.println (me.getKey() + ":" + me.getValue());
       }
       
             
              
       //取出hs集合里面的对象

       /*Iterator<Student> itr = hs.iterator();
       while(itr.hasNext())
       {
        Student obj = itr.next();
        System.out.println (obj);
       }
       */
       
              
       //下面打印出两个Student对象的hashCode值，结果是相等的。
       //因为Student类里面重写了hashCode方法。
       System.out.println (new Student("zhangsan",19).hashCode());
       System.out.println (new Student("zhangsan",19).hashCode());
      }
  }
  
  class Student
  {
   private String name;
   private int age;
   
   public Student(String name,int age)
   {
    this.name = name;
    this.age = age;
   }
   
   //jdk1.5里面新增的标注：@Override指明要覆盖父类的方法,O是大写。
   @Override
   public boolean equals(Object obj)
   {
    if(obj instanceof Student)//判断obj是否属于Student类

    {
     Student stu = (Student)obj;
     return ((this.name.equals(stu.name)) && (this.age == stu.age));
    }
    return false;
   }
   
   public int hashCode()
   {
    return (this.age + this.name.hashCode());//注意基本数据类型没有散列码值。
   }
   
   public String toString()
   {
    return (this.name + ":" + this.age);  
   }
  }

对象池模型：

 设计一个ObjectPool类作为对象池，这个对象池内部负责创建和维护若干个Object对象，ObjectPool类初始创建
3个Object对象，如果它所维护的对象全部返回给了外面，则对象池创建新的Object对象返回给外部，总共最多
能维护10个Object对象，如果ObjectPool类内部维护的对象 已经达到10个，则抛出异常。ObjectPool类还提供了ReleaseObject方法，用于将先前提供给外部的一个Object对象还回到对象池中，它维护的未被外界使用的Object对象不超过5个。

public class ObjectPool {
      Vector idlePool=new Vector();
      Vector busyPool=new Vector();
      public ObjectPool(){
            idlePool.add(new Object());
            idlePool.add(new Object());
            idlePool.add(new Object());
      }
     public Object getObject(){
           if(busyPool.size>=10){//如果被外部使用的超过十个对象，则抛出异常
                  throw new Exception("out of max resource");
           }
          if(idlePool.size>0){//如果有空闲对象，则从最后一个起给外部调用
                 int index=idlePool.size-1;//从最后一个开始调用
                Object obj=idlePool.get(index);
                busyPool.add(obj);
               return obj;
         }
        Object newObj=new Object();//创建新的对象给外部调用
        busyPool.add(newObj);
        return newObj;
    }
 
 public void releaseObject(Object obj){
        if(busyPool.cotain(obj)){//判断是不是外部调用的对象
                busyPool.remove(obj); //如果是则移出，相当于使用过  
        }
        else{
              throw new Exception("isn`t my Object");
        }
        if(idlePool.size<5){
              idlePool.add(obj);
       }
       else{
             //obj.close() //如果是数据库连接池的话，这一步可关闭连接
      }
  }
}

模板方法设计模式
        父类的方法完成了业务流程,这个业务流程调用了其他的方法,其他的方法都是抽象的,由子类具体去完  成.AbstractSet类里面的removeAll()方法就是一个很典型的模板方法设计模式.