亚洲13又紧又嫩又水多,亚洲一卡2卡4卡5卡6卡在线99,jlzzjlzz亚洲jzjzjz

勇敢的心 — Fri, 07 Jul 2006 01:53:00 GMT

java 异常

你觉得自己是一个Java专家吗？是否肯定自己已经全面掌握了Java的异常处理机�Ӟ��在下面这�D�代码中�Q�你能够�q�速找出异常处理的六个问题吗？

[code:1:48e2a3bb92]
1 OutputStreamWriter out = ...

2 java.sql.Connection conn = ...

3 try { // �?

4 Statement stat = conn.createStatement();

5 ResultSet rs = stat.executeQuery(

6 "select uid, name from user");

7 while (rs.next())

8 {

9 out.println("ID�Q? + rs.getString("uid") // �?

10 "�Q�姓名：" + rs.getString("name"));

11 }

12 conn.close(); // �?

13 out.close();

14 }

15 catch(Exception ex) // �?

16 {

17 ex.printStackTrace(); //��_��?

18 }
[/code:1:48e2a3bb92]

　　作�ؓ一个Java�E�序员，你至��应该能够找��Z��个问题。但是，如果你不能找出全部六个问题，��L��l�阅��L��文。�?

　　本文讨论的不是Java异常处理的一般性原则，因�ؓ�q�些原则已经被大多数人熟知。我们要做的是分析各�U�可�U�Cؓ“反例”（anti-pattern�Q�的�q�背优秀�~�码规范的常见坏习惯�Q�帮助读者熟悉这些典型的反面例子�Q�从而能够在实际工作中敏锐地察觉和避免这些问题。�?

　　反例之一�Q�丢弃异�?

　　代码�Q?5�?18行。�?

　　�q�段代码捕获了异常却不作��M��处理�Q�可以算得上Java�~�程中的杀手。从问题出现的频�J�程度和��害�E�度来看�Q�它也许可以和C/C++�E�序的一个恶名远播的问题相提�q�论——不��查缓冲区是否已满。如果你看到了这�U�丢弃（而不是抛出）异常的情况，可以癑ֈ�之九十九地肯定代码存在问题（在极��数情况下，�q�段代码有存在的理由�Q�但最好加上完整的注释�Q�以免引起别��解）。�?

　　�q�段代码的错误在于，异常�Q�几乎）��L��意味着某些事情不对劲了�Q�或者说臛_��发生了某些不��d��的事情，我们不应该对�E�序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace��不上“处理异常”。不错，调用printStackTrace对调试程序有帮助�Q�但�E�序调试阶段�l�束之后�Q�printStackTrace��׃��应再在异常处理模块中担负主要责�Q了。�?

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath�cȝ��文档�Q�可以看��C��面这�D�说明：“特别地�Q�虽然出现ThreadDeath是一�U�‘正常的情�Ş’，但ThreadDeath�c�L��Error而不是Exception的子�c�，因�ؓ许多应用会捕��h��有的Exception然后丢弃它不再理睬。”这�D�话的意思是�Q�虽然ThreadDeath代表的是一�U�普通的问题�Q�但鉴于许多应用会试图捕��h��有异常然后不予以适当的处理，所以JDK把ThreadDeath定义成了Error的子�c�，因�ؓError�c�M��表的是一般的应用不应该去捕获的严重问题。可见，丢弃异常�q�一坏习惯是如此常见�Q�它甚至已经影响��C��Java本��n的设计。�?

　　那么�Q�应该怎样�Ҏ��呢？主要有四个选择�Q��?

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个�h或进行其他一些处理，要根据具体的情�Ş��定应该采取的动作。再�ơ说明，调用printStackTrace��不上已�l�“处理好了异常”。�?

　　2、重新抛出异常。处理异常的代码在分析异�怹�后，认�ؓ自己不能处理它，重新抛出异常也不�׃ؓ一�U�选择。�?

　　3、把该异常�{换成另一�U�异常。大多数情况下，�q�是指把一个低�U�的异常转换成应用��的异常（其含义更�Ҏ��被用户了解的异常�Q�。�?

　　4、不要捕获异常。�?

　　�l�论一�Q�既然捕获了异常�Q�就要对它进行适当的处理。不要捕获异�怹�后又把它丢弃�Q�不予理睬。�?

　　反例之二�Q�不指定具体的异常�?

　　代码�Q?5行。�?

　　许多时候�h们会被这样一�U�“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是��用catch(Exception ex)语句。但实际上，在绝大多数情况下�Q�这�U�做法不值得提倡。�ؓ什么呢�Q��?

　　要理解其原因�Q�我们必��d��一下catch语句的用途。catch语句表示我们预期会出现某�U�异常，而且希望能够处理该异常。异常类的作用就是告诉Java�~�译器我们想要处理的是哪一�U�异常。由于绝大多数异帔R��直接或间接从java.lang.Exception�z��Q�catch(Exception ex)��q��当于说我们想要处理几乎所有的异常。�?

　　再来看看前面的代码例子。我们真正想要捕��L��异常是什么呢�Q�最明显的一个是SQLException�Q�这是JDBC操作中常见的异常。另一个可能的异常是IOException�Q�因为它要操作OutputStreamWriter。显�Ӟ��在同一个catch块中处理�q�两�U�截然不同的异常是不合适的。如果用两个catch块分别捕获SQLException和IOException��p��好多了。这��是��_��catch语句应当��量指定具体的异常类型，而不应该指定�늛�范围太广的Exception�c�R��?

　　另一斚w��Q�除了这两个特定的异常，�q�有其他许多异常也可能出现。例如，如果�׃��某种原因�Q�executeQuery�q�回了null�Q�该怎么办？�{�案是让它们�l�箋抛出�Q�即不必捕获也不必处理。实际上�Q�我们不能也不应该去捕获可能出现的所有异常，�E�序的其他地方还有捕获异常的��Z��——直��x��后由JVM处理。�?

　　�l�论二：在catch语句中尽可能指定具体的异常类型，必要时��用多个catch。不要试囑֤�理所有可能出现的异常。�?

　　反例之三�Q�占用资源不释放

　　代码�Q?�?14行。�?

　　异常改变了程序正常的执行��程。这个道理虽然简单，却常常被��Z��忽视。如果程序用��C��文�g、Socket、JDBC�q�接之类的资源，即��遇到了异常，也要正确释放占用的资源。�ؓ此，Java提供了一个简化这�c�L��作的关键词finally。�?

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理��d��的代码��L��有机会执行。遗憄��是有些�h却不习惯使用finally。�?

　　当然�Q�编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常——这是执行清理�Q务的最后机会，��量不要再有难以处理的错误。�?

　　�l�论三：保证所有资源都被正��释放。充分运用finally关键词。�?

　　反例之四�Q�不说明异常的详�l�信息�?

　　代码�Q?�?18行。�?

　　仔细观察�q�段代码�Q�如果��@环内部出��C��异常�Q�会发生什么事情？我们可以得到��_��的信息判断��@环内部出错的原因吗？不能。我们只能知道当前正在处理的�c�d��生了某种错误�Q�但却不能获得�Q何信息判断导致当前错误的原因。�?

　　printStackTrace的堆栈跟�t�功能显�C�出�E�序�q�行到当前类的执行流�E�，但只提供了一些最基本的信息，未能说明实际��D��错误的原因，同时也不易解诅R��?

　　因此�Q�在出现异常�Ӟ��最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一�U�更适合阅读的方式整理和�l�织printStackTrace提供的信息。�?

　　�l�论四：在异常处理模块中提供适量的错误原因信息，�l�织错误信息使其易于理解和阅诅R��?

　　反例之五�Q�过于庞大的try块�?

　　代码�Q?�?14行。�?

　　�l�常可以看到有�h把大量的代码攑օ�单个try块，实际上这不是好习惯。这�U�现象之所以常见，原因��在于有些�h囄��事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体�c�d��是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大��子�Q�虽然东西是带上了，但要扑և�来可不容易。�?

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception�Q�而不是分��d��个可能出现异常的�D�落�q�分别捕获其异常。这�U�做法�ؓ分析�E�序抛出异常的原因带来了困难�Q�因��Z��大段代码中有太多的地方可能抛出Exception。�?

　　�l�论五：��量减小try块的体积。�?

　　反例之六�Q�输出数据不完整

　　代码�Q?�?11行。�?

　　不完整的数据是Java�E�序的隐形杀手。仔�l�观察这�D�代码，考虑一下如果��@环的中间抛出了异常，会发生什么事情。��@环的执行当然是要被打断的�Q�其�ơ，catch块会执行——就�q�些�Q�再也没有其他动作了。已�l�输出的数据怎么办？使用�q�些数据的�h或设备将收到一份不完整的（因而也是错误的�Q�数据，却得不到��M��有关�q�䆾数据是否完整的提�C�。对于有些系�l�来��_��数据不完整可能比�pȝ��停止�q�行带来更大的损失。�?

　　较�ؓ理想的处�|�办法是向输��备写一些信息，声明数据的不完整性；另一�U�可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一�ơ性输出。�?

　　�l�论六：全面考虑可能出现的异�总�及这些异常对执行��程的媄响。�?

　　改写后的代码

　　�Ҏ��上面的讨论，下面�l�出改写后的代码。也许有��Z��说它�E�微有点啰嗦�Q�但是它有了比较完备的异常处理机制。�?

[code:1:48e2a3bb92]
OutputStreamWriter out = ...

java.sql.Connection conn = ...

try {

Statement stat = conn.createStatement();

ResultSet rs = stat.executeQuery(

"select uid, name from user");

while (rs.next())

{

out.println("ID�Q? + rs.getString("uid") +

"�Q�姓�? " + rs.getString("name"));

}

catch(SQLException sqlex)

{

out.println("警告�Q�数据不完整");

throw new ApplicationException(

"��d��数据时出现SQL错误", sqlex);

}

catch(IOException ioex)

{

throw new ApplicationException(

"写入数据时出现IO错误", ioex);

}

finally

{

if (conn != null) {

try {

conn.close();

}

catch(SQLException sqlex2)

{

System.err(this.getClass().getName() +

".mymethod - 不能关闭数据库连�? " +

sqlex2.toString());

}

if (out != null) {

try {

out.close();

}

catch(IOException ioex2)

{

System.err(this.getClass().getName() +

".mymethod - 不能关闭输出文�g" +

ioex2.toString());

}

}
[/code:1:48e2a3bb92]

　　本文的结��Z��是放之四��L��准的教条�Q�有时常识和�l�验才是最好的老师。如果你对自��q��做法没有癑ֈ�之百的信心，务必加上详细、全面的注释。�?
　　另一斚w��Q�不要笑话这些错误，不妨问问你自己是否真地彻底摆�׃��q�些坏习惯。即使最有经验的�E�序员偶��也会误入歧途，原因很简单，因�ؓ它们��确实实带来了“方侎쀝。所有这些反例都可以看作Java�~�程世界的恶��，它们��丽动�h�Q�无孔不入，时刻诱惑着你。也许有��Z��认�ؓ�q�些都属于鸡皮蒜毛的��事�Q�不��x��齿，但请��C��Q�勿以恶��而�ؓ之，勿以善小而不为�?

勇敢的心 2006-07-07 09:53 发表评论

java面试�?

勇敢的心 — Thu, 29 Dec 2005 02:53:00 GMT

��{�题�Q?BR>1、什么是数据库的事务�Q�事务的原子性？有几�U�方法可以实��C��务的原子性？
2、DOM是什么？SAX Parser和DOM Parser有何区别�Q?BR>3、同一机器中不同java虚拟机的�E�序有几�U�通讯方式�Q�不同机器的呢？
4、如何�v一个线�E�？如何�l�束一个线�E�？如何安全地结束一个线�E�？
以下为写具体代码题：
5、用java实现一个动态增长的堆栈�?BR>6、写一个读写锁�Q�可以同时多��Q�一个�h写，�q�用�q�个��d��锁实现生产者－消费者同步�?BR>7、写一个单例实玎ͼ��q�考虑当它实现可序列化接口的实现�?BR>8、写��L��一�U�排序方法，�q�说明如何将�q�个排序��法应用到Java Collection中�?BR>9、写一个程序判断一字节byte中有多少bit被置�??
思考题�Q?BR>10、有一个单向链表，不知道它的头�Q�有个指针P指向该链表中的节点N�Q�如何将节点N删除�Q?BR>

[基础问答]
1.下面哪些�c�d��以被�l�承?
java.lang.Thread (T)
java.lang.Number (T)
java.lang.Double (F)
java.lang.Math  (F)
java.lang.Void  (F)
java.lang.Class  (F)
java.lang.ClassLoader (T)

2.抽象�c�d��接口的区�?BR>(1)接口可以被多重implements,抽象�c�d��能被单一extends
(2)接口只有定义,抽象�c�d��以有定义和实�?BR>(3)接口的字�D�定义默认�ؓ:public static final, 抽象�c�d��D�默认是"friendly"(本包可见)

3.Hashtable的原�?�q�说出HashMap与Hashtable的区�?BR>HashTable的原�?通过节点的关键码��定节点的存储位�|?即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),��此��D��释�ؓ该节点的存储地址.
HashMap 与Hashtable很相�?但HashMap 是非同步(unsynchronizded)和可以以null为关键码�?

4.forward和redirect的区�?BR>forward: an internal transfer in servlet
redirect: 重定�?�?�ơrequest,�W?�ơrequest��丢��q��一�ơ的attributs/parameters�{?BR>
5.什么是Web容器?
实现J2EE规范中web协议的应�?该协议定义了web�E�序的运行时环境,包括:�q�发�?安全�?生命周期��理�{�等.

6.解释下面关于J2EE的名�?BR>(1)JNDI:Java Naming & Directory Interface,JAVA命名目录服务.主要提供的功能是�Q�提供一个目录系�l�，让其它各地的应用�E�序在其上面留下自己的烦引，从而满��_��速查扑֒�定位分布式应用程序的功能.
(2)JMS�Q�Java Message Service,JAVA消息服务.主要实现各个应用�E�序之间的通讯.包括点对点和�q�播.
(3)JTA�Q�Java Transaction API,JAVA事务服务.提供各种分布式事务服�?应用�E�序只需调用其提供的接口卛_��.
(4)JAF: Java Action FrameWork,JAVA安全认证框架.提供一些安全控制方面的框架.让开发者通过各种部��v和自定义实现自己的个性安全控制策�?
(5)RMI:Remote Method Interface,�q�程�Ҏ��调用

7.EJB是基于哪些技术实现的�Q��ƈ�?nbsp;出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区�?
EJB包括Session Bean、Entity Bean、Message Driven Bean�Q�基于JNDI、RMI、JAT�{�技术实�?
SessionBean在J2EE应用�E�序中被用来完成一些服务器端的业务操作�Q�例如访问数据库、调用其他EJB�l��g.EntityBean被用来代表应用系�l�中用到的数�?对于客户机，SessionBean是一�U�非持久性对象，它实现某些在服务器上�q�行的业务逻辑;EntityBean是一�U�持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用�E�序实现的实�?
Session Bean �q�可以再�l�分�?nbsp;Stateful Session Bean �?nbsp;Stateless Session Bean .�q�两�U�的 Session Bean都可以将�pȝ��逻辑攑֜� method之中执行�Q�不同的�?nbsp;Stateful Session Bean 可以记录呼叫者的状态，因此通常来说�Q�一个��用者会有一个相对应�?nbsp;Stateful Session Bean 的实�?Stateless Session Bean 虽然也是逻辑�l��g�Q�但是他却不负责记录使用者状态，也就是说当��用者呼�?nbsp;Stateless Session Bean 的时候，EJB Container �q�不会找�ȝ��定的 Stateless Session Bean 的实体来执行�q�个 method.换言之，很可能数个��用者在执行某个 Stateless Session Bean �?nbsp;methods �Ӟ��会是同一�?nbsp;Bean �?nbsp;Instance 在执�?从内存方面来看， Stateful Session Bean �?nbsp;Stateless Session Bean 比较�Q?nbsp;Stateful Session Bean 会消�?nbsp;J2EE Server 较多的内存，然�?nbsp;Stateful Session Bean 的优势却在于他可以维持��用者的状�?

8.XML的解析方�?BR>Sax,DOM,JDOM

9.什么是Web Service?
Web Service��是��Z��使原来各孤立的站点之间的信息能够�怺�通信、共享而提出的一�U�接口�?BR>Web Service所使用的是Internet上统一、开攄��标准�Q�如HTTP、XML、SOAP�Q�简单对象访问协议）、WSDL�{�，所以Web Service可以在�Q何支持这些标准的环境�Q�Windows,Linux�Q�中使用�?BR>注：SOAP协议�Q�Simple Object Access Protocal,��单对象访问协议）,它是一个用于分散和分布式环境下�|�络信息交换的基于XML的通讯协议。在此协议下�Q��Y件组件或应用�E�序能够通过标准的HTTP协议�q�行通讯。它的设计目标就是简单性和扩展性，�q�有助于大量异构�E�序和��^��C��间的互操作性，从而��存在的应用程序能够被�q�泛的用戯��问�?BR>
优势�Q?BR>(1).跨��^収ͼ�
(2).SOAP协议是基于XML和HTTP�q�些业界的标准的�Q�得��C��所有的重要公司的支持�?BR>(3).�׃��使用了SOAP�Q�数据是以ASCII文本的方式而非二进制传输，调试很方便；�q�且�׃��q�样�Q�它的数据容易通过防火墙，不需要防火墙��Z��E�序而单独开一个“漏�z�”�?BR>(4).此外�Q�WebService实现的技术难度要比CORBA和DCOM��得多�?BR>(5).要实现B2B集成�Q�EDI比较完善与比较复杂；而用WebService则可以低成本的实玎ͼ��公�怹�可以用上�?BR>(6).在C/S的程序中�Q�WebService可以实现�|�页无整体刷新的与服务器打交道�ƈ取数�?BR>�~�点�Q?BR>(1).WebService使用了XML�Ҏ��据封装，会造成大量的数据要在网�l�中传输�?BR>(2).WebService规范没有规定��M��与实现相关的�l�节�Q�包括对象模型、编�E�语�a��Q�这一点，它不如CORBA�?BR>
10.多线�E�有几种实现�Ҏ��,都是什�?同步有几�U�实现方�?都是什�?
�{�：多线�E�有两种实现�Ҏ��Q�分别是�l�承Thread�c�M��实现Runnable接口
同步的实现方面有两种�Q�分别是synchronized,wait与notify

11.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现

它��L��会检查所含文件中的变化，适合用于包含动态页面，�q�且可以带参�?BR>静态INCLUDE用include伪码实现,定不会检查所含文件的变化�Q�适用于包含静态页�?BR><%@ include file="included.htm" %>

[Java�~�程与程序运行结果]
1.Java�~�程,打印昨天的当前时�?BR>public class YesterdayCurrent{
  public void main(String[] args){
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DATE, -1);
    System.out.println(cal.getTime());
  }
}

2.文�g��d��,实现一个计数器
  public int getNum(){
        int i = -1;
        try{
            String stri="";
            BufferedReader in = new BufferedReader(new FileReader(f));
            while((stri=in.readLine())!=null){
                i = Integer.parseInt(stri.trim());
            }
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return i;
    }
    public void setNum(){
        int i = getNum();
        i++;
        try{
            PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(f,false)));
            out.write(String.valueOf(i));            //可能是编码的原因�Q�如果直接写入int的话�Q�将出现java�~�码和windows�~�码的�؜乱，因此此处写入的是String
            out.close() ;
        }catch(Exception e){
            e.printStackTrace();
        }
    }
3. 指出下面�E�序的运行结�?
class A{
    static{
        System.out.print("1");
    }
    public A(){
        System.out.print("2");
    }
}
class B extends A{
    static{
        System.out.print("a");
    }
    public B(){
        System.out.print("b");
    }
}
public class Hello{
    public static void main(String[] ars){
        A ab = new B(); //执行到此�?�l�果: 1a2b
ab = new B(); //执行到此�?�l�果: 1a2bab
    }
}
�?�cȝ��static 代码�D?可以看作是类首次加蝲(被虚拟机加蝲)执行的代�?而对于类的加�?首先要执行其基类的构�?再执行其本��n的构�?BR>4.写一个Singleton模式的例�?BR>public class Singleton{
private static Singleton single = new Singleton();
private Singleton(){}
public Singleton getInstance(){
  return single;
}
}

[数据库]
1.删除表的重复记录
如果记录完全相同才算重复记录,那么:  (sql server2000下测试通过)
select distinct * into #tmpp from tid
delete from tid
insert into tid select * from #tmpp
drop table #tmpp
如果有id主键(数字,自增1的那�U?,那么:(sql server2000下测试通过)
delete from tableA where id not in
(select id = min(id) from tableA group by name)

2.delete from tablea �Q?nbsp;truncate table tablea的区�?BR>truncate 语句执行速度�?占资源少,�q�且只记录页删除的日志；
delete �Ҏ��条记录的删除均需要记录日�?BR>

勇敢的心 2005-12-29 10:53 发表评论

勇敢的心 — Mon, 05 Dec 2005 12:24:00 GMT

/*�q�个�E�序是我在一个帖子上看到的，觉得写的十分的不错，拿出来与大家�׃�n�?/
package com.cucu.test;

public class Sort {

  public void swap(int a[], int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
  }

  public int partition(int a[], int low, int high) {
    int pivot, p_pos, i;
    p_pos = low;
    pivot = a[p_pos];
    for (i = low + 1; i <= high; i++) {
      if (a[i] > pivot) {
        p_pos++;
        swap(a, p_pos, i);
      }
    }
    swap(a, low, p_pos);
    return p_pos;
  }

  public void quicksort(int a[], int low, int high) {
    int pivot;
    if (low < high) {
      pivot = partition(a, low, high);
      quicksort(a, low, pivot - 1);
      quicksort(a, pivot + 1, high);
    }

  }

  public static void main(String args[]) {
    int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
    int temp;
    //选择排序�?Selection Sort)
    long begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length; j++) {
          if (vec[j] > vec[i]) {
            temp = vec[i];
            vec[i] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    long end = System.currentTimeMillis();
    System.out.println("选择法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
    //  冒��排序�?Bubble Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length - 1; j++) {
          if (vec[j + 1] > vec[j]) {
            temp = vec[j + 1];
            vec[j + 1] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    end = System.currentTimeMillis();
    System.out.println("冒��法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //插入排序�?Insertion Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 1; i < vec.length; i++) {
        int j = i;
        while (vec[j - 1] < vec[i]) {
          vec[j] = vec[j - 1];
          j--;
          if (j <= 0) {
            break;
          }
        }
        vec[j] = vec[i];
      }
    }
    end = System.currentTimeMillis();
    System.out.println("插入法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //快速排序法(Quick Sort)

    Sort s = new Sort();
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      s.quicksort(vec, 0, 5);
    }
    end = System.currentTimeMillis();
    System.out.println("快速法用时为：" + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
  }

}

************************************************************************************

package org.jr.util;
/**
* Company: JavaResearch(http://www.javaresearch.org)
* 最后更新日�?2003�q?�?�?/FONT>
* @author Cherami
*/
import org.jr.*;
/**
* 排序工具�c�，提供常见的需要排序但是又没有实现Comparable接口的类�?/FONT>
* 此类也提供一些创建的排序��法的范例�?/FONT>
* @since 0.5
*/
public class CompareUtil {
/**
* �U�有构造方法，防止�cȝ��实例化，因�ؓ工具�c�M��需要实例化�?/FONT>
*/
private CompareUtil() {
}
/**
* 比较两个数字�?/FONT>
* �q�个�Ҏ��取Number的double��D��行比较，因此只有在两个数严格相等的情况下才返�?�Q?/FONT>
* 又可能因为Java中Double型和Float的精度不同而导致两个相�{�的��C��q�回0�?/FONT>
* @param o1 �W�一个数�?/FONT>
* @param o2 �W�二个数�?/FONT>
* @return �W�一个数字大于第二个�q�回1�Q�等于返�?�Q�否则返回－1
* @since 0.5
*/
public static int compare(Number o1, Number o2) {
double n1 = o1.doubleValue();
double n2 = o2.doubleValue();
if (n1 < n2) {
return -1;
}
else if (n1 > n2) {
return 1;
}
else {
return 0;
}
}
/**
* 比较两个布尔型倹{�?/FONT>
* 如果两个的��g��同，true被认为等�?�Q�而false�{�于0�?/FONT>
* @param o1 �W�一个�?/FONT>
* @param o2 �W�二个�?/FONT>
* @return �W�一个值大于第二个�q�回1�Q�等于返�?�Q�否则返�?1
* @since 0.5
*/
public static int compare(Boolean o1, Boolean o2) {
boolean b1 = o1.booleanValue();
boolean b2 = o2.booleanValue();
if (b1 == b2) {
return 0;
}
else if (b1) {
return 1;
}
else {
return -1;
}
}
/**
* 冒��排序法排序�?/FONT>
* @param objects 排序对象
* @param isAscent 排序��序
* @return 排序后应该有的烦引数�l?/FONT>
* @since 0.5
*/
public static int[] n2sort(Comparable[] objects, boolean isAscent) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (isAscent == true) {
if (objects[indexes[i]].compareTo(objects[indexes[j]]) > 0) {
swap(indexes, i, j);
}
}
else {
if (objects[indexes[i]].compareTo(objects[indexes[j]]) < 0) {
swap(indexes, i, j);
}
}
}
}
return indexes;
}
/**
* 冒��排序法排序�?/FONT>
* @param objects 排序对象
* @param key 排序关键�?/FONT>
* @param isAscent 排序��序
* @return 排序后应该有的烦引数�l?/FONT>
* @since 0.5
*/
public static int[] n2sort(PropertyComparable[] objects, int key,
boolean isAscent) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (isAscent == true) {
if (objects[indexes[i]].compareTo(objects[indexes[j]], key) > 0) {
swap(indexes, i, j);
}
}
else {
if (objects[indexes[i]].compareTo(objects[indexes[j]], key) < 0) {
swap(indexes, i, j);
}
}
}
}
return indexes;
}
/**
* 冒��排序法排序�?/FONT>
* @param objects 排序对象
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] n2sort(Comparable[] objects) {
return n2sort(objects,true);
}
/**
* 冒��排序法排序�?/FONT>
* @param objects 排序对象
* @param key 排序关键�?/FONT>
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] n2sort(PropertyComparable[] objects, int key) {
return n2sort(objects,key);
}
/**
* 插入排序法排序�?/FONT>
* @param objects 排序对象
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] insertionSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 1; i < length; i++) {
int j = i;
Comparable B = objects[indexes[i]];
while ((j > 0) && (objects[indexes[j-1]].compareTo(B) > 0)) {
indexes[j] = indexes[j-1];
j--;
}
indexes[j] = i;
}
return indexes;
}
/**
* 插入排序法排序�?/FONT>
* @param objects 排序对象
* @param key 排序关键�?/FONT>
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] insertionSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 1; i < length; i++) {
int j = i;
Comparable B = objects[indexes[i]];
while ((j > 0) && (objects[indexes[j-1]].compareTo(B,key) > 0)) {
indexes[j] = indexes[j-1];
j--;
}
indexes[j] = i;
}
return indexes;
}
/**
* 选择排序法排序�?/FONT>
* @param objects 排序对象
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] selectionSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
int min = i;
int j;
//在未排序列表里面查找最��元�?/FONT>
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]]) <0 ) {
min = j;
}
}
//��最��的元素交换到未排序元素的最开�?/FONT>
swap(indexes,i,min);
}
return indexes;
}
/**
* 选择排序法排序�?/FONT>
* @param objects 排序对象
* @param key 排序关键�?/FONT>
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] selectionSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
int min = i;
int j;
//在未排序列表里面查找最��元�?/FONT>
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]],key) <0 ) {
min = j;
}
}
//��最��的元素交换到未排序元素的最开�?/FONT>
swap(indexes,i,min);
}
return indexes;
}
/**
* 双向冒��排序法排序�?/FONT>
* @param objects 排序对象
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] bidirectionalBubbleSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
int j;
int limit = objects.length;
int start = -1;
while (start < limit) {
start++;
limit--;
for (j = start; j < limit; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
for (j = limit; --j >= start;) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
}
return indexes;
}
/**
* 双向冒��排序法排序�?/FONT>
* @param objects 排序对象
* @param key 排序关键�?/FONT>
* @return 按照升序排序后应该有的烦引数�l?/FONT>
* @since 0.6
*/
public static int[] bidirectionalBubbleSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
int j;
int limit = objects.length;
int start = -1;
while (start < limit) {
start++;
limit--;
for (j = start; j < limit; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
for (j = limit; --j >= start;) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]],key) > 0) {
swap(indexes,j,j+1);
}
}
}
return indexes;
}
/**
* 交换两个元素的倹{�?/FONT>
* @param indexes 原烦引数�l?/FONT>
* @param i �W�一�?/FONT>
* @param j �W�二�?/FONT>
*/
private static void swap(int[] indexes, int i, int j) {
int tmp = indexes[i];
indexes[i] = indexes[j];
indexes[j] = tmp;
}
}
------------------------------------------
冒��排序�Q?
1、比较相�ȝ��两个元素�Q�如果后面的比前面小�Q�就对调二者。反复比较，到最后两个元素。结果，最大值就跑到了最末位�|��?
2、反复第一步，直到所有较大值都跑到靠后的位�|��?/P>
---------------------------------------------
选择排序
1、一开始整个数列是未排列的
2、从未排列的��C��Q�挑选出最��的敎ͼ�和未排列的数中的�W�一个元素互调，�q�将该最��的数归�c�d��已排序的序列中；
3、重复第2步，直到所有的数都归类到已排序数列中�?/P>
---------------------------------------------
插入排序法：
1、一开始只有第一个数在已排序数列中，其他的数归类到未排序数列中；
2、将未排序的�W�一个数�Q�插入到已排序数列中�Q��得插入后的已排序数列仍然�l�持由小到大的顺序；
3、重复步�?�Q�直到所有的数都在已排序数列中�?/P>
-----------------------------------------------

勇敢的心 2005-12-05 20:24 发表评论

勇敢的心 — Mon, 28 Nov 2005 07:24:00 GMT

摘要: 91、应用服务器与WEB SERVER的区别？通俗的讲�Q�Web服务器传�?serves)��面使浏览器可以��览�Q�然而应用程序服务器提供的是客户端应用程序可以调�?call)的方�?methods)。确切一点，你可以说�Q�Web服务器专门处理HTTP��h��(request)�Q�但是应用程序服务器是通过很多协议来�ؓ应用�E�序提供(serves)商业逻辑(business logic)�?2、BS与CS的联�p�M��?.. 阅读全文

勇敢的心 2005-11-28 15:24 发表评论

java面试攉��Q�持�l�更斎ͼ�

勇敢的心 — Mon, 28 Nov 2005 05:05:00 GMT

摘要: 一、Java基础1、谈谈final, finally, finalize的区别。final—修饰符�Q�关键字�Q�如果一个类被声明�ؓfinal�Q�意味着它不能再�z��出新的子�c�，不能作�ؓ父类被��ѝ��因此一个类不能既被声明�?abstract的，又被声明为final的。将变量或方法声明�ؓfinal�Q�可以保证它们在使用中不被改变。被声明为final的变量必��d��声明时给定初��|��而在以后的引用中只能��d��Q�不可修攏V�?.. 阅读全文

勇敢的心 2005-11-28 13:05 发表评论

亚洲13又紧又嫩又水多,亚洲一卡2卡4卡5卡6卡在线99,jlzzjlzz亚洲jzjzjz

java面试�?

java面试攉����Q�持�l�更斎ͼ�

java面试攉��Q�持�l�更斎ͼ�