Topquan's Blog

1.6   栈类Stack

　　Stack类是Vector类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。Stack类中提供了相应方法完成栈的有关操作。
　　基本方法：
　　public   Object   push(Object   Hem)
　　将Hem压入栈中，Hem可以是任何类的对象。
　　public   Object   pop()
　　弹出一个对象。
　　public   Object   peek()
　　返回栈顶元素，但不弹出此元素。
　　public   int   search(Object   obj)
　　搜索对象obj,返回它所处的位置。
　　public   boolean   empty()
　　判别栈是否为空。
　　例1.4   StackApp.java使用了上面的各种方法。
　　例1.4   StackApp.java。
　　import   java.lang.*;
　　import   java.util.*;
　　public   class   StackApp{
　　　public   static   void   main(String   args[]){
　　　　Stack   sta=new   Stack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//压入的为字符串对象
　　　　sta.push(new   Integer(2));
　　　　//压入的为Integer的对象，值为2
　　　　sta.push(new   Float(3.5));
　　　　//压入的为Float的对象，值为3.5
　　　　System.out.println("The   stack   is,"+sta);
　　　　//对应栈sta
　　　　System.out.println("The   top   of   stack   is:"+sta.peek());
　　　　//对应栈顶元素，但不将此元素弹出
　　　　System.out.println("The   position   of   object   Cherry   is:"
　　　　+sta.search("cherry"));
　　　　//打印对象Cherry所处的位置
　　　　System.out.print("Pop   the   element   of   the   stack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+"   ");
　　　　System.out.println();
　　　　//将栈中的元素依次弹出并打印。与第一次打印的sta的结果比较，可看出栈
　　　　//先进后出的特点
　　　}
　　}
　　运行结果(略)


1.7   哈希表类Hashtable

　　哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象，实现快速检索。
　　Java.util.Hashtable提供了种方法让用户使用哈希表，而不需要考虑其哈希表真正如何工作。
　　哈希表类中提供了三种构造方法，分别是：
　　public   Hashtable()
　　public   Hashtable(int   initialcapacity)
　　public   Hashtable(int   initialCapacity,float   loadFactor)
　　参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装载因子，是一个0.0到0.1之间的float型的浮点数。它是一个百分比，表明了哈希表何时需要扩充，例如，有一哈希表，容量为100，而装载因子为0.9，那么当哈希表90%的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。如果用户不赋这些参数，系统会自动进行处理，而不需要用户操心。
　　Hashtable提供了基本的插入、检索等方法。
　　插入
　　public   synchronized   void   put(Object   key,Object   value)
给对象value设定一关键字key,并将其加到Hashtable中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象Value。这表明在哈希表中相同的关键字不可能对应不同的对象(从哈希表的基本思想来看，这也是显而易见的)。
　　检索
　　public   synchronized   Object   get(Object   key)
　　根据给定关键字key获取相对应的对象。
　　public   synchronized   boolean   containsKey(Object   key)
　　判断哈希表中是否包含关键字key。
　　public   synchronized   boolean   contains(Object   value)
　　判断value是否是哈希表中的一个元素。
　　删除
　　public   synchronized   object   remove(object   key)
　　从哈希表中删除关键字key所对应的对象。
　　public   synchronized   void   clear()
　　清除哈希表
　　另外，Hashtalbe还提供方法获取相对应的枚举集合：
　　public   synchronized   Enumeration   keys()
　　返回关键字对应的枚举对象。
　　public   synchronized   Enumeration   elements()
　　返回元素对应的枚举对象。
　　例1.5   Hashtable.java给出了使用Hashtable的例子。
　　例1.5   Hashtalbe.java。
　　//import   java.lang.*;
　　import   java.util.Hashtable;
　　import   java.util.Enumeration;
　　public   class   HashApp{
　　　public   static   void   main(String   args[]){
　　　　Hashtable   hash=new   Hashtable(2,(float)0.8);
　　　　//创建了一个哈希表的对象hash，初始容量为2，装载因子为0.8

　　　　hash.put("Jiangsu","Nanjing");
　　　　//将字符串对象“Jiangsu”给定一关键字“Nanjing”,并将它加入hash
　　　　hash.put("Beijing","Beijing");
　　　　hash.put("Zhejiang","Hangzhou");

　　　　System.out.println("The   hashtable   hash1   is:   "+hash);
　　　　System.out.println("The   size   of   this   hash   table   is   "+hash.size());
　　　　//打印hash的内容和大小

　　　　Enumeration   enum1=hash.elements();
　　　　System.out.print("The   element   of   hash   is:   ");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+"   ");
　　　　System.out.println();
　　　　//依次打印hash中的内容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("The   capatial   of   Jiangsu   is   "+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//删除关键字Beijing对应对象
　　　　System.out.println("The   hashtable   hash2   is:   "+hash);
　　　　System.out.println("The   size   of   this   hash   table   is   "+hash.size());
　　　}
　　}

　　运行结果：
　　The   hashtable   hash1   is:   {Beijing=Beijing,   Zhejiang=Hangzhou,   Jiangsu=Nanjing}
　　The   size   of   this   hash   table   is   3
　　The   element   of   hash   is:   Beijing   Hangzhou   Nanjing
　　The   capatial   of   Jiangsu   is   Nanjing
　　The   hashtable   hash2   is:   {Zhejiang=Hangzhou,   Jiangsu=Nanjing}
　　The   size   of   this   hash   table   is   2

　　Hashtable是Dictionary(字典)类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在java.util中还有一个类Properties，它是Hashtable的子类。用它可以进行与对象属性相关的操作。

1.8   位集合类BitSet

　　位集合类中封装了有关一组二进制数据的操作。
　　我们先来看一下例8.6   BitSetApp.java。
　　例8.6   BitSetApp.java
　　//import   java.lang.*;
　　import   java.util.BitSet;
　　public   class   BitSetApp{
　　　private   static   int   n=5;
　　　public   static   void   main(String[]   args){
　　　　BitSet   set1=new   BitSet(n);
　　　　for(int   i=0;i<n;i++)   set1.set(i);
　　　　//将set1的各位赋1，即各位均为true
　　　　BitSet   set2=   new   BitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2为set1的拷贝
　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//将set1的第0位set2的第2位清零
　　　　System.out.println("The   set1   is:   "+set1);
　　　　//直接将set1转换成字符串输出，输出的内容是set1中值true所处的位置
　　　　//打印结果为The   set1   is:{1,2,3,4}
　　　　System.out.println("The   hash   code   of   set2   is:   "+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//调用打印程序printbit(),打印对象中的每一个元素
　　　　//打印set1的结果为The   bit   set1   is:   false   true   true   true   true
　　　　set1.and(set2);
　　　　printbit("set1   and   set2",set1);
　　　　//完成set1   and   set2,并打印结果
　　　　set1.or(set2);
　　　　printbit("set1   or   set2",set1);
　　　　//完成set1   or   set2,并打印结果
　　　　set1.xor(set2);
　　　　printbit("set1   xor   set2",set1);
　　　　//完成set1   xor   set2,并打印结果
　　　}
　　　//打印BitSet对象中的内容
　　　public   static   void   printbit(String   name,BitSet   set){
　　　　System.out.print("The   bit   "+name+"   is:   ");
　　　　for(int   i=0;i<n;i++)
　　　　　System.out.print(set.get(i)+"   ");
　　　　System.out.println();
　　　}
　　}

　　运行结果：
　　The   set1   is:   {1,   2,   3,   4}
　　The   hash   code   of   set2   is:   1225
　　The   bit   set1   is:   false   true   true   true   true
　　The   bit   set2   is:   true   true   false   true   true
　　The   bit   set1   and   set2   is:   false   true   false   true   true
　　The   bit   set1   or   set2   is:   true   true   false   true   true
　　The   bit   set1   xor   set2   is:   false   false   false   false   false

　　程序中使用了BitSet类提供的两种构造方法：
　　　　public   BitSet();
　　　　public   BitSet(int   n);
　　参数n代表所创建的BitSet类的对象的大小。BitSet类的对象的大小在必要时会由系统自动扩充。
　　其它方法：
　　public   void   set(int   n)
　　将BitSet对象的第n位设置成1。
　　public   void   clear(int   n)
　　将BitSet对象的第n位清零。
　　public   boolean   get(int   n)
　　读取位集合对象的第n位的值，它获取的是一个布尔值。当第n位为1时，返回true；第n位为0时，返回false。
　　另外，如在程序中所示，当把一BitSet类的对象转换成字符串输出时，输出的内容是此对象中true所处的位置。
　　在BitSet中提供了一组位操作，分别是：
　　public   void   and(BitSet   set)
　　public   void   or(BitSet   set)
　　public   void   xor(BitSet   set)
利用它们可以完成两个位集合之间的与、或、异或操作。
　　BitSet类中有一方法public   int   size()来取得位集合的大小，它的返回值与初始化时设定的位集合大小n不一样，一般为64。
小结
　　本章我们介绍了Java的实用工具类库java.util中一些常用的类。java.util包中还有其它一些类。它们的具体用法用户可以自行查阅API。  

ARRAYS

  package untitled4;
import java.util.*;
class compare implements Comparator
{
    public int compare(Object o1,Object o2)
    {  
        int i=((Person)o1).getFirstName().compareTo(((Person)o2).getFirstName());
        return (i!=0?i:((Person)o1).getLastName().compareTo(((Person)o2).getLastName()));
    }
}
class Person implements Comparable
{    private String firstName;
    private String lastName;
    public String getFirstName()
    {
      return firstName;
    }
    public String getLastName()
    {       return lastName;
    }
    public Person(String f,String l)
    {
       firstName=f;
       lastName=l;
    }
    public int compareTo(Object o)
    {   Person p=(Person)o;
        int l=firstName.compareTo(p.firstName);
       return (l!=0?l:(lastName.compareTo(p.lastName)));
    }
    public String toString()
    {
        return firstName+" "+lastName;
    }

}
public class ArrayTest {
    public ArrayTest() {
    }
public static void main(String args[])
    {
        int a[];
        a = new int[5];
        Arrays.fill(a, 5);   //用5填充数组
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        int b[] = {10, 3, 5, 6, 8, 9};
        Arrays.sort(b);
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
   
        Person p[] = {
                     new Person("John", "Lennon"),
                     new Person("Karl", "Marx"),
                     new Person("Groucho", "Marx"),
                     new Person("Oscar", "Grouch")
        };
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i]);
        }
   
        //Arrays.sort(p);
        Arrays.sort(p, new compare());
        for (int i = 0; i < p.length; i++) {
           System.out.println(p[i]);
       }

        int s = Arrays.binarySearch(p, new Person("Groucho", "Marx"), new compare());
        System.out.println(s);
        Person person[];
        person = new Person[4];
        System.arraycopy(p, 0, person, 0, p.length);
        for (int c= 0; c < person.length; c++)
        {
            System.out.println(person[c]);
   
        }
    }
}
当用Arrays的sort方法时,需要排序的数组必须实现Comparable借口.或者实现Comparator接口
Arrays的fill方法是用一个基本类型或者一个对象填充数组.
当调用binarySearch()时如果是调用sort(Objiec a[],Comparator a)时,,应调用相应的binarySearch(Object a[],Object value,Comparator)方法.
equals()方法用于比较非基本类型数组时,调用他们的equals方法..比如
  int a[]={5,4,3,2,1};
  int c[]={5,4,3,2,1};   基本类型比较他们的值,
  System.out.println(Arrays.equals(a,c));   TRUE
Integer a[]={new Integer(1),new Integer(2),new Integer(3)};
Integer b[]={new Integer(1),new Integer(2),new Integer(3)};
System.out.println(Arrays.equals(a,b));    调用Integer.equals()方法
对于没有覆盖Object equals方法的对象数组,他们之间比较的是对象的引用.
System.arraycopy()方法对与基本类型来说只是复制他们的值.而对于非基本类型时他们复制引用
  person person[]={new person("guo",20),new person("cher",21)};
         person per[]={new person("guo",20),new person("cher",21)};
       person []p=new person[2];
       System.arraycopy(person,0,p,0,person.length);
       System.out.println(person==p);     //输出   false
       person[1].setName("hao");
       System.out.println(person[1].equals(p[1]));   输出 true
       System.out.println(Arrays.equals(person,p));    输出   true
        System.out.println(Arrays.equals(person,per));   输出 false

对多态的理解

如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。
在例3-6中，父类对象a引用的是子类的实例，所以，java运行时调用子类B的callme方法。
importjava.io.*;
　　classA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideA'scallme()method");
　　　　　}
　　}
　　classBextendsA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideB'scallme()Method");
　　　　　}
　　}
　　publicclassDispatch{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　Aa=newB();
　　　　　　a.callme();
　　　　　}
　　}
方法重写时应遵循的原则：
　　1）改写后的方法不能比被重写的方法有更严格的访问权限（可以相同）。
　　2）改写后的方法不能比重写的方法产生更多的例外。