对集合重新排序（限于基本类型数据）

t150ckh 2011-01-13 09:07:18 


package com.jccw.util;



import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;



public class SortList<E> {

	@SuppressWarnings("unchecked")

	public  void sortList(List<E> list,final String method,final String sort){

		final String name="get"+method.substring(0,1).toUpperCase()+method.substring(1);

		Collections.sort(list,new Comparator(){

			public int compare(Object a,Object b){

				int i=0;

				try {

					Method m1=((E)a).getClass().getMethod(name, null);

					Method m2=((E)b).getClass().getMethod(name,null);

					Object o1=m1.invoke(((E)a), null);

					Object o2=m2.invoke(((E)b), null);

					String typeName=o1.getClass().getSimpleName();

					if(typeName.equals("Integer")||typeName.equals("Long")||typeName.equals("Double")||typeName.equals("Short")||typeName.equals("Float")){

						i=compareTo(typeName,o1,o2);

						if(sort!=null && "desc".equals(sort)){

							 i=i==0?i:-i;

						}else{

							 i=i==0?i:i;

						}

						

					}else{

						if(sort!=null && "desc".equals(sort)){

							i=o2.toString().compareTo(o1.toString());

						}else{

							i=o1.toString().compareTo(o2.toString());

						}

					}

				} catch (SecurityException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (NoSuchMethodException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (IllegalArgumentException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (IllegalAccessException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (InvocationTargetException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

				return i;

			}

			

		});

	}

	

	public int compareTo(String typeName,Object a,Object b){

		if(typeName.equals("Integer")){

			int i1=(Integer)a;

			int i2=(Integer)b;

			if(i1==i2)return 0;

			else return i1-i2>0?1:-1;

		}else if(typeName.equals("Long")){

			long i1=(Long)a;

			long i2=(Long)b;

			if(i1==i2)return 0;

			else return i1-i2>0?1:-1;

		}else if(typeName.equals("Double")){

			double i1=(Double)a;

			double i2=(Double)b;

			if(i1==i2)return 0;

			else return i1-i2>0?1:-1;

		}else if(typeName.equals("Short")){

			short i1=(Short)a;

			short i2=(Short)b;

			if(i1==i2)return 0;

			else return i1-i2>0?1:-1;

		}else if(typeName.equals("Float")){

			float i1=(Float)a;

			float i2=(Float)b;

			if(i1==i2)return 0;

			else return i1-i2>0?1:-1;

		}else{

			return 0;

		}

	}

	

	public static void main(String[] args) {

		Student stu1=new Student(1,"aaa1",99F,99L,99,99D,(short)99,"000");

		Student stu2=new Student(2,"aaa2",49F,49L,49,49D,(short)49,"000");

		Student stu3=new Student(3,"aaa3",33F,33L,33,33D,(short)33,"000");

		Student stu4=new Student(4,"aaa4",51F,51L,51,51D,(short)51,"000");

		Student stu5=new Student(5,"aaa5",43F,43L,43,43D,(short)43,"000");

		Student stu6=new Student(6,"aaa6",65F,65L,65,65D,(short)65,"000");

		List<Student> list=new ArrayList<Student>();

		list.add(stu1);

		list.add(stu2);

		list.add(stu3);

		list.add(stu4);

		list.add(stu5);

		list.add(stu6);

		

		System.out.println(System.currentTimeMillis());

		SortList<Student> sort=new SortList<Student>();

		sort.sortList(list, "name", "asc");

		System.out.println(System.currentTimeMillis());

		for (Student s : list) {

			System.out.println(s.getId()+"     "+s.getName() +"  "+s.getSdouble()+"  "+s.getSfloat()+"  "+s.getSint()+"  "+s.getSlong()+"  "+s.getSshort());

		}

	}

}



	





class Student{

	private int id;

	private String name;

	private float sfloat;

	private long slong;

	private int sint;

	private short sshort;

	private double sdouble;

	private String sex;

	

	public Student() {

		// TODO Auto-generated constructor stub

	}



	public Student(int id, String name, float sfloat, long slong, int sint,double sdouble,short sshort, String sex) {

		this.id = id;

		this.name = name;

		this.sfloat = sfloat;

		this.slong = slong;

		this.sint = sint;

		this.sdouble = sdouble;

		this.sshort=sshort;

		this.sex = sex;

	}



	public int getId() {

		return id;

	}

	public void setId(int id) {

		this.id = id;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	

	public float getSfloat() {

		return sfloat;

	}



	public void setSfloat(float sfloat) {

		this.sfloat = sfloat;

	}

	public long getSlong() {

		return slong;

	}



	public void setSlong(long slong) {

		this.slong = slong;

	}



	public int getSint() {

		return sint;

	}



	public void setSint(int sint) {

		this.sint = sint;

	}



	public short getSshort() {

		return sshort;

	}



	public void setSshort(short sshort) {

		this.sshort = sshort;

	}



	public double getSdouble() {

		return sdouble;

	}



	public void setSdouble(double sdouble) {

		this.sdouble = sdouble;

	}



	public String getSex() {

		return sex;

	}

	public void setSex(String sex) {

		this.sex = sex;

	}

	

}
...全文
252 31 打赏 收藏 转发到动态 举报
写回复
用AI写文章
31 条回复
切换为时间正序
请发表友善的回复…
发表回复
t150ckh 2011-01-17
  • 打赏
  • 举报
 回复
非常感谢。
humanity 2011-01-16
  • 打赏
  • 举报
 回复
要通用也行，只要列出几个 key columns 反射来逐个拿值来比较不就行了，当然要事先约定好 null 值和 not null 谁大谁小。

每个 key 本身一般是基本的类型(基本类型 + String)，就算不是基本的类型，它本身也可以套用这个你正在写的这个比较算法，直到分解到最后所有的东西都是最基本的类型。


qybao 2011-01-15
  • 打赏
  • 举报
 回复
[Quote=引用 28 楼 t150ckh 的回复:]
引用 27 楼 qybao 的回复:

对象排序一般是或某个抽象类实现Comparable或Comparator接口，对象class继承该抽象类，重写compareTo或compare方法，很难做一个通用的Comparator的
如果想做，只能像你现在那样在Comparator接口的实现里写很多的if else

那样子还是很麻烦的。还是有些东西做不成完美啊
[/Quote]

这个是没办法的，你想，你今天写好一个通用的Comparator，明天别人又增加了一个新类，你的Comparator又怎么能知道别人的新类想怎样比较呢？所以，一般的做法都是让新类自己去实现Comparator而不是做个通用的Comparator
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 27 楼 qybao 的回复:]

对象排序一般是或某个抽象类实现Comparable或Comparator接口，对象class继承该抽象类，重写compareTo或compare方法，很难做一个通用的Comparator的
如果想做，只能像你现在那样在Comparator接口的实现里写很多的if else
[/Quote]
那样子还是很麻烦的。还是有些东西做不成完美啊
qybao 2011-01-14
  • 打赏
  • 举报
 回复
你要通用，只能对美种类型判断后去比较了
不过可以修改一下你的compareTo方法


public int compareTo(Class<?> c,Object a,Object b){

        if(c == Integer.class){

            return ((Integer)a).compareTo((Integer)b);

        }else if(c == Long.class){

            return ((Long)a).compareTo((Long)b);

        }else if(c == Double.class){

            return ((Double)a).compareTo((Double)b);

        }else if(c == Short.class){

            return ((Short)a).compareTo((Short)b);

        }else if(c == Float.class){

            return ((Float)a).compareTo((Float)b);

        }else{

            return (a.toString().compareTo(b.toString()));

        }

    }

//调用

Object o1=m1.invoke(((E)a), null);

Object o2=m2.invoke(((E)b), null);

int i compareTo(o1.getClass(),o1,o2);

if ("desc".equals(sort)) {

    i *= -1; 

}
ggyy1031 2011-01-14
  • 打赏
  • 举报
 回复
对照java自带的equals呗，然后自己定义自己的实现规则
zn85600301 2011-01-14
  • 打赏
  • 举报
 回复
不错 不错
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 3 楼 xiangyihu 的回复:]

一个排序，怎么整的这么麻烦啊


顶：lz
[/Quote]

写多了排序就会觉得写一个通用的好点，总不要对每一个集合来一个单独的排序吧。
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 2 楼 ggyy1031 的回复:]

重写equals吧
[/Quote]

不知，能详细点，说下思路也行。
插上翅膀的老虎 2011-01-14
  • 打赏
  • 举报
 回复
一个排序，怎么整的这么麻烦啊


顶：lz
qybao 2011-01-14
  • 打赏
  • 举报
 回复
对象排序一般是或某个抽象类实现Comparable或Comparator接口，对象class继承该抽象类，重写compareTo或compare方法，很难做一个通用的Comparator的
如果想做，只能像你现在那样在Comparator接口的实现里写很多的if else
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
是吖，要是对像排序，这个搞不定啊。不知qybao有什么高见。不知这方式如何修改，才能达到效果？
qybao 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 24 楼 t150ckh 的回复:]
集合的排序，应该常用的就是基本类型的排序吧。用到其它对象排序应该少吧。不知大家遇到过没？
[/Quote]
不少啊，看情况的，比如，你现在是对List<Student>的student的每个属性排序，而这些属性刚好是基本类型，如果有要求直接对student最个综合排序呢，比如先排性别，再排姓名，再排年龄等等，那么此时就是对student对象排序
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
集合的排序，应该常用的就是基本类型的排序吧。用到其它对象排序应该少吧。不知大家遇到过没？
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 21 楼 qybao 的回复:]
引用 15 楼 t150ckh 的回复:
int i compareTo(o1.getClass(),o1,o2); 这是什么用法？

这不是什么用法，是把你的compareTo方法修改了，把第一个参数改为Class(你原来第一个参数是String)，你没看明白吗，这是在你的代码的基础上修改的


Java code
public class SortList<E> {
@……
[/Quote]哦。
qybao 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 19 楼 abc130314 的回复:]
Java code

public int compareTo(Object a, Object b) {
int k = (a == null ? 0 : 2) + (b == null ? -1 : -2);
switch (k) {
case -1://都是null
return 0;……
[/Quote]



    public int compareTo(Object a, Object b) {

        int k = (a == null && b==null) ? 0 : ((a==null) ? -1 : ((b==null) ? 1: 2));

//        switch (k) {

        if (k == 2) {

//            case -1://都是null

//                return 0;

//            case 0://都不是null

//                if (a.getClass() == b.getClass() //&& a instanceof Number && a instanceof Comparable                  

//                        ) {

                  @SuppressWarnings("unchecked")

                  if (a instanceof Comparable) { //因为List存的是相同类型的对象，

                     //所以相同的get方法取出来的应该是也是相同的Class，

                     //只需判断是否是Comparable接口，但是这样要在编译时的unchecked

                    k = ((Comparable) a).compareTo(b);

                } else {

                    //throw new IllegalArgumentException();

                    k = a.toString().compareTo(b.toString()); //Lz的意思好像是除了想要比较的几种类型，其他的都是转为String去比较

                }

//            default://其中一个为null的始终最小

//                return k;

          }

          return k;

        }
qybao 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 15 楼 t150ckh 的回复:]
int i compareTo(o1.getClass(),o1,o2); 这是什么用法？
[/Quote]
这不是什么用法，是把你的compareTo方法修改了，把第一个参数改为Class(你原来第一个参数是String)，你没看明白吗，这是在你的代码的基础上修改的

public class SortList<E> {

    @SuppressWarnings("unchecked")

    public  void sortList(List<E> list,final String method,final String sort){

        final String name="get"+method.substring(0,1).toUpperCase()+method.substring(1);

        Collections.sort(list,new Comparator(){

            public int compare(Object a,Object b){

                int i=0;

                try {

                    Method m1=((E)a).getClass().getMethod(name, null);

                    Method m2=((E)b).getClass().getMethod(name,null);

                    Object o1=m1.invoke(((E)a), null);

                    Object o2=m2.invoke(((E)b), null);

                    //String typeName=o1.getClass().getSimpleName();

                    //if(typeName.equals("Integer")||typeName.equals("Long")||typeName.equals("Double")||typeName.equals("Short")||typeName.equals("Float")){

                        //i=compareTo(typeName,o1,o2);

                        //if(sort!=null && "desc".equals(sort)){

                        //     i=i==0?i:-i;

                        //}else{

                        //     i=i==0?i:i;

                        //}

                        

                    //}else{

                        //if(sort!=null && "desc".equals(sort)){

                        //    i=o2.toString().compareTo(o1.toString());

                        //}else{

                        //    i=o1.toString().compareTo(o2.toString());

                        //}

                    //}

                    Object o1=m1.invoke(((E)a), null);

                    Object o2=m2.invoke(((E)b), null);

                    int i compareTo(o1.getClass(),o1,o2);

                    if ("desc".equals(sort)) {

                        i *= -1; 

                    }

                } catch (SecurityException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                } catch (NoSuchMethodException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                } catch (IllegalArgumentException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                } catch (IllegalAccessException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                } catch (InvocationTargetException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                return i;

            }

            

        });

    }

    

    //public int compareTo(String typeName,Object a,Object b){

    public int compareTo(Class<?> c,Object a,Object b){

        if(c == Integer.class){

            return ((Integer)a).compareTo((Integer)b);

        }else if(c == Long.class){

            return ((Long)a).compareTo((Long)b);

        }else if(c == Double.class){

            return ((Double)a).compareTo((Double)b);

        }else if(c == Short.class){

            return ((Short)a).compareTo((Short)b);

        }else if(c == Float.class){

            return ((Float)a).compareTo((Float)b);

        }else{

            return (a.toString().compareTo(b.toString()));

        }

    }

是这个意思
t150ckh 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 19 楼 abc130314 的回复:]

Java code

public int compareTo(Object a, Object b) {
int k = (a == null ? 0 : 2) + (b == null ? -1 : -2);
switch (k) {
case -1://都是null
return 0;
……
[/Quote]这是jdk原代码吗？
abc130314 2011-01-14
  • 打赏
  • 举报
 回复 


    public int compareTo(Object a, Object b) {

        int k = (a == null ? 0 : 2) + (b == null ? -1 : -2);

        switch (k) {

            case -1://都是null

                return 0;

            case 0://都不是null

                if (a.getClass() == b.getClass() //&& a instanceof Number && a instanceof Comparable

                        ) {

                    return ((Comparable) a).compareTo(b);

                } else {

                    throw new IllegalArgumentException();

                }

            default://其中一个为null的始终最小

                return k;

        }
ggyy1031 2011-01-14
  • 打赏
  • 举报
 回复
[Quote=引用 15 楼 t150ckh 的回复:]
int i compareTo(o1.getClass(),o1,o2); 这是什么用法？
[/Quote]
估计少写了 =
应该是 int i = compareTo(o1.getClass(),o1,o2);
加载更多回复（11）
C语言数据结构与算法编程、链表、树、栈、队列、排序算法
黄老师通过对数据结构核心知识点： 顺序表、链表、栈、队列、树、二叉树、遍历、插入、删除、排序、查找算法 的细心讲解，结合生动的C语言实战代码演练、帮助学员快速掌握数据结构的核心内容、为STL、Boost标准库的...
如何使用Arrays.sort()对任意类型的数据进行排序？
在本文中将介绍Arrays中各种重载的sort()，以及解释如何使用Arrays.sort()对任意类型的数据进行排序，这其中又涉及到Comparable接口和Comparator类的相关内容，最后在对比看一下ArrayList中的sort()。 文章目录1. .
抽象数据类型ADT
抽象数据类型：简单来讲就是 数据元素（不仅限于一般的数据元素）＋对其的操作（不太严谨但有助于理解） 抽象数据类型是描述数据结构的一种理论工具。在介绍抽象数据类型之前我们先介绍一下数据类型的基本概念。 ...
数据结构、数据类型、抽象数据类型之间的区别
（数据元素是最基本的数据单位，最基本的数据元素是一个二进制位。） 逻辑结构指反映数据元素之间的逻辑关系的数据结构，其中的逻辑关系是指数据元素之间的前后件关系，而与他们在计算机中的存储位置无关。包括： ...
redis的五种数据类型
（2）Redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string、list、set、zset（sorted set --有序集合）和hash。这些数据结构都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，...
J2ME

13,100

社区成员

26,495

社区内容

发帖
与我相关
我的任务
社区描述
Java J2ME
社区管理员
  • J2ME社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章