java中list排序

Posted 2023-04-16

我从数据库中查询出一串数据，把它们放入了LIST里面 然后在JSP页面上显示出来，，， 现在我要在页面上控制它们排序，，比如一个下拉框，选择了日期，，把查出来的数据进行排序，，，请问如何编写代码，，，新手。。。
注：日期这个字段包含在LIST里面了。。

第一种方法，就是list中对象实现Comparable接口，代码如下：

public class Person implements Comparable<Person>
private String name;
private Integer order;

/**
* @return the name
*/
public String getName()
return name;


/**
* @param name
* the name to set
*/
public void setName(String name)
this.name = name;


/**
* @return the order
*/
public Integer getOrder()
return order;


/**
* @param order
* the order to set
*/
public void setOrder(Integer order)
this.order = order;


@Override
public int compareTo(Person arg0)
return this.getOrder().compareTo(arg0.getOrder());




public static void main(String[] args)
List<Person> listA = new ArrayList<Person>();
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person();

p1.setName("name1");
p1.setOrder(1);
p2.setName("name2");
p2.setOrder(2);
p3.setName("name3");
p3.setOrder(3);

listA.add(p2);
listA.add(p1);
listA.add(p3);
Collections.sort(listA);
for (Person p : listA)
System.out.println(p.getName());



第二种方法，就是在重载Collections.sort方法，代码如下：

public class Person
private String name;
private Integer order;

/**
* @return the name
*/
public String getName()
return name;


/**
* @param name
* the name to set
*/
public void setName(String name)
this.name = name;


/**
* @return the order
*/
public Integer getOrder()
return order;


/**
* @param order
* the order to set
*/
public void setOrder(Integer order)
this.order = order;




public static void main(String[] args)
List<Person> listA = new ArrayList<Person>();
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person();

p1.setName("name1");
p1.setOrder(1);
p2.setName("name2");
p2.setOrder(2);
p3.setName("name3");
p3.setOrder(3);

listA.add(p2);
listA.add(p1);
listA.add(p3);

Collections.sort(listA, new Comparator<Person>()
public int compare(Person arg0, Person arg1)
return arg0.getOrder().compareTo(arg1.getOrder());

);

for (Person p : listA)
System.out.println(p.getName());



两次执行的结果都是：

name1

name2

name3 参考技术A 第一种方法，就是list中对象实现Comparable接口，代码如下：
public
class
Person
implements
Comparable

private
String
name;
private
Integer
order;
/**
*
@return
the
name
*/
public
String
getName()

return
name;

/**
*
@param
name
*
the
name
to
set
*/
public
void
setName(String
name)

this.name
=
name;

/**
*
@return
the
order
*/
public
Integer
getOrder()

return
order;

/**
*
@param
order
*
the
order
to
set
*/
public
void
setOrder(Integer
order)

this.order
=
order;

@Override
public
int
compareTo(Person
arg0)

return
this.getOrder().compareTo(arg0.getOrder());


public
static
void
main(String[]
args)

List
listA
=
new
ArrayList
();
Person
p1
=
new
Person();
Person
p2
=
new
Person();
Person
p3
=
new
Person();
p1.setName("name1");
p1.setOrder(1);
p2.setName("name2");
p2.setOrder(2);
p3.setName("name3");
p3.setOrder(3);
listA.add(p2);
listA.add(p1);
listA.add(p3);
Collections.sort(listA);
for
(Person
p
:
listA)

System.out.println(p.getName());


第二种方法，就是在重载Collections.sort方法，代码如下：
public
class
Person

private
String
name;
private
Integer
order;
/**
*
@return
the
name
*/
public
String
getName()

return
name;

/**
*
@param
name
*
the
name
to
set
*/
public
void
setName(String
name)

this.name
=
name;

/**
*
@return
the
order
*/
public
Integer
getOrder()

return
order;

/**
*
@param
order
*
the
order
to
set
*/
public
void
setOrder(Integer
order)

this.order
=
order;


public
static
void
main(String[]
args)

List
listA
=
new
ArrayList
();
Person
p1
=
new
Person();
Person
p2
=
new
Person();
Person
p3
=
new
Person();
p1.setName("name1");
p1.setOrder(1);
p2.setName("name2");
p2.setOrder(2);
p3.setName("name3");
p3.setOrder(3);
listA.add(p2);
listA.add(p1);
listA.add(p3);
Collections.sort(listA,
new
Comparator
()

public
int
compare(Person
arg0,
Person
arg1)

return
arg0.getOrder().compareTo(arg1.getOrder());

);
for
(Person
p
:
listA)

System.out.println(p.getName());


两次执行的结果都是：
name1
name2
name3 参考技术B 首先你要写一个比较器类（实现Comparator接口），
实现该接口里的compare方法（具体可参照jdk API），在compare方法里对list中对象按日期进行比较。然后调用Collections.sort( list, comparator) ;
其中list为你要进行排序的list，comparator是你写的比较器类的对象。
代码不给了，自己写对楼主有好处 参考技术C 首先我给你的建议是:
你可以在页面中定义一个下拉框,用哪个控制按什么方式排序,如果你选择哪个之后,那么就在你的数据库的查询语句的后面加上这个排序的条件,然后在从数据库中查询,这样查询出来的数据都是满足要求的数据,你可以把他放入哪个LIST里面,然后在页面遍历这个容器,进行数据显示,这样比你上面的方法要简洁的多! 参考技术D >>比如一个下拉框，选择了日期，，把查出来的数据进行排序
建议你这样写：
StringBuffer sb = new StringBuffer();
sb.append("select * from table");
//当你得下拉列表选择了时间
if(request.getParameter("time") != null)
sb.append(" order by time desc ");

//然后在执行你的SQL
//.......

JAVA中list排序问题

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
/**
* @author jardot
* @version 1.0
* 通用排序
*/
public class SortList<E>
public void Sort(List<E> list, final String method, final String sort)
Collections.sort(list, new Comparator()
public int compare(Object a, Object b)
int ret = 0;
try
Method m1 = ((E)a).getClass().getMethod(method, null);
Method m2 = ((E)b).getClass().getMethod(method, null);
if(sort != null && "desc".equals(sort))//倒序
ret = m2.invoke(((E)b), null).toString().compareTo(m1.invoke(((E)a), null).toString());
else//正序
ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());
catch(NoSuchMethodException ne)
System.out.println(ne);
catch(IllegalAccessException ie)
System.out.println(ie);
catch(InvocationTargetException it)
System.out.println(it);

return ret;

);


ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());这条代码怎么就能够为list重新排序呢？在下小鸟鸟，望各位大大指教！

分不多，不过正好我研究了这里，也算给自己做个总结：

我为了方便解释、写了一个测试类

/** test for reflex */
public class Model
private String name;
private String content;

public Model()
this.name = "my name";
this.content = "a long text";

public void setName(String name)
this.name = name;

public String getName()
return name;

public String getContent()
return content;

//测试
public void test() throws Exception
Model model = new Model();
Method m1 = model.getClass().getMethod("getName", null);
System.out.println(m1.invoke(model, null));

public static void main(String args[])
try
new Model().test("getName");
catch (Exception e)
e.printStackTrace();



首先调用test，传递一个method过去；

通过反射机制(这里用到了getMethod、invoke，我比较喜欢getField)、获取到m1对象的getName方法，getMethod第一个参数为方法名、第二个是给这个method的参数的类型，
If parameterTypes is null, it is treated as if it were an empty array，如果为null，表示没有参数；(即 getName()方法)；

然后在通过 invoke 注入参数；第一个是相应对象的引用、第二个是参数值（刚刚的是类型，现在才是值）；
If the underlying method is static, then the specified obj argument is ignored. It may be null，也就是说static的方法第一个参数是null；
我们要调用的是getName(),那么就是 m1.invoke(model,null)了；

执行结果为：my name ；相当于调用了getName()方法.
绕了一圈也就是 model.getName() == model.getClass().getMethod("getName",null).invoke(model,null);

对于有参数的，调整为
public void test(String method) throws Exception
Model model = new Model();
Method m1 = model.getClass().getMethod(method, String.class);
m1.invoke(model, "can you");
System.out.println(model.getName());

结果:can you

接下来上边的题目就简单了，
public void Sort(List<E> list, final String method, final String sort)
这里给出了method，接下来是一个内部类的处理；自定义一个comparator，

Method m1 = ((E) a).getClass().getMethod(method, null);
这里就是获取method方法，他没有参数。

m1.invoke(((E)a), null).toString()
这里是得到对象a调用方法method之后的返回值。

ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());
而这里就是比较两个对象method方法的返回值

将ret交给sort进行排序；

就像3楼说的、真正排序的是sort方法，下面的只是对一个类中某个方法的返回值进行比较 参考技术A compareTo 只是比较2个字符串，不能进行排序
String s1 = "abc";
String s2 = "abcd";
String s3 = "abcdfg";
String s4 = "1bcdfg";
String s5 = "cdfg";
String s6="abc";
System.out.println( s1.compareTo(s2) ); // -1 (前面相等,s1长度小1)
System.out.println( s1.compareTo(s3) ); // -3 (前面相等,s1长度小3)
System.out.println( s1.compareTo(s4) ); // 48 ("a"的ASCII码是97,"1"的的ASCII码是49,所以返回48)
System.out.println( s1.compareTo(s5) ); //-2
System.out.println( s1.compareTo(s6) ); // 0
比较方法其实就是对字符串中的字符逐个比较ASCII 值相减，如果2个字符串是包含关系返回长度差。Collections.sort方法才是对LIST 进行排序的方法。本回答被提问者和网友采纳 参考技术B 这是根据Collections.sort重载方法来实现 list比较排序
compare 方法返回int类型参数实现正序和倒序排列
那我们来分析一下这句
ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());
method m1 invoke方法中 将Object a强制转换为实体E类型 类型数组null 之后to成String 返回类型，与m2的invoke方法返回类型进行字符比较。 其结果返回的int类型 是compare 方法的返回类型。
Collections.sort将Sort方法中的参数list 进行排序，
ret = m2.invoke(((E)b), null).toString().compareTo(m1.invoke(((E)a), null).toString());
ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());
这两句返回参数理论上是相反的

不用为此纠结 这只是个实例 有不明白的 可以Hi我 ms_compound 参考技术C m1.invoke通过反射，调用方法
compareTo.按字典顺序比较两个字符串 参考技术D 看来我还是要好好看书啊