亚洲国产成人久久精品99 ,国产亚洲欧美日韩亚洲中文色,亚洲国产精品不卡在线电影

bluesky — Sat, 26 Nov 2005 05:19:00 GMT

function IsNumeric(Data: string) : boolean;
    var i, code : integer;
    begin
    val(data, i, code);

    if code = 0
     then result := true
     else result := false;
    end;

bluesky 2005-11-26 13:19 发表评论

Java.util.Date�c�d��格式化输出和字符串�{Date�c�d��

bluesky — Wed, 16 Nov 2005 08:59:00 GMT

1 import java.text.Format;
2 import java.text.ParseException;
3 import java.text.SimpleDateFormat;
4 import java.util.Date;
5
6 public class DateFormatToString {
7     protected static Format format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
8
9     public static void main(String[] args) {
10
11         Date date = new Date();
12         System.out.println(format.format(date));
13
14         try {
15             Date date1 = (Date) format.parseObject("2005-11-15 20:55:48");
16             System.out.println(date1);
17         } catch (ParseException e) {
18             // TODO Auto-generated catch block
19
20         }
21
22         format = new SimpleDateFormat("yyyy-MM-dd");
23         System.out.println(format.format(date));
24         format = new SimpleDateFormat("hh:mm:ss");
25         System.out.println(format.format(new Date()));
26
27     }
28 }

输出

12005-11-15 09:02:30
2Tue Nov 15 20:55:48 CST 2005
32005-11-15
409:02:30

bluesky 2005-11-16 16:59 发表评论

bluesky — Wed, 09 Nov 2005 02:03:00 GMT

1import java.io.FileInputStream;
2import java.io.FileOutputStream;
3import java.io.ObjectInputStream;
4import java.io.ObjectOutputStream;
5import java.io.Serializable;
6
7public class serialStore implements Serializable {
8
9    public serialStore() {
10    }// serialStore()
11
12    /**
13     * 写对象到指定文�g�?BR>14     */
15    public void writeFile(String strFile, Object[] o) {
16        try {
17            FileOutputStream fos = new FileOutputStream(strFile);
18            ObjectOutputStream oos = new ObjectOutputStream(fos);
19            for (int i = 0; i < o.length; i++) {
20                oos.writeObject(o[i]);
21            }
22            oos.flush();
23        } catch (Exception e) {
24            e.printStackTrace();
25        }
26    }// writeFile()
27
28    /**
29     * ��L��定文件的对象到对象组�?BR>30     */
31    public Object[] readFile(String strFile, int objectNum) {
32        Object o[] = new Object[objectNum];
33        try {
34            FileInputStream fis = new FileInputStream(strFile);
35            ObjectInputStream ois = new ObjectInputStream(fis);
36            for (int i = 0; i < o.length; i++) {
37                o[i] = ois.readObject();
38            }
39        } catch (Exception e) {
40            e.printStackTrace();
41        }
42        return o;
43    }// readFile()
44
45    /**
46     * 昄��对象内容
47     */
48    public void log(Object[] o) {
49        for (int i = 0; i < o.length; i++) {
50            System.out.println(o[i]);
51        }
52    }// log()
53
54    /**
55     * 昄��对象内容
56     */
57    public void log(Object o) {
58        System.out.println(o);
59    }// log()
60
61    public static void main(String arg[]) {
62        Object o[] = new Object[2];
63        o[0] = new String("objectName");
64        o[1] = new Integer(25);
65        serialStore ss = new serialStore();
66        String strFile = "serial.abc";
67        ss.writeFile(strFile, o);
68        ss.log(ss.readFile(strFile, o.length));
69    }//main()
70
71}
72/** serialStore */
73
74

bluesky 2005-11-09 10:03 发表评论

bluesky — Wed, 09 Nov 2005 01:52:00 GMT

对象序列化机制对于需要将对象的状态保存到文�g中，而后能够通过��d��对象状态来重新构造对象，恢复�E�序状态，或者��用套接字在网�l�上传送对象的�E�序来说�Q�是很有用的。通过让类实现java.io.Serializable 接口可以��类序列化。这个接口是一个制造者（marker�Q�接口。也��是��_��对于要实现它的类来说�Q�该接口不需要实��C�Q何方法。它主要用来通知Java虚拟机（JVM�Q�需要将一个对象序列化�?/SPAN>

也叫串行化，对象的域转化为紧凑的2�q�制形式�Q�是对象持久化的�Ҏ��之一�?BR>
《实现类的序列化--例子��Vector对象压入标准��》出�?CN-JAVA原创�Q�jackliu

Vector对象是一个很灉|��的java数据�l�构�Q�在实际�~�程中，有时需要我们将一个Vector对象传递给另一个Java�E�序�q�保持Vector的数据结构状态，�q�时�Q�我们可以将需要传递的对象实现java.io.Serializable接口�Q�序列化�q�个�c�，�׃��序列化本�w�就是允�怸�个对象在虚拟��Z��间传�?或者经�q�一�D늩��_��如在RMI�?或者经�q�一�D�|��_��比如数据��被保存��C��个文件中)�?关于�cȝ��序列化请查阅相关资料�Q�本��不在叙�q�ͼ�下面使用一个简单的�E�序说明如何把一个Vector对象序列化�ƈ攑ֈ�一个流中（��Z��试方便�Q�这里放��C��个文件流中，如果换成一个套接字��可以把对象发送给�q�程��h��者）

�E�序1�Q�把一个Vector对象存储��C��个testvector.obj文�g里（模拟server socket处理�Q?BR>

1import java.io.*;
2import java.util.*;
3
4class TestVector implements java.io.Serializable{
5        private Vector vect=new Vector();
6
7        public void add(Object obj){
8                this.vect.add(obj);
9        }
10        public void print(){
11                System.out.println(this.vect);
12        }
13        public static void main(String[] args){
14                try {
15                        /* ��对象写��C��个文仉�� */
16                        FileOutputStream objfile = new FileOutputStream("testvector.obj");
17                        /* 创徏一个输出流 */
18                        ObjectOutputStream p = new ObjectOutputStream(objfile);
19                        /* 创徏一个TestVector对象 */
20                        TestVector tv =new TestVector();
21                        /*�l�Vector写入几String个对�?/SPAN>*/
22                        tv.add("One");
23                        tv.add("Two");
24                        tv.add("Three");
25                        p.writeObject(tv); // 把tv写入��?/SPAN>
26                        p.flush();
27                        objfile.close();    // 关闭文�g对象
28                } catch (Exception e) {
29                        e.printStackTrace();
30                }
31        }
32}
33

�~�译�E�序1�Q�运行后�Q�在当前目录生成一个testvector.obj文�g�Q�这个文仉��存放了TestVector�cȝ��数据

�E�序2�Q�从testvector.obj文�g里获取TestVector对象�Q�模拟socke客户端）

1import java.io.*;
2import java.util.*;
3
4class ReadVectorObj{
5        public static void  main (String[] args){
6                try {
7                        /* 打开文�g�Q�读取Vector 存放的对象数�?nbsp;*/
8                        FileInputStream objfile = new FileInputStream("testvector.obj");
9                        ObjectInputStream q = new ObjectInputStream(objfile);
10                        /* 获取对象原始数据 */
11                        TestVector myvector = (TestVector)q.readObject();
12                        myvector.print();
13                } catch (Exception e) {
14                        e.printStackTrace();
15                }
16        }
17}

�~�译�E�序2�Q�运行后�Q�读取testvector.obj文�g�Q�根据内�Ҏ��建出原始的TestVector�c�R�?/P>

bluesky 2005-11-09 09:52 发表评论

三种初始化字�D늚�方式

bluesky — Tue, 08 Nov 2005 15:11:00 GMT

1构造函��C��赋�?BR>2声明时赋�?BR>3初始化块 initialization block。类中可以包含�Q意多的代码块�Q�只要构造了�cȝ��对象�Q�这些代码块��׃��被执行�?BR>
例子
People.java

1package test;
2
3public class People {
4    private String name;
5    private int age;
6    public int getAge() {
7        return age;
8    }
9    public void setAge(int age) {
10        this.age = age;
11    }
12    public String getName() {
13        return name;
14    }
15    public void setName(String name) {
16        this.name = name;
17    }
18
19    public People(){
20        //默认构造函�?/SPAN>
21    }
22    {
23        this.setAge(12);
24        this.setName("bluesky");
25    }
26
27}
28

Test.java

1package test;
2
3public class Test {
4    public static void main(String args[]){
5        People p = new People();
6        System.out.println(p.getName());
7    }
8
9}

输出bluesky

bluesky 2005-11-08 23:11 发表评论

JavaIO利用�q�代��d��文�g�Ҏ��有目录及文�g

bluesky — Mon, 07 Nov 2005 10:08:00 GMT

1import java.io.File;
2import java.util.ArrayList;
3
4public class ReadFile {
5 public static void main(String args[]) {
6  String dir = "D:\\xxx";
7
8  ArrayList a = getFiles(dir);
9  for (int i = 0; i < a.size(); i++) {
10   File file = (File) a.get(i);
11  }
12 }
13
14 public static ArrayList getFiles(String aDir) {
15  ArrayList files = new ArrayList();
16  File dirx = new File(aDir);
17  File[] dirFilesx = dirx.listFiles();
18
19  for (int k = 0; k < dirFilesx.length; k++) {
20   System.out.print("|");
21   File file = dirFilesx[k];
22   String fileName = file.getName();
23   System.out.println("-" + fileName);
24   if (file.isDirectory()) {
25    String dirx1 = aDir + "\\" + fileName;
26    getFiles(dirx1);
27   }
28   files.add(file);
29  }
30  return files;
31
32 }
33
34}
35
36

bluesky 2005-11-07 18:08 发表评论

bluesky — Mon, 07 Nov 2005 09:06:00 GMT

正则表达式是一�U�功能强大但又非常灵�zȝ��文本处理工具。它能让你用�~�程的方式来描述复杂的文本模式，然后在字�W�串里把它找出来。一旦你扑ֈ�了这�U�模式，你就能随心所�Ʋ地处理�q�些文本了。虽然初看�v来正则表辑ּ�的语法有点让人望而生畏，但它提供了一�U�精�l�的动态语�a��Q��我们能用一�U�通用的方式来解决各种字符串的问题�Q�包括匹配，选择�Q�编辑以及校验�?/P>

创徏正则表达�?/STRONG>

字符

B 字符B

\xhh 16�q�制�?SPAN class=original_words>0xhh所表示的字�W?/TD>

\uhhhh 16�q�制�?SPAN class=original_words>0xhhhh所表示的Unicode字符

\t Tab

\n 换行�W?/TD>

\r 回�R�W?/TD>

\f 换页�W?/TD>

\e Escape

正则表达式的强大体现在它能定义字�W�集(character class)。下面是一些最常见的字�W�集及其定义的方式，此外�q�有一些预定义的字�W�集�Q?/P>

字符�?/SPAN>

. 表示��L��一个字�W?

[abc] 表示字符a�Q?SPAN class=original_words>b�Q?SPAN class=original_words>c中的��L��一�?�?SPAN class=original_words>a|b|c相同)

[^abc] �?SPAN class=original_words>a�Q?SPAN class=original_words>b�Q?SPAN class=original_words>c之外的�Q意一个字�W?否定)

[a-zA-Z] �?SPAN class=original_words>a�?SPAN class=original_words>z�?SPAN class=original_words>A�?SPAN class=original_words>Z当中的�Q意一个字�W?范围)

[abc[hij]] a,b,c,h,i,j中的��L��一个字�W?�?SPAN class=original_words>a|b|c|h|i|j相同)(�q��)

[a-z&&[hij]] h,i,j中的一�?交集)

\s �I�格字符(�I�格�? tab, 换行, 换页, 回�R)

\S 非空格字�W?[^\s])

\d 一个数字，也就�?SPAN class=original_words>[0-9]

\D 一个非数字的字�W�，也就�?SPAN class=original_words>[^0-9]

\w 一个单词字�W?word character)�Q�即[a-zA-Z_0-9]

\W 一个非单词的字�W�，[^\w]

如果你用�q�其它语�a�的正则表辑ּ��Q�那么你一眼就能看出反斜杠的与众不同。在其它语言里，"\\"的意思是"我只是要在正则表辑ּ�里插入一个反斜杠。没什么特别的意思�?但是在Java里，"\\"的意思是"我要插入一个正则表辑ּ�的反斜杠�Q�所以跟在它后面的那个字�W�的意思就变了�?举例来说�Q�如果你惌��C�Z��个或更多�?单词字符"�Q�那么这个正则表辑ּ��应该是"\\w+"。如果你要插入一个反斜杠�Q�那��得�?\\\\"。不�q�像换行�Q�蟩��g��cȝ��q�是只用一根反斜杠�Q?\n\t"�?/P>
�q�里只给你讲一个例子；你应�?SPAN class=original_words>JDK文档�?SPAN class=original_words>java.util.regex.Pattern加到收藏多w��Q�这样就能很�Ҏ��地找到各�U�正则表辑ּ�的模式了�?/P>

逻辑�q�算�W?

XY X 后面跟着 Y

X|Y X或Y

(X) 一�?要匹配的�l?capturing group)". 以后可以用\i来表�C�第i个被匚w��的组�?/TD>

边界匚w��W?

^ 一行的开�?

$ 一行的�l�尾

\b 一个单词的边界

\B 一个非单词的边�?

\G 前一个匹配的�l�束

数量表示�W?/STRONG>

"数量表示�W?quantifier)"的作用是定义模式应该匚w��多少个字�W��?/P>

Greedy(贪婪�?�Q?除非另有表示�Q�否则数量表�C�符都是greedy的。Greedy的表辑ּ�会一直匹配下去，直到匚w��不下��Mؓ止�?U>(如果你发现表辑ּ�匚w��的结果与预期的不�W?�Q�很有可能是因�ؓ�Q�你以�ؓ表达式会只匹配前面几个字�W�，而实际上它是greedy的，因此会一直匹配下厅R�?
Reluctant(勉强�?�Q?用问可��C�，它会匚w��最��的字符。也�U�Cؓlazy, minimal matching, non-greedy, 或ungreedy�?
Possessive(占有�?�Q?目前只有Java支持(其它语言都不支持)。它更加先进�Q�所以你可能�q�不太会用。用正则表达式匹配字�W�串的时候会产生很多中间状态，(一般的匚w��引擎会保存这�U�中间状态，)�q�样匚w��p�|的时候就能原路返回了。占有型的表辑ּ�不保存这�U�中间状态，因此也就不会回头重来了。它能防止正则表辑ּ�的失控，同时也能提高�q�行的效率�?

Greedy Reluctant Possessive 匚w��

X? X?? X?+ 匚w��一个或零个X

X* X*? X*+ 匚w��零或多个X

X+ X+? X++ 匚w��一个或多个X

X{n} X{n}? X{n}+ 匚w��正好n�?SPAN class=original_words>X

X{n,} X{n,}? X{n,}+ 匚w��臛_��n�?SPAN class=original_words>X

X{n,m} X{n,m}? X{n,m}+ 匚w��臛_��n个，臛_��m�?SPAN class=original_words>X

再提醒一下，要想让表辑ּ�照你的意思去�q�行�Q�你应该用括��h��'X'括�v来。比方说�Q?/P>
abc+

��g��q�个表达式能匚w��一个或若干�?abc'�Q�但是如果你真的用它��d��?abcabcabc'的话�Q�实际上只会扑ֈ�三个字符。因��个表辑ּ�的意思是'ab'后边跟着一个或多个'c'。要惛_��配一个或多个完整�?abc'�Q�你应该�q�样�Q?/P>
(abc)+

正则表达式能轻而易丑֜�把你�l�耍了�Q�这是一�U�徏立在Java之上的新语言�?BR>

Pattern�?SPAN class=original_words>Matcher

先给一个例子。下面这�D늨�序可以测试正则表辑ּ�是否匚w��字符丌Ӏ�第一个参数是要匹配的字符�Ԍ��后面是正则表辑ּ�。正则表辑ּ�可以有多个。在Unix/Linux环境下，命��o行下的正则表辑ּ��q�必��ȝ��引号�?/P>
当你创徏正则表达式时�Q�可以用�q�个�E�序来判断它是不是会按照你的要求工作�?/P>

//: c12:TestRegularExpression.java // Allows you to easly try out regular expressions. // {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" } import java.util.regex.*; public class TestRegularExpression { public static void main(String[] args) { if(args.length < 2) { System.out.println("Usage:\n" + "java TestRegularExpression " + "characterSequence regularExpression+"); System.exit(0); } System.out.println("Input: \"" + args[0] + "\""); for(int i = 1; i < args.length; i++) { System.out.println( "Regular expression: \"" + args[i] + "\""); Pattern p = Pattern.compile(args[i]); Matcher m = p.matcher(args[0]); while(m.find()) { System.out.println("Match \"" + m.group() + "\" at positions " + m.start() + "-" + (m.end() - 1)); } } } } ///:~

Java的正则表辑ּ�是由java.util.regex�?SPAN class=original_words>Pattern�?SPAN class=original_words>Matcher�c�d��现的�?SPAN class=original_words>Pattern对象表示�l�编译的正则表达式。静态的compile( )�Ҏ��负责��表�C�正则表辑ּ�的字�W�串�~�译�?SPAN class=original_words>Pattern对象。正如上�q�C��E�所�C�的�Q�只要给Pattern�?SPAN class=original_words>matcher( )�Ҏ��送一个字�W�串��p��获取一�?SPAN class=original_words>Matcher对象。此外，Pattern�q�有一个能快速判断能否在input里面扑ֈ�regex�?注意�Q�原文有误，漏了�Ҏ��?

static boolean matches( regex, input)

以及能返�?SPAN class=original_words>String数组�?SPAN class=original_words>split( )�Ҏ��Q�它能用regex把字�W�串分割开来�?/P>
只要�l?SPAN class=original_words>Pattern.matcher( )�Ҏ��传一个字�W�串��p��获得Matcher对象了。接下来��p��?SPAN class=original_words>Matcher的方法来查询匚w��的结果了�?/P>
boolean matches() boolean lookingAt() boolean find() boolean find(int start)

matches( )的前提是Pattern匚w��整个字符�Ԍ��?SPAN class=original_words>lookingAt( )的意思是Pattern匚w��字符串的开头�?

find( )

Matcher.find( )的功能是发现CharSequence里的�Q�与pattern相匹配的多个字符序列。例如：

//: c12:FindDemo.java import java.util.regex.*; import com.bruceeckel.simpletest.*; import java.util.*; public class FindDemo { private static Test monitor = new Test(); public static void main(String[] args) { Matcher m = Pattern.compile("\\w+") .matcher("Evening is full of the linnet's wings"); while(m.find()) System.out.println(m.group()); int i = 0; while(m.find(i)) { System.out.print(m.group() + " "); i++; } monitor.expect(new String[] { "Evening", "is", "full", "of", "the", "linnet", "s", "wings", "Evening vening ening ning ing ng g is is s full " + "full ull ll l of of f the the he e linnet linnet " + "innet nnet net et t s s wings wings ings ngs gs s " }); } } ///:~

"\\w+"的意思是"一个或多个单词字符"�Q�因此它会将字符串直接分解成单词�?SPAN class=original_words>find( )像一个�P代器�Q�从头到��扫描一遍字�W�串。第二个find( )是带int参数的，正如你所看到的，它会告诉�Ҏ��从哪里开始找——即从参��C��|�开始查找�?/P>
Groups

Group是指里用括号括�v来的�Q�能被后面的表达式调用的正则表达式。Group 0 表示整个表达式，group 1表示�W�一个被括�v来的group�Q�以此类推。所以；

A(B(C))D

里面有三个group�Q�group 0�?SPAN class=original_words>ABCD�Q?group 1�?SPAN class=original_words>BC�Q�group 2�?SPAN class=original_words>C�?/P>
你可以用下述Matcher�Ҏ��来��用group�Q?/P>
public int groupCount( )�q�回matcher对象中的group的数目。不包括group0�?/P>
public String group( ) �q�回上次匚w��操作(比方�?SPAN class=original_words>find( ))的group 0(整个匚w��)

public String group(int i)�q�回上次匚w��操作的某个group。如果匹配成功，但是没能扑ֈ�group�Q�则�q�回null�?/P>
public int start(int group)�q�回上次匚w��所扑ֈ�的，group的开始位�|��?/P>
public int end(int group)�q�回上次匚w��所扑ֈ�的，group的结束位�|�，最后一个字�W�的下标加一�?/P>
下面我们举一些group的例子：

//: c12:Groups.java import java.util.regex.*; import com.bruceeckel.simpletest.*; public class Groups { private static Test monitor = new Test(); static public final String poem = "Twas brillig, and the slithy toves\n" + "Did gyre and gimble in the wabe.\n" + "All mimsy were the borogoves,\n" + "And the mome raths outgrabe.\n\n" + "Beware the Jabberwock, my son,\n" + "The jaws that bite, the claws that catch.\n" + "Beware the Jubjub bird, and shun\n" + "The frumious Bandersnatch."; public static void main(String[] args) { Matcher m = Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$") .matcher(poem); while(m.find()) { for(int j = 0; j <= m.groupCount(); j++) System.out.print("[" + m.group(j) + "]"); System.out.println(); } monitor.expect(new String[]{ "[the slithy toves]" + "[the][slithy toves][slithy][toves]", "[in the wabe.][in][the wabe.][the][wabe.]", "[were the borogoves,]" + "[were][the borogoves,][the][borogoves,]", "[mome raths outgrabe.]" + "[mome][raths outgrabe.][raths][outgrabe.]", "[Jabberwock, my son,]" + "[Jabberwock,][my son,][my][son,]", "[claws that catch.]" + "[claws][that catch.][that][catch.]", "[bird, and shun][bird,][and shun][and][shun]", "[The frumious Bandersnatch.][The]" + "[frumious Bandersnatch.][frumious][Bandersnatch.]" }); } } ///:~

�q�首诗是Through the Looking Glass的，Lewis Carroll�?Jabberwocky"的第一部分。可以看到这个正则表辑ּ�里有很多用括��h��h��的group�Q�它是由��L��多个�q�箋的非�I�字�W?'\S+')和�Q意多个连�l�的�I�格字符('\s+')所�l�成的，其最�l�目的是要捕��h��行的最后三个单词；'$'表示一行的�l�尾。但�?$'通常表示整个字符串的�l�尾�Q�所以这里要明确地告诉正则表辑ּ�注意换行�W�。这一�Ҏ��?(?m)'标志完成�?模式标志会过一会讲�?�?/P>
start( )和end( )

如果匚w��成功�Q?SPAN class=original_words>start( )会返回此�ơ匹配的开始位�|�，end( )会返回此�ơ匹配的�l�束位置�Q�即最后一个字�W�的下标加一。如果之前的匚w��不成�?或者没匚w��)�Q�那么无论是调用start( )�q�是end( )�Q�都会引发一�?SPAN class=original_words>IllegalStateException。下面这�D늨�序还演示�?SPAN class=original_words>matches( )�?SPAN class=original_words>lookingAt( )�Q?/P>

//: c12:StartEnd.java import java.util.regex.*; import com.bruceeckel.simpletest.*; public class StartEnd { private static Test monitor = new Test(); public static void main(String[] args) { String[] input = new String[] { "Java has regular expressions in 1.4", "regular expressions now expressing in Java", "Java represses oracular expressions" }; Pattern p1 = Pattern.compile("re\\w*"), p2 = Pattern.compile("Java.*"); for(int i = 0; i < input.length; i++) { System.out.println("input " + i + ": " + input[i]); Matcher m1 = p1.matcher(input[i]), m2 = p2.matcher(input[i]); while(m1.find()) System.out.println("m1.find() '" + m1.group() + "' start = "+ m1.start() + " end = " + m1.end()); while(m2.find()) System.out.println("m2.find() '" + m2.group() + "' start = "+ m2.start() + " end = " + m2.end()); if(m1.lookingAt()) // No reset() necessary System.out.println("m1.lookingAt() start = " + m1.start() + " end = " + m1.end()); if(m2.lookingAt()) System.out.println("m2.lookingAt() start = " + m2.start() + " end = " + m2.end()); if(m1.matches()) // No reset() necessary System.out.println("m1.matches() start = " + m1.start() + " end = " + m1.end()); if(m2.matches()) System.out.println("m2.matches() start = " + m2.start() + " end = " + m2.end()); } monitor.expect(new String[] { "input 0: Java has regular expressions in 1.4", "m1.find() 'regular' start = 9 end = 16", "m1.find() 'ressions' start = 20 end = 28", "m2.find() 'Java has regular expressions in 1.4'" + " start = 0 end = 35", "m2.lookingAt() start = 0 end = 35", "m2.matches() start = 0 end = 35", "input 1: regular expressions now " + "expressing in Java", "m1.find() 'regular' start = 0 end = 7", "m1.find() 'ressions' start = 11 end = 19", "m1.find() 'ressing' start = 27 end = 34", "m2.find() 'Java' start = 38 end = 42", "m1.lookingAt() start = 0 end = 7", "input 2: Java represses oracular expressions", "m1.find() 'represses' start = 5 end = 14", "m1.find() 'ressions' start = 27 end = 35", "m2.find() 'Java represses oracular expressions' " + "start = 0 end = 35", "m2.lookingAt() start = 0 end = 35", "m2.matches() start = 0 end = 35" }); } } ///:~

注意�Q�只要字�W�串里有�q�个模式�Q?SPAN class=original_words>find( )��p��把它�l�找出来�Q�但�?SPAN class=original_words>lookingAt( )�?SPAN class=original_words>matches( )�Q�只有在字符串与正则表达式一开始就相匹配的情况下才能返�?SPAN class=original_words>true�?SPAN class=original_words>matches( )成功的前提是正则表达式与字符串完全匹配，�?SPAN class=original_words>lookingAt( )^[67]成功的前提是�Q�字�W�串的开始部分与正则表达式相匚w��?/P>
匚w��的模�?Pattern flags)

compile( )�Ҏ��q�有一个版本，它需要一个控制正则表辑ּ�的匹配行为的参数�Q?/P>
Pattern Pattern.compile(String regex, int flag)

flag的取��D��围如下：

�~�译标志效果

Pattern.CANON_EQ 当且仅当两个字符�?正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达�?a\u030A"会匹�??"。默认情况下�Q�不考虑"规范相等�?canonical equivalence)"�?

Pattern.CASE_INSENSITIVE
(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表辑ּ�忽略大小写进行匹配。要惛_��Unicode字符�q�行大小不明感的匚w��Q�只要将UNICODE_CASE与这个标志合��h��p��了�?

Pattern.COMMENTS
(?x) 在这�U�模式下�Q�匹配时会忽�?正则表达式里�?�I�格字符(译者注�Q�不是指表达式里�?\\s"�Q�而是指表辑ּ�里的�I�格�Q�tab�Q�回车之�c?。注释从#开始，一直到�q�行�l�束。可以通过嵌入式的标志来启用Unix行模式�?

Pattern.DOTALL
(?s) 在这�U�模式下�Q�表辑ּ�'.'可以匚w��L��字符�Q�包括表�C�Z��行的�l�束�W�。默认情况下�Q�表辑ּ�'.'不匹配行的结束符�?

Pattern.MULTILINE
(?m) 在这�U�模式下�Q?^'�?$'分别匚w��一行的开始和�l�束。此外，'^'仍然匚w��字符串的开始，'$'也匹配字�W�串的结束。默认情况下�Q�这两个表达式仅仅匹配字�W�串的开始和�l�束�?

Pattern.UNICODE_CASE
(?u) 在这个模式下�Q�如果你�q�启用了CASE_INSENSITIVE标志�Q�那么它会对Unicode字符�q�行大小写不明感的匹配。默认情况下�Q�大��写不明感的匚w��只适用于US-ASCII字符集�?

Pattern.UNIX_LINES
(?d) 在这个模式下�Q�只�?\n'才被认作一行的中止�Q��ƈ且与'.'�Q?^'�Q�以�?$'�q�行匚w��?

在这些标志里面，Pattern.CASE_INSENSITIVE�Q?SPAN class=original_words>Pattern.MULTILINE�Q�以�?SPAN class=original_words>Pattern.COMMENTS是最有用�?其中Pattern.COMMENTS�q�能帮我们把思�\理清楚，�q�且/或者做文档)。注意，你可以用在表辑ּ�里插记号的方式来启用�l�大多数的模式。这些记号就在上面那张表的各个标志的下面。你希望模式从哪里开始启动，��在哪里插记受��?/P>
可以�?OR" ('|')�q�算�W�把�q�些标志合��用：

//: c12:ReFlags.java import java.util.regex.*; import com.bruceeckel.simpletest.*; public class ReFlags { private static Test monitor = new Test(); public static void main(String[] args) { Pattern p = Pattern.compile("^java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE); Matcher m = p.matcher( "java has regex\nJava has regex\n" + "JAVA has pretty good regular expressions\n" + "Regular expressions are in Java"); while(m.find()) System.out.println(m.group()); monitor.expect(new String[] { "java", "Java", "JAVA" }); } } ///:~

�q�样创徏出来的正则表辑ּ��p��匚w��?java"�Q?Java"�Q?JAVA"...开头的字符串了。此外，如果字符串分好几行，那它�q�会�Ҏ��一行做匚w��(匚w��始于字符序列的开始，�l�于字符序列当中的行�l�束�W?。注意，group( )�Ҏ��仅返回匹配的部分�?/P>
split( )

所谓分割是指将以正则表辑ּ�为界�Q�将字符串分割成String数组�?/P>
String[] split(CharSequence charseq) String[] split(CharSequence charseq, int limit)

�q�是一�U�既快又方便地将文本�Ҏ��一些常见的边界标志分割开来的�Ҏ��?/P>

//: c12:SplitDemo.java import java.util.regex.*; import com.bruceeckel.simpletest.*; import java.util.*; public class SplitDemo { private static Test monitor = new Test(); public static void main(String[] args) { String input = "This!!unusual use!!of exclamation!!points"; System.out.println(Arrays.asList( Pattern.compile("!!").split(input))); // Only do the first three: System.out.println(Arrays.asList( Pattern.compile("!!").split(input, 3))); System.out.println(Arrays.asList( "Aha! String has a split() built in!".split(" "))); monitor.expect(new String[] { "[This, unusual use, of exclamation, points]", "[This, unusual use, of exclamation!!points]", "[Aha!, String, has, a, split(), built, in!]" }); } } ///:~

�W�二�?SPAN class=original_words>split( )会限定分割的�ơ数�?/P>
正则表达式是如此重要�Q�以至于有些功能被加�q�了String�c�，其中包括split( )(已经看到�?�Q?SPAN class=original_words>matches( )�Q?SPAN class=original_words>replaceFirst( )以及replaceAll( )。这些方法的功能�?SPAN class=original_words>Pattern�?SPAN class=original_words>Matcher的相同�?

替换操作

正则表达式在替换文本斚w��特别在行。下面就是一些方法：

replaceFirst(String replacement)��字�W�串里，�W�一个与模式相匹配的子串替换�?SPAN class=original_words>replacement�?

replaceAll(String replacement)�Q�将输入字符串里所有与模式相匹配的子串全部替换�?SPAN class=original_words>replacement�?/P>
appendReplacement(StringBuffer sbuf, String replacement)�?SPAN class=original_words>sbuf�q�行逐次替换�Q�而不是像replaceFirst( )�?SPAN class=original_words>replaceAll( )那样�Q�只替换�W�一个或全部子串。这是个非常重要的方法，因�ؓ它可以调用方法来生成replacement(replaceFirst( )�?SPAN class=original_words>replaceAll( )只允许用固定的字�W�串来充�?SPAN class=original_words>replacement)。有了这个方法，你就可以�~�程区分group�Q�从而实现更强大的替换功能�?/P>
调用�?SPAN class=original_words>appendReplacement( )之后�Q��ؓ了把剩余的字�W�串拯��回去�Q�必��调�?SPAN class=original_words>appendTail(StringBuffer sbuf, String replacement)�?

下面我们来演�C�Z��下怎样使用�q�些替换�Ҏ��。说明一下，�q�段�E�序所处理的字�W�串是它自己开头部分的注释�Q�是用正则表辑ּ�提取出来�q�加以处理之后再传给替换�Ҏ��的�?/P>

//: c12:TheReplacements.java import java.util.regex.*; import java.io.*; import com.bruceeckel.util.*; import com.bruceeckel.simpletest.*; /*! Here's a block of text to use as input to the regular expression matcher. Note that we'll first extract the block of text by looking for the special delimiters, then process the extracted block. !*/ public class TheReplacements { private static Test monitor = new Test(); public static void main(String[] args) throws Exception { String s = TextFile.read("TheReplacements.java"); // Match the specially-commented block of text above: Matcher mInput = Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL) .matcher(s); if(mInput.find()) s = mInput.group(1); // Captured by parentheses // Replace two or more spaces with a single space: s = s.replaceAll(" {2,}", " "); // Replace one or more spaces at the beginning of each // line with no spaces. Must enable MULTILINE mode: s = s.replaceAll("(?m)^ +", ""); System.out.println(s); s = s.replaceFirst("[aeiou]", "(VOWEL1)"); StringBuffer sbuf = new StringBuffer(); Pattern p = Pattern.compile("[aeiou]"); Matcher m = p.matcher(s); // Process the find information as you // perform the replacements: while(m.find()) m.appendReplacement(sbuf, m.group().toUpperCase()); // Put in the remainder of the text: m.appendTail(sbuf); System.out.println(sbuf); monitor.expect(new String[]{ "Here's a block of text to use as input to", "the regular expression matcher. Note that we'll", "first extract the block of text by looking for", "the special delimiters, then process the", "extracted block. ", "H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO", "thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE'll", "fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr", "thE spEcIAl dElImItErs, thEn prOcEss thE", "ExtrActEd blOck. " }); } } ///:~

我们用前面介�l�的TextFile.read( )�Ҏ��来打开和读取文件�?SPAN class=original_words>mInput的功能是匚w��'/*!' �?'!*/' 之间的文�?注意一下分�l�用的括�?。接下来�Q�我们将所有两个以上的�q�箋�I�格全都替换成一个，�q�且��各行开头的�I�格全都��L��(��Z��让这个正则表辑ּ�能对所有的行，而不仅仅是第一行�v作用�Q�必��d��用多行模�?。这两个操作都用�?SPAN class=original_words>String�?SPAN class=original_words>replaceAll( )(�q�里用它更方�?。注意，�׃��每个替换只做一�ơ，因此除了预编�?SPAN class=original_words>Pattern之外�Q�程序没有额外的开销�?/P>
replaceFirst( )只替换第一个子丌Ӏ�此外，replaceFirst( )�?SPAN class=original_words>replaceAll( )只能用常�?literal)来替换，所以如果你每次替换的时候还要进行一些操作的话，它们是无能�ؓ力的。碰到这�U�情况，你得�?SPAN class=original_words>appendReplacement( )�Q�它能让你在�q�行替换的时候想写多��代码就写多��。在上面那段�E�序里，创徏sbuf的过�E�就是选group做处理，也就是用正则表达式把元音字母扑և�来，然后换成大写的过�E�。通常你得在完成全部的替换之后才调�?SPAN class=original_words>appendTail( )�Q�但是如果要模仿replaceFirst( )(�?replace n")的效果，你也可以只替换一�ơ就调用appendTail( )。它会把剩下的东西全都放�q?SPAN class=original_words>sbuf�?/P>
你还可以�?SPAN class=original_words>appendReplacement( )�?SPAN class=original_words>replacement参数里用"$g"引用已捕��L��group�Q�其�?g' 表示group的号码。不�q�这是�ؓ一些比较简单的操作准备的，因而其效果无法与上�q�程序相比�?/P>
reset( )

此外�Q�还可以�?SPAN class=original_words>reset( )�Ҏ��l�现有的Matcher对象配上个新�?SPAN class=original_words>CharSequence�?/P>

//: c12:Resetting.java import java.util.regex.*; import java.io.*; import com.bruceeckel.simpletest.*; public class Resetting { private static Test monitor = new Test(); public static void main(String[] args) throws Exception { Matcher m = Pattern.compile("[frb][aiu][gx]") .matcher("fix the rug with bags"); while(m.find()) System.out.println(m.group()); m.reset("fix the rig with rags"); while(m.find()) System.out.println(m.group()); monitor.expect(new String[]{ "fix", "rug", "bag", "fix", "rig", "rag" }); } } ///:~

如果不给参数�Q?SPAN class=original_words>reset( )会把Matcher讑ֈ�当前字符串的开始处�?/P>
正则表达式与Java I/O

到目前�ؓ止，你看到的都是用正则表辑ּ�处理静态字�W�串的例子。下面我们来演示一下怎样用正则表辑ּ�扫描文�g�q�且扑և�匚w��的字�W�串。受Unix的grep启发�Q�我写了�?SPAN class=original_words>JGrep.java�Q�它需要两个参敎ͼ�文�g名，以及匚w��字符串用的正则表辑ּ�。它会把匚w��q�个正则表达式那部分内容及其所属行的行��h��印出来�?/P>

//: c12:JGrep.java // A very simple version of the "grep" program. // {Args: JGrep.java "\\b[Ssct]\\w+"} import java.io.*; import java.util.regex.*; import java.util.*; import com.bruceeckel.util.*; public class JGrep { public static void main(String[] args) throws Exception { if(args.length < 2) { System.out.println("Usage: java JGrep file regex"); System.exit(0); } Pattern p = Pattern.compile(args[1]); // Iterate through the lines of the input file: ListIterator it = new TextFile(args[0]).listIterator(); while(it.hasNext()) { Matcher m = p.matcher((String)it.next()); while(m.find()) System.out.println(it.nextIndex() + ": " + m.group() + ": " + m.start()); } } } ///:~

文�g是用TextFile打开�?本章的前半部分讲�?。由�?SPAN class=original_words>TextFile会把文�g的各行放�?SPAN class=original_words>ArrayList里面�Q�而我们又提取了一�?SPAN class=original_words>ListIterator�Q�因此我们可以在文�g的各行当中自��q��?既能向前也可以向�?�?

每行都会有一�?SPAN class=original_words>Matcher�Q�然后用find( )扫描。注意，我们�?SPAN class=original_words>ListIterator.nextIndex( )跟踪行号�?

��试参数�?SPAN class=original_words>JGrep.java和以[Ssct]开头的单词�?/P>
�q�需要StringTokenizer�?

看到正则表达式能提供�q�么强大的功能，你可能会怀疑，是不是还需要原先的StringTokenizer。JDK 1.4以前�Q�要惛_��割字�W�串�Q�只有用StringTokenizer。但现在�Q�有了正则表辑ּ�之后�Q�它��p��做得更干净利烦了�?/P>

//: c12:ReplacingStringTokenizer.java import java.util.regex.*; import com.bruceeckel.simpletest.*; import java.util.*; public class ReplacingStringTokenizer { private static Test monitor = new Test(); public static void main(String[] args) { String input = "But I'm not dead yet! I feel happy!"; StringTokenizer stoke = new StringTokenizer(input); while(stoke.hasMoreElements()) System.out.println(stoke.nextToken()); System.out.println(Arrays.asList(input.split(" "))); monitor.expect(new String[] { "But", "I'm", "not", "dead", "yet!", "I", "feel", "happy!", "[But, I'm, not, dead, yet!, I, feel, happy!]" }); } } ///:~

有了正则表达式，你就能用更复杂的模式��字�W�串分割开来——要是交�l?SPAN class=original_words>StringTokenizer的话�Q�事情会�ȝ��得多。我可以很有把握地说�Q�正则表辑ּ�可以取代StringTokenizer�?

要想�q�一步学习正则表辑ּ��Q�徏议你�?CITE>Mastering Regular Expression, 2nd Edition�Q�作者Jeffrey E. F. Friedl (O’Reilly, 2002)�?/P>
�ȝ��

Java的I/O��类库应该能满��你的基本需求：你可以用它来��d��控制収ͼ�文�g�Q�内存，甚至是Internet。你�q�可以利用��承来创徏新的输入和输出类型。你甚至可以利用Java会自动调用对象的toString( )�Ҏ��的特�?Java仅有�?自动�c�d��转换")�Q�通过重新定义�q�个�Ҏ��Q�来对要传给��的对象做一个简单的扩展�?/P>
但是Java的I/O��类库及其文档还是留下了一些缺憾。比方说你打开一个文件往里面写东西，但是�q�个文�g已经有了�Q�这么做会把原先的内容给覆盖�?。这时要是能有一个异常就好了——有些编�E�语�a�能让你规定只能往新徏的文仉��输出。看来Java是要你用File对象来判断文件是否存在，因�ؓ如果你用FileOutputStream�?SPAN class=original_words>FileWriter的话�Q�文件就会被覆盖了�?/P>
我对I/O��类库的评�h是比较矛盄��Q�它��实能干很多事情�Q�而且做到了跨�q�_��。但是如果你不懂decorator模式�Q�就会觉得这�U�设计太隄��解了�Q�所以无论是对老师�q�是学生�Q�都得多��q��力。此外这个类库也不完��_��否则我也用不着��d��TextFile了。此外它没有提供格式化输出的功能�Q�而其他语�a�都已�l�提供了�q�种功能�?/P>
但是�Q�一旦你真正理解了decorator模式�Q��ƈ且能开始灵�z�运用这个类库的时候，你就能感受到�q�种设计的好处了。这时多写几行代码就��不了什么了�?

如果你觉得不解��(本章只是做个介绍�Q�没惌��面面俱到)�Q�可以去看Elliotte Rusty Harold 写的Java I/O (O’Reilly, 1999)。这本书讲得更深�?/P>

bluesky 2005-11-07 17:06 发表评论

字符
B	字符B
\xhh	16�q�制�?SPAN class=original_words>0xhh所表示的字�W?/TD>
\uhhhh	16�q�制�?SPAN class=original_words>0xhhhh所表示的Unicode字符
\t	Tab
\n	换行�W?/TD>
\r	回�R�W?/TD>
\f	换页�W?/TD>
\e	Escape

字符�?/SPAN>
.	表示��L��一个字�W?
[abc]	表示字符a�Q?SPAN class=original_words>b�Q?SPAN class=original_words>c中的��L��一�?�?SPAN class=original_words>a\|b\|c相同)
[^abc]	�?SPAN class=original_words>a�Q?SPAN class=original_words>b�Q?SPAN class=original_words>c之外的�Q意一个字�W?否定)
[a-zA-Z]	�?SPAN class=original_words>a�?SPAN class=original_words>z�?SPAN class=original_words>A�?SPAN class=original_words>Z当中的�Q意一个字�W?范围)
[abc[hij]]	a,b,c,h,i,j中的��L��一个字�W?�?SPAN class=original_words>a\|b\|c\|h\|i\|j相同)(�q��)
[a-z&&[hij]]	h,i,j中的一�?交集)
\s	�I�格字符(�I�格�? tab, 换行, 换页, 回�R)
\S	非空格字�W?[^\s])
\d	一个数字，也就�?SPAN class=original_words>[0-9]
\D	一个非数字的字�W�，也就�?SPAN class=original_words>[^0-9]
\w	一个单词字�W?word character)�Q�即[a-zA-Z_0-9]
\W	一个非单词的字�W�，[^\w]

逻辑�q�算�W?
XY	X 后面跟着 Y
X\|Y	X或Y
(X)	一�?要匹配的�l?capturing group)". 以后可以用\i来表�C�第i个被匚w��的组�?/TD>

边界匚w��W?
^	一行的开�?
$	一行的�l�尾
\b	一个单词的边界
\B	一个非单词的边�?
\G	前一个匹配的�l�束

Greedy	Reluctant	Possessive	匚w��
X?	X??	X?+	匚w��一个或零个X
X*	X*?	X*+	匚w��零或多个X
X+	X+?	X++	匚w��一个或多个X
X{n}	X{n}?	X{n}+	匚w��正好n�?SPAN class=original_words>X
X{n,}	X{n,}?	X{n,}+	匚w��臛_��n�?SPAN class=original_words>X
X{n,m}	X{n,m}?	X{n,m}+	匚w��臛_��n个，臛_��m�?SPAN class=original_words>X

�~�译标志	效果
Pattern.CANON_EQ	当且仅当两个字符�?正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达�?a\u030A"会匹�??"。默认情况下�Q�不考虑"规范相等�?canonical equivalence)"�?
Pattern.CASE_INSENSITIVE (?i)	默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表辑ּ�忽略大小写进行匹配。要惛_��Unicode字符�q�行大小不明感的匚w��Q�只要将UNICODE_CASE与这个标志合��h��p��了�?
Pattern.COMMENTS (?x)	在这�U�模式下�Q�匹配时会忽�?正则表达式里�?�I�格字符(译者注�Q�不是指表达式里�?\\s"�Q�而是指表辑ּ�里的�I�格�Q�tab�Q�回车之�c?。注释从#开始，一直到�q�行�l�束。可以通过嵌入式的标志来启用Unix行模式�?
Pattern.DOTALL (?s)	在这�U�模式下�Q�表辑ּ�'.'可以匚w��L��字符�Q�包括表�C�Z��行的�l�束�W�。默认情况下�Q�表辑ּ�'.'不匹配行的结束符�?
Pattern.MULTILINE (?m)	在这�U�模式下�Q?^'�?$'分别匚w��一行的开始和�l�束。此外，'^'仍然匚w��字符串的开始，'$'也匹配字�W�串的结束。默认情况下�Q�这两个表达式仅仅匹配字�W�串的开始和�l�束�?
Pattern.UNICODE_CASE (?u)	在这个模式下�Q�如果你�q�启用了CASE_INSENSITIVE标志�Q�那么它会对Unicode字符�q�行大小写不明感的匹配。默认情况下�Q�大��写不明感的匚w��只适用于US-ASCII字符集�?
Pattern.UNIX_LINES (?d)	在这个模式下�Q�只�?\n'才被认作一行的中止�Q��ƈ且与'.'�Q?^'�Q�以�?$'�q�行匚w��?

bluesky — Mon, 07 Nov 2005 08:15:00 GMT
对象和类
面向对象�E�序设计(OOP)�Q�类是创建对象的模板或蓝图，从类中构造一个对象，卛_��Z��q�个�cȝ��一个实�?instance)�?
面向对象中，��装(encapsulation)是把数据和行为结合在一个包中，�q�对对象的��用者隐藏数据的实现�q�程�?
对象中的数据�U�Cؓ对象的实例字�D?instance field)�Q�操作数据的函数和过�E�称为对象的�Ҏ��(method)。实现封装的
关键在于决不让方法直接访问其他类的实例字�D�c��程序应该只能通过对象的方法和对象的数据交互。OOP的另一个原则，
�l�承�?inheritance)�Q��得很�Ҏ��在java中编写自��q��c?

对象
要��用OOP�Q�需要了解对象的三个主要�Ҏ��，分别�?
对象的行�?behavior) 对象能做什么，或者说�Q�能对对象施加什么方�?
对象的状�?state) 对对象施加方法时�Q�对象如何反�?
对象的��n�?identity) 对象如何与具有相同行为、状态的其他对象�怺�区别
�c�M��间的关系
依赖("use-a") 在A�c�M��的方法操作了B�c�d��象，那么A�c�M��赖于B�c?
聚合("has-a") A�c�d��象包含B�c�d��象，�q�包含C�c�d��象等�{�，聚合关系意味着�c�A的对象包含类B的对�?
�l�承("is-a") �l�承关系用来表示更特�D�的和更一般的�c�M��间的关系

对象和对象变�?/STRONG>
要��用对象，使用构造器(constructor)来构造新的实例。构造器是一个专门的�Ҏ��Q�构造器名称和类名相�?
因此Date�cȝ��构造器名�ؓDate。要构造Date对象�Q�只要在构造器前面加上new�q�算�W�就行了�Q�如new Date()
�q�个表达式即构造了一个新的对象，通常我们需要把对象存储在一个变量中 Date birthday = new Date();
birthday是一个对象变量，对象变量(birthday)指向新构造的对象(new Date)。对象变量�ƈ不包含对象，
它只是指向一个对象。在java中，��M��对象变量的值都是指向存储在别处的对象的一个引用。new �q�算�W�的�q�回
��g��是一个引用�?img src ="http://www.tkk7.com/bluesky/aggbug/18597.html" width = "1" height = "1" />

bluesky 2005-11-07 16:15 发表评论

bluesky — Mon, 07 Nov 2005 07:51:00 GMT

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ReadFile {
       public static void main(String[] args) throws IOException{
              File file = new File("D:\\test.txt");
              FileReader fileReader = new FileReader(file);
              String sx = fileReader.getEncoding();
              FileInputStream fileInputStream = new FileInputStream(file);
              InputStreamReader inputStramReader = new InputStreamReader(fileInputStream, "utf-8");
              BufferedReader bufferedReader = new BufferedReader(inputStramReader);
              String fileContent = "";
              String line = null;
              while ((line = bufferedReader.readLine()) != null) {
                     fileContent += line + "\n";
              }
       }

}

bluesky 2005-11-07 15:51 发表评论

代码中通过代理讉K��外部资源�Q��{��_��

bluesky — Mon, 07 Nov 2005 07:44:00 GMT
http://spaces.msn.com/members/savagardn/Blog/cns!1pzu-0W6-WxMGeUbOUArh6Eg!105.entry

目前�|�络上最��行的协议就是HTTP协议。HTTP协议有许多优点，例如它能够穿��防火墙。同时HTTP也是很多其他协议的基��Q�例如SOAP协议��是建立在HTTP协议之上的�?

Java通过两种API对HTTP提供支持�Q�一�U�是servlet API�Q�它覆盖了服务器端的�~�程问题�Q�另一�U�是java.net包，它通过HttpURLConnection�c�d��客户端提供了对HTTP协议的支持。但是我在��用servlet API的时候曾�l�遇到过一些问题。本文将介绍我曾遇到�q�的一些问题和相应的解军_��法�?

基础知识

通常在企业网�l�中�Q�一个终端通过代理服务器同互联�|�连接�v来，代理服务器负责监视网�l�流量和执行安全规则。在java.net API中，软�g可以通过两个属性来支持代理服务器，它们分别是http.proxyHost和http.proxyPort。它们必��被讑֮�为相应的代理服务器和端口�Q�下面的代码展示了如何设定这两个属性：

String url = "http://www.digitalcq.com/", proxy = "proxy.digitalcq.com", port = "8080"; URL server = new URL(url); Properties systemProperties = System.getProperties(); systemProperties.setProperty("http.proxyHost",proxy); systemProperties.setProperty("http.proxyPort",port); HttpURLConnection connection = ( HttpURLConnection)server.openConnection(); connection.connect(); InputStream in = connection.getInputStream(); readResponse(in);

在上面的�E�序中，你需要根据实际情况设定代理服务器和端口。如果你不知道该如何讄��的话�Q�可以询问你们公司的�|�络��理员�?

使用验证

通常公司会要求员工在�q�接��C��联网之前��d��C��理服务器。通过��d��q�种机制使公司可以更好的监控员工对互联网的��用，例如监控员工都访问了哪些�|�站。HttpURLConnection通过验证�c�L��持代理服务器验证。下面是一个如何利用HttpURLConnection�c�进行验证的例子。首先需要实��C��个验证者：

public class SimpleAuthenticator extends Authenticator { private String username, password; public SimpleAuthenticator(String username,String password) { this.username = username; this.password = password; } protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication( username,password.toCharArray()); } }

然后�Q�通过Authenticator.setDefault()�Ҏ��注册验证者：

String url = "http://www.digitalcq.com/", proxy = "proxy.digitalcq.com", port = "8080", username = "usr", password = "pwd"; Authenticator.setDefault(new SimpleAuthenticator( username,password)); URL server = new URL(url); Properties systemProperties = System.getProperties(); systemProperties.setProperty("http.proxyHost",proxy); systemProperties.setProperty("http.proxyPort",port); HttpURLConnection connection = ( HttpURLConnection)server.openConnection(); connection.connect(); InputStream in = connection.getInputStream(); readResponse(in);

问题

上面介绍的都是HttpURLConnection�c�能够正常工作的情况。但是我在实际情况中遇到了一些网�l�，在这些网�l�中�Q�HttpURLConnection�c�L��法正常工作。最后我发现关键的问题在于��用了不正��的DNS配置。在实际情况中，HttpURLConnection�c�L��L��先尝试利用DNS服务器来解析地址名称。通常情况下，�q�种��试会失败，而代理服务器会将�q�接重新定向。但是某些DNS服务器会�q�回一些不正确的响应，从而导致程序抛出UnknownHostException异常。作��Z��个程序员�Q�系�l�不会�ؓ了你的程序更改DNS服务器的配置�Q�因此你需要找��册��个问题的�Ҏ��。我的方案是通过自己实现HTTP协议来解册��个问题。例如一个GET命��o可以用下面的代码来实玎ͼ�

String url = "http://www.digitalcq.com/", proxy = "proxy.digitalcq.com", port = "8080", authentication = "usr:pwd"; URL server = new URL(url); Socket socket = new Socket(proxy,port); Writer writer = new OutputStreamWriter(socket.getOutputStream(), "US-ASCII"); writer.write("GET " + server.toExternalForm() + " HTTP/1.0\r\n"); writer.write("Host: " + server.getHost() + "\r\n"); writer.write("Proxy-Authorization: Basic " + new sun.misc.BASE64Encoder().encode( authentication.getBytes()) + "\r\n\r\n"); writer.flush(); BufferedReader reader = new BufferedReader(new InputStreamReader( socket.getInputStream(),"US-ASCII")); String line = reader.readLine(); if(line != null && line.startsWith("HTTP/")) { int sp = line.indexOf(' '); String status = line.substring(sp + 1,sp + 4); if(status.equals("200")) { while(line.length() != 0) line = reader.readLine(); readResponse(reader); } else throw new FileNotFoundException("Host reports error " + status); } else throw new IOException("Bad protocol"); reader.close(); writer.close(); socket.close();

在上面的代码中，大家可以注意��C��理服务器的用户名和密码的格式�?

username:password�Q?

�q�且�E�序对它们基于Base 64�q�行了编码。如果需要参考HTTP协议�Q�可以到http://www.ietf.org/rfc/rfc2616.txt�?

bluesky 2005-11-07 15:44 发表评论

bluesky — Mon, 07 Nov 2005 07:15:00 GMT

�c�L��把现实世界中��h��相同属性和行�ؓ的物体抽象出来，用来构造对象实体的模板�?/P>
�c�L��创徏对象的模�ѝ�?/P>
对象是类的实例�?/P>

bluesky 2005-11-07 15:15 发表评论