基于文本的应用

程序交互的几种方式
程序在运行的时候，我们要给程序输入数据，程序根据输入的数据作出响应。
常见的输入方式有：
n    命令行参数
n    系统属性
n    标准的输入
n    在程序中实现文件的创建，读，写

常用类方法说明
Math类是用来支持数学计算的，它打包在java.lang包中，包含一组静态方法和两个常数，是终态（final）的，它不能被实例化。它主要包括下列方法：
分割
     int ceil(double d)：返回不小于d的最小整数。
     int floor(double d)：返回不大于d的最大整数。
     int round(float f) ：返回最接近f的整数（int）。
     long round(double d) ：返回最接近d的整数（long）。
极值、绝对值
     double abs(double d)：返回d的绝对值。对于float,int,long有类似的函数。
     double min(double d1, double d2) ：返回d1与d2中的小者。对于float,int,long有类似的函数。
     double max(double d1, double d2) ：返回d1与d2中的大者。对于float,int,long有类似的函数。
三角函数
     double sin(double d)：返回d正弦。对于余弦和正切有类似的函数cosine,tangent。
     double asin(double d)：返回d反正弦。对于反余弦和反正切有类似的函数acos,atan。
     double toDegrees(double r):将弧度换算成度。
     double toRadians(double d):将度换算成弧度。
对数、指数
     double log(double d)：返回d的自然对数。
     double exp(double d)：返回以e为底的指数。
其它函数
     double sqrt(double d)：返回d的平方根。
     double pow(double d1, double d2)：返回d1的d2次幂。
     double random()：返回0 至 1 的随机数。
常数
     PI：圆周率，double。
     E：自然对数的底，double。
String的方法
String concat(String s)：返回一个新的String，即，在原来的String后面追加上s。
String replace(String old, String new)：返回一个新的String，将原来的String中的old替换成new。
String substring(int start, int end)：返回一个新的String，它是原来的String中从start到end的一部分。
String toLowerCase()：返回一个新的String，它将原来的String中的大写字母变成小写。
String toUpperCase()：返回一个新的String，它将原来的String中的小写字母变成大写。
查找方法
boolean endsWith(String s)：如果原来的String以s为结尾，则返回true。
boolean startsWith(String s) ：如果原来的String以s为开始，则返回true。
int indexOf(String s)：返回String中第一次出现s偏移量。类似有lastindexOf，从串尾开始查找。
int indexOf(int ch)：返回String中第一次出现ch偏移量。类似有lastindexOf，从串尾开始查找。
int indexOf(String s, int offset)：返回String中从offset开始查找，第一次出现s的偏移量。类似有lastindexOf，从串尾开始查找。
int indexOf(int ch, int offset) 返回String中从offset开始查找，第一次出现ch的偏移量。类似有lastindexOf，从串尾开始查找。
比较方法
boolean equals(String s)：如果原String与s逐字符比较都相等，则返回true。
boolean equalsIgnoreCase(String s)：如果在忽略大小写的情况下，原String与s逐字符比较都相等，则返回true。
int  compareTo(String s)：进行词汇比较，如果原String 小于s则返回负数；如果原String 大于s则返回正数；如果原String 等于s则返回零。
其它方法
char charAt(int index)：返回index处的字符。
int length()：返回String的长度。
正则表示式（Regular expression）
正则表示式的功能是J2SE 1.4之后加入的新功能。String的matches()、replaceAll()等方法，所传入的参数就是正则表示式（Regular expression）的字符串；可以在API文件的 java.util.regex.Pattern 类中找到有关正则表示式的相关信息。

如果您使用String类定义字符串对象，可以使用简易的方法来使用正则表示式，并应用于字符串的比较或替换等方法中，以下先介绍几个简单的正则表示式。

例如一些常用的范围，我们可以使用预先定义的字符类别：
.  表示任一字符  
\d  表示 [0-9] 数字  
\D  表示 [^0-9] 非数字  
\s  表示 [ \t\n\x0B\f\r] 空格符  
\S  表示 [^ \t\n\x0B\f\r] 非空格符  
\w  表示 [a-zA-Z_0-9] 数字或是英文字  
\W  表示 [^a-zA-Z_0-9] 非数字与英文字  
. 表示任一字符。例如有一字符串abcdebcadxbc，使用.bc来比对的话，符合的子字符串有abc、ebc、xbc三个。
以上的例子来根据字符比对，您也可以使用「字符类」（Character class）来比较一组字符范围，例如：
[abc]  a、b或c  
[^abc]  非a、b、c的其它字符  
[a-zA-Z]  a到z或A到Z（范围）  
[a-d[m-p]]  a到d或m到p（联集）  
[a-z&&[def]]  d、e或f（交集）  
[a-z&&[^bc]]  a到z，除了b与c之外（差集）  
[a-z&&[^m-p]]  a到z且没有m到p（a-lq-z）（差集）

可以指定字符可能出现的次数：
X?  X出现一次或完全没有  
X*  X出现零次或多次  
X+  X出现一次或多次  
X{n}  X出现n次  
X{n,}  X出现至少n次  
X{n,m}  X出现至少n次，但不超过m次  

在String类别中，matches()方法可以让您验证字符串是否符合指定的正规表示式，这通常用于验证使用者输入的字符串数据是否正确，例如电话号码格式；replaceAll()方法可以将符合正规表示式的子字符串置换为指定的字符串；split()方法可以让您依指定的正规表示式，将符合的子字符串分离出来，并以字符串数组传回。
下面这个程序示范几个正则表示式的应用：
UseRegularExpression.java
import java.util.Scanner;

public class UseRegularExpression {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        String str = "abcdefgabcabc";
        System.out.println(str.replaceAll(".bc", "###"));
        System.out.print("输入手机号码: ");
        str = scanner.next(); // 简单格式验证
        if (str.matches("[0-9]{4}-[0-9]{6}"))
            System.out.println("格式正确");
        else
            System.out.println("格式错误");
        System.out.print("输入href标签: ");
        // Scanner的next()方法是以空白为区隔
        // 我们的输入有空白，所以要执行两次
        str = scanner.next() + " " + scanner.next();
        // 验证href标签
        if (str.matches("<a.+href*=*['\"]?.*?['\"]?.*?>"))
            System.out.println("格式正确");
        else
            System.out.println("格式错误");
        System.out.print("输入电子邮件: ");
        str = scanner.next();
        // 验证电子邮件格式
        if (str.matches("^[_a-z0-9-]+([.][_a-z0-9-]+)*@[a-z0-9-]+([.][a-z0-9-]+)*$"))
            System.out.println("格式正确");
        else
            System.out.println("格式错误");
    }
}
执行结果：


StringBuffer类
StringBuffer对象是一个可以改变的统一编码字符串。String与StringBuffer之间没有继承关系。
     构造函数
     StringBuffer()：创建一个空的StringBuffer。
     StringBuffer(int capacity) ：创建一个空的StringBuffer，容量是capacity。
     StringBuffer(String initialString) ：创建一个StringBuffer，其内容是initialString。
     修改方法
     StringBuffer append(String s)：在原来的StringBuffer后面追加上s。对于下列参数类型有重载的方法：
boolean,char,char[],double,float,int,long,Object。
     StringBuffer insert(int offset, String s)：在原来的StringBuffer的offset处插入s。对于下列参数类型有重载的方法：boolean, char, char[], double, float, int, long, Object。
     StringBuffer reverse()：颠倒原StringBuffer中字符的顺序。
     void setCharAt(int index, char ch)：将StringBuffer中的index处设为ch。
     void setlength(int newLength)：设定StringBuffer的长度。
另外，在JDK5.0中新加入了StringBuilder类，它类似于StringBuffer类，只是该类的方法是非线程安全的；因此在不需要考虑线程安全时可以考虑这个类替换StringBuffer类。

StringBuffer与String的区别
主要是效率上的区别。它们都可以表示一个字符串对象，只不过String类型的字符串对象，只要值改变，存储的空间也会改变，而StringBuffer是在原来的空间上进行修改的。所以要进行大量的字符串操作，要用StringBuffer.
而如果不是频繁操作字符串对象，两者都可以，只不过String 更方便些，因为用两个双引号就可以表示一个Sting对象。

集合类的使用
集合 （或容器）是代表一个对象组的单个对象，其它对象被认为是它的元素。集合 用于处理多种类型对象的问题，所有的类型都有一个特殊的种类(也就是说，它们都是从一个共同父类继承来的)。Java编程语言支持集合 Vector,List,Map,Stack等等。例如，Stack实现后进先出（LIFO）的顺序,Hashtable提供一个相关的对象数组。
集合 可用于保存，处理Object类型的对象。这允许在收集中贮存任何对象。它还可以，在使用对象前、从集合 中检索到它之后，使用正确的类型转换为我们所需要的对象类型。

Collections API的体系结构
集合是代表一组对象的单个对象。集合中的对象叫元素。
我们在程序设计中经常会用到各种各样的数据结构，如：表、映射、清单、树、集合等。显然，这些数据结构都满足集合的定义。为了方便我们处理各种各样的数据结构，Java在Java.util包中提供了一组API。这组API中的大部分类都实现了Collection接口，因此，被称作Collections API。
API还包括诸如HashSet, ArraySet, ArrayList, LinkedList和Vector等等的类，它们实现这些接口。API还提供了支持某些算法的方法，如：排序，二进制搜索，计算列表中的最小和最大等。
集合 根据它们处理的不同种类的数据结构，Collections API可分为三类：
    (Collection)收集-没有具体顺序的一组对象
    (Set)设定-没有重复的一组对象
    (List)列表-有序对象组，允许重复
 
实例分析
命令行参数
例1
问题的描述：
    通过命令行参数给程序输入数据
解决方案：        
    当一个Java应用程序从终端启动时，用户可以提供零个或多个命令行参数。这些命令行参数都是字符串，这些字符串可以是独立的记号（如：arg1），也可以是引号之间的多个符号（"another arg"）。参数序列跟在程序类的名字后面输入；然后被存放在String 对象的数组中，传递给main 方法。
请看下例：
class TestArgs {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}
编译，运行以及输出的结果为：  


例2
系统属性
问题的描述：
通过系统属性给程序传入数据
解决方案：
系统属性是另外一种在运行时向程序传递参数的机制。每个属性都是一个属性名和属性值的映射对。属性名和属性值都是字符串。Properties 类表示这样的映射。System.getProperties方法返回系统的属性对象。System.getProperties(String)方法返回String属性的值。System.getProperties(String， String)方法允许你在属性名不存在时返回默认值。你可以使用递归调用PropertyNames方法遍历全部属性名的集合；对每个属性名调用getProperty方法得到所有属性的值。
请看下例：
import java.util.*;

class TestSP // System Properties
{
    public static void main(String[] args) {
        Properties p = System.getProperties(); // 第六行
        Enumeration e = p.propertyNames(); // 第七行

        while (e.hasMoreElements()) {
            String name = (String) e.nextElement();
            if (name.equals("aaa")) {
                String value = p.getProperty(name);
                System.out.println("name: " + name + "  value: " + value);
            }
        }
    }
}
分析：第六行取得系统属性的集合，第七行从属性集合中得到属性名的枚举。枚举对象允许程序循环遍历其中的所有元素。这一点与迭代相似。hasMoreElements 方法判断枚举中是否还有后续元素，nextElement方法返回枚举中的下一个元素。
运行：
     java -Daaa=345 TestSP     //-D后面是属性的名字，=后面是属性的值 ，注意是大写的D
输出结果摘录如下：


例3
标准的输入
问题的描述：
    标准的输入
解决方案：
    多数应用都会发生人机交互， 人机交互经常通过控制台文本输入/输出来完成。
    Java 2 SDK 用公有类java.lang.System支持控制台I/O。
    System.out是一个PrintStream对象，它指向运行Java应用程序的终端窗口。
    System.in是一个InputStream对象，它指向用户的键盘。

请看下例：
import *;

class TestKI // Keyboard Input
{
    public static void main(String[] args) {
        String s;

        // 进行字符串的包装，就可以读取一行字符串
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

        System.out.println("按 ctrl+c 键 或者输入exit 退出程序！");

        try {
            s = br.readLine();
            // 如果按 ctrl+c 键，那么s==null，所以要先进行s!=null判断，不然
            // 会出现空指针异常（调用s.equals("exit")）
            while (s != null && !s.equals("exit")) {
                System.out.println("Read: " + s);
                s = br.readLine();
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
编译和运行的结果为：


JDK1.5新特性：java.util.Scanner类，如下代码：
import java.util.Scanner;
public class ScannerDemo {   
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你的名字：");
        String name = scanner.nextLine();
        System.out.print("请输入你的年龄：");
        int age = scanner.nextInt();
        System.out.println(name + "年龄是：" + age);
    }
}



JDK1.6新特性：类，如下代码：
import
public class ConsoleDemo {
    public static void main(String[] args) {
        Console console = System.console();
        System.out.print("请输入你的名字：");
        String name = console.readLine();
        System.out.print("请输入你的密码：");
        char[] password = console.readPassword();
        System.out.println(name + "密码是：" + new String(password));
    }
}



例4
程序中实现文件的创建，读，写
问题的描述：
    在程序中实现文件的创建，读，写
解决方案：
Input/Output(I/O)是程序中最重要的元素之一。Java技术包含了一套丰富的I/O流。这一节我们要讲解文件中字符数据的读写。我们将讲述：
    创建文件对象。
    操作文件对象。
    读写文件流。
    创建一个新的File对象
File类提供了若干处理文件和获取它们基本信息的方法。在java技术中，目录也是一个文件。你可以创建一个代表目录的文件，然后用它定义另一个文件：
            File        myFile;
            myFile = new File("FileName");
            myFile = new File("/", "FileName");
            
            File        myDir = new File("/");
            myFile = new File(myDir, "FileName");
你所使用的构造函数经常取决于你所使用的其他文件对象。例如，如果你在你的应用程序中只使用一个文件，那么就会使用第一个构造函数。如果你使用一个公共目录中的若干文件，那么使用第二个或者第三个构造函数可能更容易。
File类提供了独立于平台的方法来操作由本地文件系统维护的文件。然而它不允许你存取文件的内容。
注意：你可以使用一个File对象来代替一个String作为FileInputStream和FileOutputStream对象的构造函数参数。这是一种推荐方法，因为它独立于本地文件系统的约定。

文件测试和工具
当你创建一个File对象后，你可以使用下面任何一种方法来获取有关文件的信息：
              文件名：
String getName()
                    String getPath()
                    String getAbsolutePath()
                    String getParent()
                    boolean renameTo(File newName)

                文件测试：
                    boolean exists()
                    boolean canWrite()
                    boolean canRead()
                    boolean isFile()
                    boolean isDirectory()
                    boolean isAbsolute()

                通用文件信息和工具：
                    long lastModified()
                    long length()
                    boolean delete()

                目录工具：
                    boolean mkdir()
                    String[] list()
请看下例：
import *;

class TestReader {
    public static void main(String[] args) {
        //读取当前目录下的，该类的原文件
        File f = new File("TestReader.java");
        //输出到当前目录下的out.java，系统会自动创建该文件
        File f1 = new File("out.java");
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        PrintWriter pw = null;

        try {
            fr = new FileReader(f);
            br = new BufferedReader(fr);
            fw = new FileWriter(f1);
            pw = new PrintWriter(fw, true);//true 代表自动刷新到磁盘里

            String ss = br.readLine();
            while (ss != null && !ss.equals("exit")) {
                pw.println(ss);
                ss = br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不管发生不发生异常，都要进行IO流的关闭
            try {
                //防止发生空指针异常，也就是说在创建文件IO流之前发生异常。
                if (br != null)
                    br.close();
                if (pw != null)
                    pw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 以上是关闭IO流最完整的代码
    }
}
运行完之后，会在当前目录下生成out.java文件，跟上面的源文件一样。
例5
问题的描述：
    通过控制台写数据到文件里
解决方案：
        1，建立控制台的输入流
        2，建立文件的输出流
请看下例：
import *;

class TestKWF {
    public static void main(String[] args) {
        File file = new File("keyout.java");
        BufferedReader br = null;
        // 要习惯性的给声明的引用类型变量初始化为null
        PrintWriter pw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            pw = new PrintWriter(new FileWriter(file));
            System.out.println("按 ctrl+c 键 或者输入exit 退出程序！");
            String s = null;
            s = br.readLine();
            // 如果按 ctrl+c 键，那么s==null，所以要先进行s!=null判断，不然
            // 会出现空指针异常（调用s.equals("exit")）
            while (s != null && !s.equals("exit")) {
                pw.println(s);
                s = br.readLine();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
                if (pw != null)
                    pw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
运行完之后，会在当前目录下生成keyout.java文件，跟控制台输入的一样。
例6
问题的描述：
    String 类的使用
解决方案：
    String 对象是一个不可变的统一编码字符串。该类是JDK中最特殊的一个类。只要一个String对象值改变，系统会在内存堆里寻找新的空间来存放改变后的值。
请看下例：
class TestString {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        /*
         * 如果该成 String s2 = new String("abc"); 会在内存中再生成一个"abc"对象 那么将第一次将输出！=
         * 如果要想输出== 把（s1 == s2）改成(s1.equals(s2)) ==只能判断基本类型的值和引用类型的地址相等不相等
         * equals方法可以判断引用类型的值相等不相等。
         */
        if (s1 == s2) // 地址相等的判断
            System.out.println("==");
        else
            System.out.println("!=");

        s2 = s2 + "d"; // 改变对象"abc"的值
        if (s1 == s2) // 地址相等的判断,如果输出！= 说明s2的地址改变了。
            System.out.println("==");
        else
            System.out.println("!=");

    }
}
编译和运行的结果为：
        ==
        !=
例7
Set容器
问题的描述：
    Set容器的使用
解决方案：
在下面的例题中，程序声明了一个Collections API的Set 型对象，并且用它的子类HashSet初始化它。然后向Set中添加元素，打印结果。
请看下例：
import java.util.*;

public class TestSet {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("abc");
        set.add("abd");
        set.add("abe");
        set.add(new Integer(4));
        set.add("abe"); // 插入了相同的数据，所以会失败
        set.add(new Integer(4)); // 同上
        System.out.println(set);
    }
}
编译和运行的结果为：
        [4,abd,abc,abe]
从结果可以看出Set容器的特点：不能保存重复的数据，而且保存的是无序的数
请思考下面的问题：这里的重复数据是根据什么判断两个数据是否是同一个数据？
    是由对象的hashCode()和equals()方法共同决定的。
请看下例：
import java.util.*;

class TestSet1 {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        // 保存了10个数据
        for (int i = 0; i < 10; i++)
            hs.add(new Data());
        // 只打印一个数据，如果Data没有覆盖hashCode()、equals()其中一个方法，那么会输出10个数据
        System.out.println(hs);
    }
}

class Data {
    // 覆盖hashCode()方法，得到一样的hashcode
    public int hashCode() {
        return 12;
    }

    // 覆盖equals()方法，是每个对象比较相等
    public boolean equals(Object o) {
        return true;
    }
}
输出结果为：
   [Data@c]

例8
List 容器
问题的描述：
    List 容器的使用
解决方案：
在下面的例题中，程序声明了一个Collections API的List 型对象，并且用它的子类ArrayList初始化它。然后向List中添加元素，打印结果。
    注意：List允许重复的元素。
请看下例：
import java.util.*;

class TestList {
    public static void main(String[] args) {
        // 建立一个List类型的容器
        ArrayList al = new ArrayList();
        // 放11个数据，其中有重复的
        for (int k = 0; k < 10; k++)
            al.add("abc" + k);
        al.add("abc" + 4);
        // 打印出容器里的数据
        System.out.println(al);
    }
}

编译和运行的结果为：
[abc0,abc1,abc2,abc3,abc4,abc5,abc6,abc7,abc8,abc9,abc4]
从结果可以看到List容器的特点：有序的数据，可重复的数据
例9
迭代器
问题的描述：
    迭代器的用法
解决方案：
请看下例：
可以用迭代扫描一个集合。基本的Iterator接口可以向前扫描任何集合。对于一个Set来说，它的迭代是没有顺序的。对于一个List来说，它的迭代的顺序与List中元素的顺序相同，只能向前，不能后退。此外，List对象还支持ListIterator接口，允许迭代向后移动。
示例：
import java.util.*;

public class TestList2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("one");
        list.add("second");
        list.add("third");
        list.add(new Integer(4));
        list.add(new Float(5.0F));
        list.add("second"); // true
        list.add(new Integer(4)); // true
        // 使用迭代器，来迭代容器里的所以数据，我们把Iterator叫做迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());
    }
}
输出结果为：
        one
        second
        third
        4
        5.0
        second
        4
上面例子只用了Iterator，这种迭代器只能向后迭代容器里的数据，有时候需要向前迭代数据，那么就得用ListIterator（列表迭代器），它可以前后滚动容器里的数据。请看下面的例子：
import java.util.*;

public class TestList3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("one");
        list.add("second");
        list.add("third");
        list.add(new Integer(4));
        list.add(new Float(5.0F));
        list.add("second"); // true
        list.add(new Integer(4)); // true
        ListIterator iterator = list.listIterator();
        System.out.println("向下迭代容器里的数据：");
        while (iterator.hasNext())
            System.out.println(iterator.next());
        System.out.println("向上迭代容器里的数据：");
        while (iterator.hasPrevious())
            System.out.println(iterator.previous());
    }
}

输出结果为：
向下迭代容器里的数据：
        one
        second
        third
        4
        5.0
        second
        4
向上迭代容器里的数据：
        4
        second
        5.0
        4
        third
        second
        one
用迭代器还可以修改容器里的数据，只不过只能用当前的迭代器修改，不能两个迭代器同时修改一个容器里的数据！
请看下面事例：
import java.util.*;

public class TestList4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("one");
        list.add("second");
        list.add("third");
        list.add(new Integer(4));
        list.add(new Float(5.0F));
        list.add("second"); //true
        list.add(new Integer(4)); //true
        ListIterator listIterator = list.listIterator();
        Iterator iterator = null;
        iterator = list.iterator();

        if (iterator.hasNext())
            iterator.next();
        iterator.remove();//会删除该next()返回的元素。
        //用另个迭代器操作上一个迭代器改变后的数据
        while (listIterator.hasNext())
            System.out.println(listIterator.next());

    }
}
会发生如下异常：
java.util.ConcurrentModificationException

JDK5.0新特性：增强性for循环
package com.itjob;
import java.util.*;
public class TestList
{
    public static void main(String[] args)
    {
        List<String> list = new LinkedList<String>();   
        list.add("tom");
        list.add("mary");
        list.add("bob");
        for (String name: list)
        {
            System.out.println(name);
        }
    }
}

例10
映射（Maps）
问题的描述：
    映射（Maps）的用法
解决方案：        
映射这种数据结构含有两个部分：关键字和值。对于每个关键字都有一个值，也就是说，一个关键字映射一个值。映射允许通过关键字访问数据结构。
Java 在Collections API的Map接口中声明了一对一的映射。当向映射中插入一对关键字和值时,如果出现关键字重用，则用新值替换映射中原有的值，不在映射中增加一个元素。
请看下例：
import java.util.Map;
import java.util.HashMap;

public class TestMap {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("abc", new Integer(5));
        map.put("abd", new Integer(6));
        map.put("abf", new Integer(7));
        // 会覆盖原来的值7
        map.put("abf", new Integer(8));
        System.out.println(map.get("abf"));
    }
}
编译和运行的结果为：
        8
在应用中可以把该容器里关键字单独取出来放到一个实现Set接口的容器里，然后过滤出你所需要的关键字，然后根据这个关键字把对应的值取出来。
import java.util.Map;
import java.util.*;

public class TestMap1 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("abc", new Integer(5));
        map.put("abd", new Integer(6));
        map.put("abf", new Integer(7));
        map.put("abf", new Integer(8));
        // 得到关键字的集合
        Set s = map.keySet();
        Iterator i = s.iterator();
        String str = null;
        while (i.hasNext()) {
            str = (String) i.next();
            if (str.equals("abf"))
                System.out.println(map.get(str));
        }
    }
}

结果还是8
注意：这里的关键字对象还是由hashCode()和equals()方法共同决定的

例11
排序
问题的描述：
    排序的用法
解决方案：
    对于复杂的应用，尤其是生成报表时，排序是一种必不可少的基本操作。在Java 2 Collections API中，已经实现了几种排序。
    给数组排序可以使用Arrays对象的一套sort方法。
    对于boolean以外的基本类型，Arrays.sort有两种变化：
    Arrays.sort(<type>[] array)用来为整个数组排序。
    Arrays.sort(<type>[] array, int fromIndex, int toIndex)用来为数组的一部分排序。
对于引用类型，Arrays.sort有四种种变化：
    Arrays.sort(Object[] array)用默认的比较器为整个数组排序。
    Arrays.sort(Object[] array, int fromIndex, int toIndex)用默认的比较器为数组的一部分排序。
    Arrays.sort(Object[] array, Comparator comparator)使用指定得比较器为整个数组排序。
    Arrays.sort(Object[] array, int fromIndex, int toIndex, Comparator comparator)使用指定得比较器为数组的一部分排序。
由于排序算法必须比较两个对象，所以使用Arrays.sort方法时要传递比较器参数。比较器有两种类型：一种是实现Comparable接口的, 另一种是实现Comparator接口的。
Comparable接口定义了一个方法:int compareTo(element, Object)。这个方法比较 Object 与element。如果Object小于element，则返回负值；如果Object大于element，则返回正值；如果Object等于element，则返回零。
Comparator接口定义了两个方法：
    compare(T o1, T o2) ，返回值int。如果o1小于o2，则返回负值；如果o1大于o2，则返回正值；如果o1等于o2，则返回零。
    equals(Object obj) ，返回值boolean。用于判断两个比较器对象是否相等。该方法在继承Object类时已经被实现。
请看下例：
import java.util.*;
public class TestCompareable1 {
    public static void main(String[] args) {

        Cat[] c = new Cat[5];
        for (int i = 0; i < c.length; i++) {
            c[i] = new Cat((int) (Math.random() * 100));
            // 随机生成一个整数，作为猫对象的属性值，以区分不同的对象
            System.out.println(c[i]);
        }

        Arrays.sort(c);
        System.out.println("----------------");
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i]);
        }
    }
}
class Cat implements Comparable {
    int w = 0;

    public Cat(int i) {
        w = i;
    }

    public String toString() {
        return "Cat: " + w;
    }

    public int compareTo(Object o) {
        Cat c = (Cat) o;
        if (this.w == c.w) // 相等的话返回0
        {
            return 0;
        } else if (this.w > c.w) // 大于的话返回正数
        {
            return 6;
        } else
            return -3; // 小于的话返回负数
    }
}
输出结果如图


也可以定义动态的比较器，如下事例：
import java.util.*;

public class TestCompareable2 {
    public static void main(String[] args) {

        Cat[] c = new Cat[5];
        for (int i = 0; i < c.length; i++) {
            c[i] = new Cat((int) (Math.random() * 100));
            // 随机生成一个整数，作为猫对象的属性值，以区分不同的对象
            System.out.println(c[i]);
        }

        Arrays.sort(c, new Comparator() // 匿名类实现
                {
                    public int compare(Object o1, Object o2) {
                        Cat c1 = (Cat) o1;
                        Cat c2 = (Cat) o2;
                        if (c1.w > c2.w) // 如果大于的话返回正数
                            return 4;
                        else if (c1.w < c2.w)
                            return -2; // 小于的话返回负数
                        else
                            return 0; // 相等的话返回0

                    }
                    /*
                     * 注意该接口还有一个方法叫 equals(Object o)方法在
                     * 这里并没有实现，也会通过，原因是Object类也有那个方法 所以每个类都有该方法。
                     */

                });
        System.out.println("----------------");
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i]);
        }

    }

}

class Cat {
    int w = 0;

    public Cat(int i) {
        w = i;
    }

    public String toString() {
        return "Cat: " + w;
    }
}
输出结果如图

收到的鲜花

• gameohyes 于 2010-07-21 19:51 送鲜花  49朵   附言：好文章..辛苦了!!!

新手，有点不懂

如果想一天学完这些，是很难的，分几天看吧，慢慢学就能入门了

顶啊，

帖子好长，嘿嘿

路过

厉害，这是你自己写的吗？

  太多了  看上去感觉好复杂。。。

学习路过