建议将login_id,name,created封装到一个类中,而不是放在Vector中:
例如:
class User
    implements Comparable {
  private String loginID;
  private String name;
  private boolean isCreated;  public User(String loginID, String name, boolean isCreated) {
    this.loginID = loginID;
    this.name = name;
    this.isCreated = isCreated;
  }  public boolean isIsCreated() {
    return isCreated;
  }  public String getName() {
    return name;
  }  public void setLoginID(String loginID) {
    this.loginID = loginID;
  }  public void setIsCreated(boolean isCreated) {
    this.isCreated = isCreated;
  }  public void setName(String name) {
    this.name = name;
  }  public String getLoginID() {
    return loginID;
  }  public int compareTo(Object obj) {
    //sort as you wish
    return 0;
  }
}
其中该类实现了Comparable接口,然后用系列方法排序:
 Vector usr = new Vector();
 usr.add(new User("Hello", "hello", true));
 usr.add(new User("word", "world", true));
 List listUsr = new ArrayList(usr);
 Collections.sort(listUsr);
如此listUsr就是排好序的

解决方案 »

  1.   

    如果不涉及到多线程的异步问题,推荐直接用List而不是用Vector,
    如此效率即高代码有简单:
     List usr = new ArrayList();
     usr.add(new User("Hello", "hello", true));
     usr.add(new User("word", "world", true));   
     Collections.sort(usr);
    如此处理过usr已经排好序了
      

  2.   

    如果我按照loginID进行排序的话,
      public int compareTo(Object obj) {
        //sort as you wish
        return 0;
      }
    怎么写
      

  3.   

    按照longinID排序: 
    public int compareTo(Object obj) {
        //sort as you wish
       User temp = (User)obj;
        return this.longID.compareTo(temp.longID);
      }
      

  4.   

    跪求大家,帮我看看这个问题,谢谢!!!!!!!!!!!!!http://expert.csdn.net/Expert/topic/2633/2633574.xml?temp=.6377375
      

  5.   

    如果楼主是按照固定方式排序的话,为什么不在查询的SQL中完成呢?
      

  6.   

    再此谢谢,web_spider(蓦然回首,那人却在、灯火阑珊处。) 我的已经完全写好,拿出来与大家共分享:
    package com.surekam.common.util;import java.util.*;
    /**
     * <p>Title:sort Vector </p>
     * <p>Description: </p>
     * <p>Copyright: Copyright (c) 2003</p>
     * <p>Company: surekam</p>
     * @author yangsf
     * @version 1.0
     */
    public class SortVector implements Comparable{
      Vector v=new Vector();
      int i=0;
      int ascendOrDescend=0;//0:ascend  1:Descend
      String s1="";
      String s2="";
      //construct function
      public SortVector(){
        super();
      }
      //construct function
      public SortVector(Vector v,int i){
        this.v=v;
        this.i=i;
      }
      //construct function
      public SortVector(Vector v,int i,int ascendOrDescend){
      this.v=v;
      this.i=i;
      this.ascendOrDescend=ascendOrDescend;
     }
    //implementing the 'compareTo' method
      public int compareTo(Object o){
       SortVector sv=(SortVector)o;
       s1=(sv.v.elementAt(i)).toString();
       s2=(this.v.elementAt(i)).toString();
       //System.out.println("===s1==="+s1);
       //System.out.println("===s2==="+s2);
       int mm=s1.compareTo(s2.toString());
       //System.out.println("======mm====="+mm);
       if(this.ascendOrDescend==1)
         mm=-mm;
        return mm;
      }
      //get this vector
      public Vector getVector(){
        return this.v;
      }
      /*
       author:
       description:getting one Vector Odering by the determinate rule
       param:
             param1: dv     Vector (storing some vectors in the dv )
             param2: m      int  (the index of the vectors in the dv )
             param3: n      int (0:ascend  1:Descend)
       return:Vector
       exception:
       date:
     */  public Vector returnVBysortDVector(Vector dv,int m,int n){
        ArrayList list =new ArrayList();
        Vector v=new Vector();
        if(dv.size()>0){
          //System.out.println("=======dv.size()==========="+dv.size());
          for(int j=0;j<dv.size();j++){
            //System.out.println("======"+j+"========="+(Vector)(dv.elementAt(j)));
            SortVector sortVector=new SortVector((Vector)(dv.elementAt(j)),m,n);
            list.add(sortVector);
          }
          Collections.sort(list);
          for(int i=0;i<list.size();i++){
            //System.out.println(((SortVector)list.get(i)).getVector());
            v.add(((SortVector)list.get(i)).getVector());
          }
        }
         return v;
      }
      /*
     author:yangsf
     description:getting one ArrayList Odering by the determinate rule
     param:
           param1: dv     Vector (storing some vectors in the dv )
           param2: m      int  (the index of the vectors in the dv )
           param3: n      int (0:ascend  1:Descend)
     return:ArrayList
     exception:
     date:
     */  public ArrayList returnLBysortDVector(Vector dv,int m,int n){
      ArrayList list =new ArrayList();
      Vector v=new Vector();
      if(dv.size()>0){
        //System.out.println("=======dv.size()==========="+dv.size());
        for(int j=0;j<dv.size();j++){
          //System.out.println("======"+j+"========="+(Vector)(dv.elementAt(j)));
          SortVector sortVector=new SortVector((Vector)(dv.elementAt(j)),m,n);
          list.add(sortVector);
        }
        Collections.sort(list);
      }
       return list;
    } public static void main(String[] args){
       Vector v1=new Vector();
       v1.add("mmdsjkf");
       v1.add("dshfhds");
       v1.add("dfjsdkakld");
       Vector v2 =new Vector();
       v2.add("lfjkldsjfd");
       v2.add("djfklsad");
       v2.add("fdjkgkldf");
       Vector v=new Vector();
       v.add(v1);
       v.add(v2);
       System.out.println("===============Test begin=========");
       System.out.println("");
       SortVector sortVector=new SortVector();
       sortVector.returnVBysortDVector(v,0,0);
       sortVector.returnVBysortDVector(v,0,1);
       System.out.println("");
       System.out.println("===============Test end=========");
     }
    }