BlogJava-fjpan2002-文章分类-Java

Java异常处理之陋习展播（ZT）

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

java 异常

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

[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：" + rs.getString("uid") // ⑹

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

11 }

12 conn.close(); // ⑶

13 out.close();

14 }

15 catch(Exception ex) // ⑵

16 {

17 ex.printStackTrace(); //⑴，⑷

18 }
[/code:1:48e2a3bb92]

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。

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

　　反例之一：丢弃异常

　　代码：15行-18行。

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

　　这段代码的错误在于，异常（几乎）总是意味着某些事情不对劲了，或者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。

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

　　那么，应该怎样改正呢？主要有四个选择：

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

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常（其含义更容易被用户了解的异常）。

　　4、不要捕获异常。

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。

　　反例之二：不指定具体的异常

　　代码：15行。

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

　　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch(Exception ex)就相当于说我们想要处理几乎所有的异常。

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

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因，executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常，程序的其他地方还有捕获异常的机会——直至最后由JVM处理。

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。

　　反例之三：占用资源不释放

　　代码：3行-14行。

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally。

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

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

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

　　反例之四：不说明异常的详细信息

　　代码：3行-18行。

　　仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。

　　printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。

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

　　结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。

　　反例之五：过于庞大的try块

　　代码：3行-14行。

　　经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出来可不容易。

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception。

　　结论五：尽量减小try块的体积。

　　反例之六：输出数据不完整

　　代码：7行-11行。

　　不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次，catch块会执行——就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的（因而也是错误的）数据，却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。

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

　　结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。

　　改写后的代码

　　根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点啰嗦，但是它有了比较完备的异常处理机制。

[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：" + rs.getString("uid") +

"，姓名: " + rs.getString("name"));

}

catch(SQLException sqlex)

{

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

throw new ApplicationException(

"读取数据时出现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 - 不能关闭输出文件" +

ioex2.toString());

}

}
[/code:1:48e2a3bb92]

　　本文的结论不是放之四海皆准的教条，有时常识和经验才是最好的老师。如果你对自己的做法没有百分之百的信心，务必加上详细、全面的注释。
　　另一方面，不要笑话这些错误，不妨问问你自己是否真地彻底摆脱了这些坏习惯。即使最有经验的程序员偶尔也会误入歧途，原因很简单，因为它们确确实实带来了“方便”。所有这些反例都可以看作Java编程世界的恶魔，它们美丽动人，无孔不入，时刻诱惑着你。也许有人会认为这些都属于鸡皮蒜毛的小事，不足挂齿，但请记住：勿以恶小而为之，勿以善小而不为。

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

java面试题3

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

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

[基础问答]
1.下面哪些类可以被继承?
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.抽象类和接口的区别
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)

3.Hashtable的原理,并说出HashMap与Hashtable的区别
HashTable的原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址.
HashMap 与Hashtable很相似,但HashMap 是非同步(unsynchronizded)和可以以null为关键码的.

4.forward和redirect的区别
forward: an internal transfer in servlet
redirect: 重定向,有2次request,第2次request将丢失第一次的attributs/parameters等

5.什么是Web容器?
实现J2EE规范中web协议的应用.该协议定义了web程序的运行时环境,包括:并发性,安全性,生命周期管理等等.

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

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

8.XML的解析方法
Sax,DOM,JDOM

9.什么是Web Service?
Web Service就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。
Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
注：SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。

优势：
(1).跨平台；
(2).SOAP协议是基于XML和HTTP这些业界的标准的，得到了所有的重要公司的支持。
(3).由于使用了SOAP，数据是以ASCII文本的方式而非二进制传输，调试很方便；并且由于这样，它的数据容易通过防火墙，不需要防火墙为了程序而单独开一个“漏洞”。
(4).此外，WebService实现的技术难度要比CORBA和DCOM小得多。
(5).要实现B2B集成，EDI比较完善与比较复杂；而用WebService则可以低成本的实现，小公司也可以用上。
(6).在C/S的程序中，WebService可以实现网页无整体刷新的与服务器打交道并取数。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA。

10.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

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

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

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

2.文件读写,实现一个计数器
  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));            //可能是编码的原因，如果直接写入int的话，将出现java编码和windows编码的混乱，因此此处写入的是String
            out.close() ;
        }catch(Exception e){
            e.printStackTrace();
        }
    }
3. 指出下面程序的运行结果:
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(); //执行到此处,结果: 1a2b
ab = new B(); //执行到此处,结果: 1a2bab
    }
}
注:类的static 代码段,可以看作是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其本身的构造
4.写一个Singleton模式的例子
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的那种),那么:(sql server2000下测试通过)
delete from tableA where id not in
(select id = min(id) from tableA group by name)

2.delete from tablea ＆ truncate table tablea的区别
truncate 语句执行速度快,占资源少,并且只记录页删除的日志；
delete 对每条记录的删除均需要记录日志

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

java排序法

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

/*这个程序是我在一个帖子上看到的，觉得写的十分的不错，拿出来与大家共享下*/
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("选择法用时为：" + (end - begin));
    //打印排序好的结果
    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("冒泡法用时为：" + (end - begin));
    //打印排序好的结果
    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("插入法用时为：" + (end - begin));
    //打印排序好的结果
    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));
    //打印排序好的结果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
  }

}

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

package org.jr.util;
/**
* Company: JavaResearch(http://www.javaresearch.org)
* 最后更新日期:2003年3月4日
* @author Cherami
*/
import org.jr.*;
/**
* 排序工具类，提供常见的需要排序但是又没有实现Comparable接口的类。
* 此类也提供一些创建的排序算法的范例。
* @since 0.5
*/
public class CompareUtil {
/**
* 私有构造方法，防止类的实例化，因为工具类不需要实例化。
*/
private CompareUtil() {
}
/**
* 比较两个数字。
* 这个方法取Number的double值进行比较，因此只有在两个数严格相等的情况下才返回0，
* 又可能因为Java中Double型和Float的精度不同而导致两个相等的数不返回0。
* @param o1 第一个数字
* @param o2 第二个数字
* @return 第一个数字大于第二个返回1，等于返回0，否则返回－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;
}
}
/**
* 比较两个布尔型值。
* 如果两个的值不同，true被认为等于1，而false等于0。
* @param o1 第一个值
* @param o2 第二个值
* @return 第一个值大于第二个返回1，等于返回0，否则返回-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;
}
}
/**
* 冒泡排序法排序。
* @param objects 排序对象
* @param isAscent 排序顺序
* @return 排序后应该有的索引数组
* @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;
}
/**
* 冒泡排序法排序。
* @param objects 排序对象
* @param key 排序关键字
* @param isAscent 排序顺序
* @return 排序后应该有的索引数组
* @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;
}
/**
* 冒泡排序法排序。
* @param objects 排序对象
* @return 按照升序排序后应该有的索引数组
* @since 0.6
*/
public static int[] n2sort(Comparable[] objects) {
return n2sort(objects,true);
}
/**
* 冒泡排序法排序。
* @param objects 排序对象
* @param key 排序关键字
* @return 按照升序排序后应该有的索引数组
* @since 0.6
*/
public static int[] n2sort(PropertyComparable[] objects, int key) {
return n2sort(objects,key);
}
/**
* 插入排序法排序。
* @param objects 排序对象
* @return 按照升序排序后应该有的索引数组
* @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;
}
/**
* 插入排序法排序。
* @param objects 排序对象
* @param key 排序关键字
* @return 按照升序排序后应该有的索引数组
* @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;
}
/**
* 选择排序法排序。
* @param objects 排序对象
* @return 按照升序排序后应该有的索引数组
* @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;
//在未排序列表里面查找最小元素
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]]) <0 ) {
min = j;
}
}
//将最小的元素交换到未排序元素的最开始
swap(indexes,i,min);
}
return indexes;
}
/**
* 选择排序法排序。
* @param objects 排序对象
* @param key 排序关键字
* @return 按照升序排序后应该有的索引数组
* @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;
//在未排序列表里面查找最小元素
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]],key) <0 ) {
min = j;
}
}
//将最小的元素交换到未排序元素的最开始
swap(indexes,i,min);
}
return indexes;
}
/**
* 双向冒泡排序法排序。
* @param objects 排序对象
* @return 按照升序排序后应该有的索引数组
* @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;
}
/**
* 双向冒泡排序法排序。
* @param objects 排序对象
* @param key 排序关键字
* @return 按照升序排序后应该有的索引数组
* @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;
}
/**
* 交换两个元素的值。
* @param indexes 原索引数组
* @param i 第一行
* @param j 第二行
*/
private static void swap(int[] indexes, int i, int j) {
int tmp = indexes[i];
indexes[i] = indexes[j];
indexes[j] = tmp;
}
}
------------------------------------------
冒泡排序：
1、比较相邻的两个元素，如果后面的比前面小，就对调二者。反复比较，到最后两个元素。结果，最大值就跑到了最末位置。
2、反复第一步，直到所有较大值都跑到靠后的位置。
---------------------------------------------
选择排序
1、一开始整个数列是未排列的
2、从未排列的数中，挑选出最小的数，和未排列的数中的第一个元素互调，并将该最小的数归类到已排序的序列中；
3、重复第2步，直到所有的数都归类到已排序数列中。
---------------------------------------------
插入排序法：
1、一开始只有第一个数在已排序数列中，其他的数归类到未排序数列中；
2、将未排序的第一个数，插入到已排序数列中，使得插入后的已排序数列仍然维持由小到大的顺序；
3、重复步骤2，直到所有的数都在已排序数列中。
-----------------------------------------------

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

java面试收集（持续更新）-1 原贴编辑太慢了

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

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

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

java面试收集（持续更新）

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

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

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