import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.CollationKey;
import java.text.Collator;
import java.text.RuleBasedCollator;
import java.util.*;

/**
 * <strong>Title : ListComparator </strong>. <br>
 * <strong>Description : List排序器（支持中文排序）.</strong> <br>
  */
public class ListComparator implements Comparator {

 /**
  * <code>collator</code> - 排序规则控制器.
  */
 private RuleBasedCollator collator = (RuleBasedCollator) Collator
   .getInstance(java.util.Locale.CHINA);

 /**
  * <code>methodName</code> - 排序字段的方法名.
  */
 private String methodName;

 /**
  * <code>seq</code> - 排序顺序.
  */
 private String seq;

 /**
  * <code>methodeArgs</code> - 方法参数.
  */
 private Object[] methodeArgs;

 /**
  * 构造函数(List中存放复杂对象，并且获得排序字段值的方法需要参数).
  *
  * @param methodName
  *            -对象中的方法名
  * @param methodeArgs
  *            -方法参数
  * @param seq
  *            -排序顺序
  * @throws Exception
  */
 public ListComparator(String methodName, Object[] methodeArgs, String seq)
   throws Exception {

  this.methodName = methodName;

  this.methodeArgs = methodeArgs;

  if (!"asc".equalsIgnoreCase(seq) && !"desc".equalsIgnoreCase(seq)) {

   throw new Exception("illegal value of parameter 'seq' for input '"
     + seq + "'");
  }

  this.seq = seq;
 }

 /**
  * 构造函数(List中存放复杂对象，并且获得排序字段值的方法不需要参数).
  *
  * @param methodName
  * @param seq
  * @throws Exception
  */
 public ListComparator(String methodName, String seq) throws Exception {

  this.methodName = methodName;

  if (!"asc".equalsIgnoreCase(seq) && !"desc".equalsIgnoreCase(seq)) {

   throw new Exception("illegal value of parameter 'seq' for input '"
     + seq + "'");
  }

  this.seq = seq;

 }

 /**
  * 构造函数(List中存放简单对象).
  *
  * @param seq
  * @throws Exception
  */
 public ListComparator(String seq) throws Exception {

  if (!"asc".equalsIgnoreCase(seq) && !"desc".equalsIgnoreCase(seq)) {

   throw new Exception("illegal value of parameter 'seq' for input '"
     + seq + "'");
  }

  this.seq = seq;
 }

 /**
  * (non-Javadoc).
  *
  * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
  */
 public int compare(Object obj1, Object obj2) {

  int t_ret = 0;

  // 如果指定了方法名，则表示List中存放的是复杂对象
  if (this.methodName != null && !"".equals(this.methodName)) {

   // 执行Bean中的方法，得到方法返回的对象
   Object t_obj1 = invokeMethod(obj1, this.methodName,
     this.methodeArgs);
   Object t_obj2 = invokeMethod(obj2, this.methodName,
     this.methodeArgs);

   t_ret = selectCompare(t_obj1, t_obj2);

  } else {

   t_ret = selectCompare(obj1, obj2);

  }

  return t_ret;
 }

 /**
  * 执行对象的某个方法.
  *
  * @param owner
  *            -对象
  * @param methodName
  *            -方法名
  * @param methodArgs
  *            -方法参数
  *
  * @return 方法返回对象
  * @throws InvocationTargetException
  * @throws IllegalAccessException
  * @throws IllegalArgumentException
  * @throws Exception
  */
 private Object invokeMethod(Object owner, String methodName,
   Object[] methodArgs) {

  Class[] argsClass = null;

  if (methodArgs != null && methodArgs.length > 0) {

   argsClass = new Class[methodeArgs.length];

   for (int i = 0, j = methodeArgs.length; i < j; i++) {

    argsClass[i] = methodeArgs[i].getClass();
   }
  }

  Class ownerClass = owner.getClass();

  Method method;
  Object t_object = null;
  try {
   method = ownerClass.getMethod(methodName, argsClass);
   t_object = method.invoke(owner, methodArgs);
  } catch (SecurityException e) {
  } catch (NoSuchMethodException e) {

   argsClass = new Class[1];
   argsClass[0] = Object.class;
   try {
    method = ownerClass.getMethod(methodName, argsClass);
    t_object = method.invoke(owner, methodArgs);
   } catch (SecurityException e1) {
   } catch (NoSuchMethodException e1) {
   } catch (IllegalArgumentException e1) {
   } catch (IllegalAccessException e1) {
   } catch (InvocationTargetException e1) {
   }

  } catch (IllegalArgumentException e) {
  } catch (IllegalAccessException e) {
  } catch (InvocationTargetException e) {
  }

  return t_object;
 }

 private int selectCompare(Object obj1, Object obj2) {

  int t_ret = 0;

  if (obj1 instanceof String && obj2 instanceof String) {

   t_ret = compareString(obj1, obj2);
  }

  if (obj1 instanceof Integer && obj2 instanceof Integer) {

   t_ret = compareInt(obj1, obj2);
  }

  if (obj1 instanceof Long && obj2 instanceof Long) {

   t_ret = compareLong(obj1, obj2);
  }

  if (obj1 instanceof Date && obj2 instanceof Date) {

   t_ret = compareDate(obj1, obj2);
  }

  return t_ret;
 }

 private int compareString(Object obj1, Object obj2) {

  int ret = 0;

  String s1 = (String) obj1;
  String s2 = (String) obj2;

  CollationKey c1 = collator.getCollationKey(s1);
  CollationKey c2 = collator.getCollationKey(s2);

  ret = collator.compare(c1.getSourceString(), c2.getSourceString());

  if (seq.equalsIgnoreCase("desc")) {

   ret = ret * -1;
  }

  return ret;
 }

 private int compareInt(Object obj1, Object obj2) {

  int ret = 0;

  int i1 = ((Integer) obj1).intValue();
  int i2 = ((Integer) obj2).intValue();

  if (i1 < i2)
   ret = -1;
  else if (i1 > i2)
   ret = 1;
  else
   ret = 0;

  if (seq.equalsIgnoreCase("desc")) {

   ret = ret * -1;
  }

  return ret;
 }

 private int compareLong(Object obj1, Object obj2) {

  int ret = 0;

  long l1 = ((Long) obj1).longValue();
  long l2 = ((Long) obj2).longValue();

  if (l1 < l2)
   ret = -1;
  else if (l1 > l2)
   ret = 1;
  else
   ret = 0;

  if (seq.equalsIgnoreCase("desc")) {

   ret = ret * -1;
  }

  return ret;
 }

 private int compareDate(Object obj1, Object obj2) {

  int ret = 0;

  Date d1 = (Date) obj1;
  Date d2 = (Date) obj2;

  ret = d1.compareTo(d2);

  if (seq.equalsIgnoreCase("desc")) {

   ret = ret * -1;
  }

  return ret;
 }
}



-------------------------------------------------------------------
使用
-------------------------------------------------------------------
private List getSortedList(List unsortedList, String methodName,
   Object methodArgs[], String orderSequence) throws Exception {

  ListComparator t_compare = null;

  if (null != methodName && !"".equals(methodName)) {

   if (methodArgs != null && methodArgs.length > 0)
    t_compare = new ListComparator(methodName, methodArgs,
      orderSequence);
   else
    t_compare = new ListComparator(methodName, orderSequence);
  } else {
   t_compare = new ListComparator(orderSequence);
  }

  List t_list = unsortedList;

  Collections.sort(t_list, t_compare);

  return t_list;
 }

类集包含一个add(Object obj)方法，因此可以包含任意Object数据，但是不能直接存储：int，char,Double等数据。可以使用下面的方法实现：
ArrayList a=new ArrayList();
a.add(new Integer(1));
a.add(new Integer(2));
……

当类集不能被修改时，可能引发 UnsupportedOperationException异常。企图将一个不兼容的对象加入到一个类集中时可能引发ClassCastException异常。

List接口（从Collection继承而来，使用基于0的下标）
void add(int index,Object obj) 插入点以后的元素将后移
boolean addAll(int index,Collection c) 如果调用列表改变了，返回true,否则返回false
Object get(int index)
int indexOf(Object obj) 返回obj对象在列表中的索引，不存在返回-1
int lastIndexOf(Object obj) 返回obj在列表中的最后一个实例的下标，不存在返回-1
ListIterator listIterator()
ListIterator listIterator(int index) 返回index开始的迭代程序
Object set(int index,Object obj) 对列表index处的值进行修改
List subList(int start,int end) 从start到end-1
 

Set接口（从Collection派生，没有定义新的方法）
Set不允许有重复的元素。
对Set调用add（Object obj）方法，如果obj已经存在集合中，将返回false。

SortedSet接口
Comparator comparator() 返回调用排序集合的比较函数，如果改集合使用自然顺序，则返回null
Object first() 返回被排序集合的第一个元素
SortedSet headSet(Object end) 返回一个包含小于end元素的SortedSet
Object last() 返回调用排序集合的最后一个元素
SortedSet subSet(Object start,Object end) 包括从start到end-1
SortedSet tailSet(Object start) 返回包含大于等于start的元素
 

ArrayList扩展AstractList类，并执行List接口。ArrayList支持动态长度的数组。
LinkList扩展了AbstractSequentialList，执行List接口。提供连接列表。
HashSet扩展AbstractSet实现Set接口，元素没有顺序。对于大集合提供常量级基本操作。
TreeSet使用树来存储的Set，对象按升序存储。访问和检索非常快。

iterator实现Iterator接口或者ListIterator接口。
Iterator接口
boolean hasNext()
Object next() 如果没有下一个元素则引发NoSuchElementException异常。
void remove() 删除当前元素，如果试图在调用next()方法后调用remove()方法则引发IllegalStateException异常。
 
 

ListIterator接口
void add(Object obj) 将一个元素插入到当前元素之前，调用next()方法将返回该元素。
boolean hasNext()
boolean hasPrevious()
Object next() 如果不存在引发NoSuchElementException
int nextIndex() 如果不存在返回列表的大小
void remove()
void set(Object obj) 修改当前元素

public void test1() {
  ArrayList al = new ArrayList();
  for (int i = 1; i < 10; i++) {
  al.add("ArrayList Element:" + i);
  }
  Iterator itr = al.listIterator();
  while (itr.hasNext()) {
  Object obj = itr.next();
  System.out.println(obj);
  }
  }

public void test2() {
  HashSet hs = new HashSet();
  System.out.println("HashSet");
  for (int i = 1; i < 10; i++) {
  hs.add("HashSet Element:" + i);
  }
  Iterator itr = hs.iterator();
  while (itr.hasNext()) {
  Object obj = itr.next();
  System.out.println(obj);
  }
  }

  public void test3() {
  TreeSet ts = new TreeSet();
  System.out.println("TreeSet");
  for (int i = 1; i < 10; i++) {
  ts.add("TreeSet Element:" + i);
  }
  Iterator itr = ts.iterator();
  while (itr.hasNext()) {
  Object obj = itr.next();
  System.out.println(obj);
  }
  }

  public void test4()
  {
  HashMap hm=new HashMap();
  for ( int i=0;i<10;i++)
  {
  hm.put("item"+i,"value"+i);
  }

  Set set=hm.entrySet();
  Iterator itr=set.iterator();
  while (itr.hasNext())
  {
  Map.Entry me=(Map.Entry)itr.next();
  System.out.println(me.getKey()+";"+me.getValue());
  }

  hm.put("item5","modifyed value");
  System.out.println(hm.get("item5") );

  set=hm.entrySet();
  itr=set.iterator();
  while (itr.hasNext())
  {
  Map.Entry me=(Map.Entry)itr.next();
  System.out.println(me.getKey()+";"+me.getValue());
  }

  }

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract   class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）？下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。
 
解决方案一：
 
简单的在Door的定义中增加一个alarm方法，如下：
 
abstract class Door{
 
abstract void open();
 
abstract void close()；
 
abstract void alarm();
 
}
 
或者
 
interface Door{
 
void open();
 
void close();
 
void alarm();
 
}
 
那么具有报警功能的AlarmDoor的定义方式如下：
 
class AlarmDoor  extends Door{
 
void open(){…}
 
void close(){…}
 
void alarm(){…}
 
}
 
或者
 
class  AlarmDoor implements  Door｛
 
void  open(){…}
 
void  close(){…}
 
void  alarm(){…}
 
｝
 
这种方法违反了面向对象设计中的一个核心原则ISP（InterfaceSegregationPriciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。
 
解决方案二：
 
既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract  class方式定义；两个概念都使用interface方式定义；一个概念使用abstract  class方式定义，另一个概念使用interface方式定义。
 
显然，由于Java语言不支持多重继承，所以两个概念都使用abstract  class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。
 
如果两个概念都使用interface方式来定义，那么就反映出两个问题：1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。
 
如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"isa"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：
 
abstract  class  Door{
 
abstract  void  open();
 
abstract  void  close()；
 
}
 
interface  Alarm{
 
void  alarm();
 
}
 
class  AlarmDoor  extends  Door   implements  Alarm{
 
void  open(){…}
 
void  close(){…}
 
void  alarm(){…}
 
}
 
这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract  class表示的是"isa"关系，interface表示的是"likea"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

一行一行读取数据
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>文件读取</title>
</head>
<body>
<%
 String path=request.getRealPath("");//取得当前目录的路径
 FileReader fr=new FileReader(path + "file://file//inc//t.txt%22);//建立FileReader对象，并实例化为fr
 BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
 String Line=br.readLine();//从文件读取一行字符串
 //判断读取到的字符串是否不为空
 while(Line!=null){
  out.println(Line + "<br>");//输出从文件中读取的数据
  Line=br.readLine();//从文件中继续读取一行数据
 }
 br.close();//关闭BufferedReader对象
 fr.close();//关闭文件
%>
</body>
</html>

略过文件中的字符不读取
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>略过字节不读取</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "file://ReadData.txt/");
fr.skip(2);//跳过2个字节
int c=fr.read();//读取一个字节
while(c!=-1){
 out.print((char)c);
 c=fr.read();
}
fr.close();
%>
</body>
</html>

将数据写入文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将数据写入文件</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "file://WriteData.txt%22);//建立FileWriter对象，并实例化fw
//将字符串写入文件
fw.write("大家好！");
fw.write("本书是《JSP编程技巧》");
fw.write("请多多指教！");
fw.write("email:stride@sina.com");
fw.close();
FileReader fr=new FileReader(path + "file://WriteData.txt/");
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();
//读取一行数据
out.println(Line + "<br>");
br.close();//关闭BufferedReader对象
fr.close();
%>
</body>
</html>

将写入文件的数据分行
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "file://WriteData.txt/");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大家好！");
bw.write("本书是《JSP编程技巧》。");
bw.newLine();//断行
bw.write("请多多指教！");
bw.newLine();//断行
bw.write("email: stride@sina.com");
bw.flush();//将数据更新至文件
fw.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "file://WriteData.txt/");
BufferedReader br=new BufferedReader(fr);
String Line=br.readLine();//读取一行数据
while(Line!=null){
 out.println(Line + "<br>");
 Line=br.readLine();
}
fr.close();
%>
</body>
</html>

如何将数据追加写入到文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
RandomAccessFile rf=new RandomAccessFile(path + "file://WriteData.txt%22,%22rw%22);//定义一个类RandomAccessFile的对象，并实例化
rf.seek(rf.length());//将指针移动到文件末尾
rf.writeBytes("\nAppend a line to the file!");
rf.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "file://WriteData.txt/");
BufferedReader br=new BufferedReader(fr);//读取文件的BufferedRead对象
String Line=br.readLine();
while(Line!=null){
 out.println(Line + "<br>");
 Line=br.readLine();
}
fr.close();//关闭文件
%>
</body>
</html>
 
import java.util.*;
import java.io.*;
public class ReadIni
{
  public static void main(String[] args)
    throws Exception
  {
    Properties proDB = new Properties();
    FileInputStream in = new FileInputStream("DBConfig.ini");
    proDB.load(in);
    String jdbc = proDB.getProperty("jdbc");
    String dburl = proDB.getProperty("dburl");
    String userid = proDB.getProperty("userid");
    String password = proDB.getProperty("password");

    System.out.println(jdbc);
    System.out.println(dburl);
    System.out.println(userid);
    System.out.println(password);
  }
}

DBConfig.ini:

dburl=jdbcracle:thin:@202.16.147.104:1521ub
userid=user
password=password
jdbc=oracle.jdbc.driver.OracleDriver