精华内容
下载资源
问答
  • Python字典按照对象属性排序 1 问题描述 2 示例 结果   1 问题描述 使用字段存放对象,然后根据对象中的某个属性对字典进行排序。 2 示例 '定义一个B' class B: def __init__(self, obj_name1, a1, ...

    Python字典按照对象属性排序

     

    1 问题描述

    使用字段存放类对象,然后根据对象中的某个属性对字典进行排序。
    

    2 示例

    '定义一个类B'
    class B:
        def __init__(self, obj_name1, a1, a2):
            self.obj_name = obj_name1
            self.a = a1
            self.b = a2
    
    o1 = B('o1', 0, 1)
    o2 = B('o2', 3, 4)
    
    dict_original={0: o1,
               1: o2}
    
    print("排序前:", dict_original)
    
    dict_sorted = sorted(dict_original.items(), key=lambda dict_original:dict_original[1].a, reverse=True)
    
    print("排序后:", dict_sorted)
    

    结果

    不过排序后的结果是一个列表的形式,可以根据实际需要进行取值

     

    展开全文
  • 在开发中,我们可能会遇到,我们会根据不同情况对一个List集合进行排序操作,为了方便List集合根据对象中的某一个属性进行排序,开发了此工具
  • 天才之作:通过泛型,对List中对象属性排序,支持设置各属性排序方式(动态属性),看了之后绝对让你震撼!
  • Java通用工具之按对象属性排序工具

    千次阅读 多人点赞 2013-10-17 00:28:41
    本工具为按对象属性排序工具,实现的功能: 1.按对象的一个属性和多个属性进行排序. 2.按对象属性正序和倒序排列. 3.完美支持int等基础和Integer等包装. 4.完美支持属性为实现了Comparable接口的. 5.如果...

    本工具类为按对象属性排序工具类,实现的功能:
    1.按对象的一个属性和多个属性进行排序.
    2.按对象属性正序和倒序排列.
    3.完美支持int等基础类和Integer等包装类.
    4.完美支持属性为实现了Comparable接口的类.
    5.如果类不是java.lang中定义的基础类型也没有实现Comparable接口则转为String后进行排序.

    实现思路:使用反射取得对象属性或对象方法的值从而解除对具体对象的依赖.


    import java.lang.reflect.Field;
    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.Date;
    import java.util.List;
    
    /**
     * 通用工具类之按对象中某属性排序
     * @author 李坤 
     * 交流博客:http://blog.csdn.net/lk_blog
     */
    public class SortListUtil {
    	public static final String DESC = "desc";
    	public static final String ASC = "asc";
    
    	/**
    	 * 对list中的元素按升序排列.
    	 * 
    	 * @param list
    	 *            排序集合
    	 * @param field
    	 *            排序字段
    	 * @return
    	 */
    	public static List<?> sort(List<?> list, final String field) {
    		return sort(list, field, null);
    	}
    
    	/**
    	 * 对list中的元素进行排序.
    	 * 
    	 * @param list
    	 *            排序集合
    	 * @param field
    	 *            排序字段
    	 * @param sort
    	 *            排序方式: SortList.DESC(降序) SortList.ASC(升序).
    	 * @return
    	 */
    	@SuppressWarnings("unchecked")
    	public static List<?> sort(List<?> list, final String field,
    			final String sort) {
    		Collections.sort(list, new Comparator() {
    			public int compare(Object a, Object b) {
    				int ret = 0;
    				try {
    					Field f = a.getClass().getDeclaredField(field);
    					f.setAccessible(true);
    					Class<?> type = f.getType();
    
    					if (type == int.class) {
    						ret = ((Integer) f.getInt(a)).compareTo((Integer) f
    								.getInt(b));
    					} else if (type == double.class) {
    						ret = ((Double) f.getDouble(a)).compareTo((Double) f
    								.getDouble(b));
    					} else if (type == long.class) {
    						ret = ((Long) f.getLong(a)).compareTo((Long) f
    								.getLong(b));
    					} else if (type == float.class) {
    						ret = ((Float) f.getFloat(a)).compareTo((Float) f
    								.getFloat(b));
    					} else if (type == Date.class) {
    						ret = ((Date) f.get(a)).compareTo((Date) f.get(b));
    					} else if (isImplementsOf(type, Comparable.class)) {
    						ret = ((Comparable) f.get(a)).compareTo((Comparable) f
    								.get(b));
    					} else {
    						ret = String.valueOf(f.get(a)).compareTo(
    								String.valueOf(f.get(b)));
    					}
    
    				} catch (SecurityException e) {
    					e.printStackTrace();
    				} catch (NoSuchFieldException e) {
    					e.printStackTrace();
    				} catch (IllegalArgumentException e) {
    					e.printStackTrace();
    				} catch (IllegalAccessException e) {
    					e.printStackTrace();
    				}
    				if (sort != null && sort.toLowerCase().equals(DESC)) {
    					return -ret;
    				} else {
    					return ret;
    				}
    
    			}
    		});
    		return list;
    	}
    
    	/**
    	 * 对list中的元素按fields和sorts进行排序,
    	 * fields[i]指定排序字段,sorts[i]指定排序方式.如果sorts[i]为空则默认按升序排列.
    	 * 
    	 * @param list
    	 * @param fields
    	 * @param sorts
    	 * @return
    	 */
    	@SuppressWarnings("unchecked")
    	public static List<?> sort(List<?> list, String[] fields, String[] sorts) {
    		if (fields != null && fields.length > 0) {
    			for (int i = fields.length - 1; i >= 0; i--) {
    				final String field = fields[i];
    				String tmpSort = ASC;
    				if (sorts != null && sorts.length > i && sorts[i] != null) {
    					tmpSort = sorts[i];
    				}
    				final String sort = tmpSort;
    				Collections.sort(list, new Comparator() {
    					public int compare(Object a, Object b) {
    						int ret = 0;
    						try {
    							Field f = a.getClass().getDeclaredField(field);
    							f.setAccessible(true);
    							Class<?> type = f.getType();
    							if (type == int.class) {
    								ret = ((Integer) f.getInt(a))
    										.compareTo((Integer) f.getInt(b));
    							} else if (type == double.class) {
    								ret = ((Double) f.getDouble(a))
    										.compareTo((Double) f.getDouble(b));
    							} else if (type == long.class) {
    								ret = ((Long) f.getLong(a)).compareTo((Long) f
    										.getLong(b));
    							} else if (type == float.class) {
    								ret = ((Float) f.getFloat(a))
    										.compareTo((Float) f.getFloat(b));
    							} else if (type == Date.class) {
    								ret = ((Date) f.get(a)).compareTo((Date) f
    										.get(b));
    							} else if (isImplementsOf(type, Comparable.class)) {
    								ret = ((Comparable) f.get(a))
    										.compareTo((Comparable) f.get(b));
    							} else {
    								ret = String.valueOf(f.get(a)).compareTo(
    										String.valueOf(f.get(b)));
    							}
    
    						} catch (SecurityException e) {
    							e.printStackTrace();
    						} catch (NoSuchFieldException e) {
    							e.printStackTrace();
    						} catch (IllegalArgumentException e) {
    							e.printStackTrace();
    						} catch (IllegalAccessException e) {
    							e.printStackTrace();
    						}
    
    						if (sort != null && sort.toLowerCase().equals(DESC)) {
    							return -ret;
    						} else {
    							return ret;
    						}
    					}
    				});
    			}
    		}
    		return list;
    	}
    
    	/**
    	 * 默认按正序排列
    	 * 
    	 * @param list
    	 * @param method
    	 * @return
    	 */
    	public static List<?> sortByMethod(List<?> list, final String method) {
    		return sortByMethod(list, method, null);
    	}
    
    	@SuppressWarnings("unchecked")
    	public static List<?> sortByMethod(List<?> list, final String method,
    			final String sort) {
    		Collections.sort(list, new Comparator() {
    			public int compare(Object a, Object b) {
    				int ret = 0;
    				try {
    					Method m = a.getClass().getMethod(method, null);
    					m.setAccessible(true);
    					Class<?> type = m.getReturnType();
    					if (type == int.class) {
    						ret = ((Integer) m.invoke(a, null))
    								.compareTo((Integer) m.invoke(b, null));
    					} else if (type == double.class) {
    						ret = ((Double) m.invoke(a, null)).compareTo((Double) m
    								.invoke(b, null));
    					} else if (type == long.class) {
    						ret = ((Long) m.invoke(a, null)).compareTo((Long) m
    								.invoke(b, null));
    					} else if (type == float.class) {
    						ret = ((Float) m.invoke(a, null)).compareTo((Float) m
    								.invoke(b, null));
    					} else if (type == Date.class) {
    						ret = ((Date) m.invoke(a, null)).compareTo((Date) m
    								.invoke(b, null));
    					} else if (isImplementsOf(type, Comparable.class)) {
    						ret = ((Comparable) m.invoke(a, null))
    								.compareTo((Comparable) m.invoke(b, null));
    					} else {
    						ret = String.valueOf(m.invoke(a, null)).compareTo(
    								String.valueOf(m.invoke(b, null)));
    					}
    
    					if (isImplementsOf(type, Comparable.class)) {
    						ret = ((Comparable) m.invoke(a, null))
    								.compareTo((Comparable) m.invoke(b, null));
    					} else {
    						ret = String.valueOf(m.invoke(a, null)).compareTo(
    								String.valueOf(m.invoke(b, null)));
    					}
    
    				} catch (NoSuchMethodException ne) {
    					System.out.println(ne);
    				} catch (IllegalAccessException ie) {
    					System.out.println(ie);
    				} catch (InvocationTargetException it) {
    					System.out.println(it);
    				}
    
    				if (sort != null && sort.toLowerCase().equals(DESC)) {
    					return -ret;
    				} else {
    					return ret;
    				}
    			}
    		});
    		return list;
    	}
    
    	@SuppressWarnings("unchecked")
    	public static List<?> sortByMethod(List<?> list, final String methods[],
    			final String sorts[]) {
    		if (methods != null && methods.length > 0) {
    			for (int i = methods.length - 1; i >= 0; i--) {
    				final String method = methods[i];
    				String tmpSort = ASC;
    				if (sorts != null && sorts.length > i && sorts[i] != null) {
    					tmpSort = sorts[i];
    				}
    				final String sort = tmpSort;
    				Collections.sort(list, new Comparator() {
    					public int compare(Object a, Object b) {
    						int ret = 0;
    						try {
    							Method m = a.getClass().getMethod(method, null);
    							m.setAccessible(true);
    							Class<?> type = m.getReturnType();
    							if (type == int.class) {
    								ret = ((Integer) m.invoke(a, null))
    										.compareTo((Integer) m.invoke(b, null));
    							} else if (type == double.class) {
    								ret = ((Double) m.invoke(a, null))
    										.compareTo((Double) m.invoke(b, null));
    							} else if (type == long.class) {
    								ret = ((Long) m.invoke(a, null))
    										.compareTo((Long) m.invoke(b, null));
    							} else if (type == float.class) {
    								ret = ((Float) m.invoke(a, null))
    										.compareTo((Float) m.invoke(b, null));
    							} else if (type == Date.class) {
    								ret = ((Date) m.invoke(a, null))
    										.compareTo((Date) m.invoke(b, null));
    							} else if (isImplementsOf(type, Comparable.class)) {
    								ret = ((Comparable) m.invoke(a, null))
    										.compareTo((Comparable) m.invoke(b,
    												null));
    							} else {
    								ret = String.valueOf(m.invoke(a, null))
    										.compareTo(
    												String.valueOf(m
    														.invoke(b, null)));
    							}
    
    						} catch (NoSuchMethodException ne) {
    							System.out.println(ne);
    						} catch (IllegalAccessException ie) {
    							System.out.println(ie);
    						} catch (InvocationTargetException it) {
    							System.out.println(it);
    						}
    
    						if (sort != null && sort.toLowerCase().equals(DESC)) {
    							return -ret;
    						} else {
    							return ret;
    						}
    					}
    				});
    			}
    		}
    		return list;
    	}
    
    	/**
    	 * 判断对象实现的所有接口中是否包含szInterface
    	 * 
    	 * @param clazz
    	 * @param szInterface
    	 * @return
    	 */
    	public static boolean isImplementsOf(Class<?> clazz, Class<?> szInterface) {
    		boolean flag = false;
    
    		Class<?>[] face = clazz.getInterfaces();
    		for (Class<?> c : face) {
    			if (c == szInterface) {
    				flag = true;
    			} else {
    				flag = isImplementsOf(c, szInterface);
    			}
    		}
    
    		if (!flag && null != clazz.getSuperclass()) {
    			return isImplementsOf(clazz.getSuperclass(), szInterface);
    		}
    
    		return flag;
    	}
    
    	public static void main(String[] args) throws Exception {
    		List<Student> list = new ArrayList<Student>();
    
    		list.add(new Student(3, "b", 1, new Date(11110000)));
    		list.add(new Student(1, "c", 3, new Date(44440000)));
    		list.add(new Student(2, "a", 2, new Date(22210000)));
    		list.add(new Student(4, "a", 11, new Date(33330000)));
    		System.out.println("-------原来序列-------------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// 按age正序排序,注意结果排完后是1,2,3,11. 不是1,11,2,3(如果是String类型正序排序是这样)
    		SortListUtil.sort(list, "age", null);
    		System.out.println("---------测试Integer和正序,按age正序排序-----------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// 按id倒序
    		SortListUtil.sort(list, "id", SortListUtil.DESC);
    		System.out.println("--------测试int和倒序,按id倒序------------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// 先按name正序排序,再按id正序排序
    		SortListUtil.sort(list, new String[] { "name", "id" }, new String[] {});
    		System.out
    				.println("---------测试多个排序字段,先按name正序,name相同时再按id正序-----------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// 先按name正序排序,再按id倒序排序
    		SortListUtil.sort(list, new String[] { "name", "id" }, new String[] {
    				SortListUtil.ASC, SortListUtil.DESC });
    		System.out
    				.println("---------测试多个排序字段,先按name正序,name相同时再按id倒序-----------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// 按birthday排序
    		SortListUtil.sort(list, "birthday");
    		System.out
    				.println("---------测试实现了Comparable接口的对象排序,按birthday正序-----------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    		// sortByMethod
    		SortListUtil.sortByMethod(list, "getId", null);
    		System.out
    				.println("---------测试sortByMethod,按getId方法正序-----------------");
    		for (Student stu : list) {
    			System.out.println(stu.toString());
    		}
    
    	}
    }
    
    测试执行效果:


    Studeng.java:

    import java.util.*;
    
    public class Student{
    	private int id;
    
    	private String name;
    
    	private Integer age;
    
    	private Date birthday;
    
    	public Student(int id, String name, Integer age, Date birthday) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.birthday = birthday;
    	}
    
    	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 Integer getAge() {
    		return age;
    	}
    
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    
    	public Date getBirthday() {
    		return birthday;
    	}
    
    	public void setBirthday(Date birthday) {
    		this.birthday = birthday;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", age=" + age
    				+ ", birthday=" + birthday + "]";
    	}
    
    
    }
    


    以下关于Comparable和Comparator的基础知识摘自博客:http://uule.iteye.com/blog/766688

    1.Comparable接口是在java.lang类中的,而Comparator接口是在java.util类中的。
    2.Comparable 是在集合内部定义的方法实现的排序,Comparator 是在集合外部实现的排序,所以,如想实现排序,就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。 

    用自定义类实现 Comparable接口,那么这个类就具有排序功能,Comparable和具体你要进行排序的类的实例邦定。

    而Comparator比较灵活,它没有和任何类绑定,实现它的自定义类仅仅定义了一种排序方式或排序规则。不言而喻,这种方式比较灵活。我们的要排序的类可以分别和多个实现 Comparator接口的类绑定,从而达到可以按自己的意愿实现按多种方式排序的目的。Comparable——“静态绑定排序”,Comparator——“动态绑定排序”。


    限于本人水平有限,很多地方写的并不完美,希望大家不吝赐教.不足之处欢迎留言交流,希望在和大家的交流中得到提高.

    展开全文
  • java 按对象属性排序

    2013-01-08 20:28:34
    最近没事写了一个彩票开奖情况统计程序,其中碰到了需要对数字出现的次数排序的问题,因为涉及到对象属性排序,觉得有必要总结一下,没多少技术含量,只是认识了一个新的接口,权当学习了,呵呵。 以前碰到排序...
    最近没事写了一个彩票开奖情况统计程序,其中碰到了需要对数字出现的次数排序的问题,因为涉及到对象属性的排序,觉得有必要总结一下,没多少技术含量,只是认识了一个新的接口,权当学习了,呵呵。
    以前碰到排序的问题大部分都只是针对单序列的,直接sort一下就完事了,如果是需要对某个对象的某一属性排序,或者说需要对key-value对进行排序,这就稍微有点麻烦了。
    最弱智的方法就是直接对key-value进行冒泡或选择等基本排序,同时交换key和value,逻辑最简单,但是时间复杂度也是最高的。其次稍微好点的可以用快排或堆排序,这里就没必要细讲了,我主要想介绍的是实现Comparable接口的排序。
    首先通过bean类去继承Comparable接口,实现方法compareTo,通过这个方法返回需要排序的value。然后再主类中将bean对象放入list中,调用Collections.sort(list)方法,就能按compareTo方法中的value值进行排序。下面是部分代码:


    public class Number implements Comparable<Number> {
    private String num;
    private int count;
    ......
    ......
    public int compareTo(Number o) {
    return this.getCount() - o.getCount();
    }
    }



    public List<Number> getSort(Number[] number) {
    List<Number> list = new ArrayList<Number>();
    for(int i=0;i<number.length;i++) {
    list.add(number[i]);
    }
    Collections.sort(list);
    return list;
    }


    ok,这样就能按照Number对象的count值对其进行排序了。当然,排序不仅仅限升序一种,还有降序排列Collections.sort(list, Collections.reverseOrder()),反转排列Collections.reverse(list)等等。
    其实采用这种方法并不是为了缩短时间复杂度,我个人觉得这样能让代码显得更简洁些,多调用些已经存在的类和方法总好过自己去实现一套差不多的类或方法。
    展开全文
  • Java 集合自定义对象属性排序

    千次阅读 2018-06-12 13:24:05
    对自定义的对象属性进行排序,一般是实现Comparable接口或实现Comparator接口 1. 实现Comparable接口 package CollectionKnowledge; import java.util.ArrayList; import java.util.Collections; import java....

    对自定义的对象属性进行排序,一般是实现Comparable接口或实现Comparator接口

    1. ComparableComparator接口的区别

    参数 Comparable Comparator
    排序逻辑 排序逻辑必须在待排序对象的类(pojo类)中 排序逻辑单独实现
    实现 pojo类实现Comparable接口 自定义Comparator接口
    排序方法 int compareTo(Object o1) int compare(Object o1, Object o2)
    触发排序 Collections.sort(List) Collections.sort(List, Comparator)
    接口所在包 java.lang.Comparable java.util.Comparator

    巧记两个接口:
    Comparator:-tor结尾,类似doctor一样代表一个人,可以想象为是一个独立的排序接口个体,因为是个比较器个体,所以需要单独书写,单独调用;
    Comparable:-able结尾,able代表xxx能力,描述自身具有的一种能力,是自身自带排序,所以不需要单独写但是要嵌入Bean中,使得Bean具有排序能力

    2. 实现***Comparator***接口

    package CollectionKnowledge;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * 集合自定义属性升序排序示例
     * @author sunlh
     *
     */
    public class ComparatorSort {
    	
    	public static void main(String[] args) {
    		List<UserBean> list = new ArrayList<>();
    		UserBean user1 = new UserBean("2", "张三", "男", 23);
    		UserBean user2 = new UserBean("4", "李四", "男", 24);
    		UserBean user3 = new UserBean("3", "王五", "男", 25);
    		UserBean user4 = new UserBean("1", "马六", "男", 26);
    		list.add(user1);
    		list.add(user2);
    		list.add(user3);
    		list.add(user4);
    		System.out.println("排序前数据");
    		for (UserBean userBean : list)
    			System.out.println(userBean.toString());
    		System.out.println("排序后数据");
    		// 调用排序方法,进行排序
    		ComparatorSort.sortById(list);
    		for (UserBean userBean : list)
    			System.out.println(userBean.toString());
    	}
    	
    	/**
    	 * 按照集合id升序排序
    	 * @param list
    	 */
    	public static void sortById(List<UserBean> list) {
    		Collections.sort(list, new Comparator<UserBean>() {
    			@Override
    			public int compare(UserBean u1, UserBean u2) {
    				String id1 = u1.getId();
    				String id2 = u2.getId();
    				return id1.compareToIgnoreCase(id2);// 忽略大小写进行升序排序
    			}
    		});
    	}
    	
    }
    
    /**
     * 用户pojo
     * @author sunlh
     *
     */
    class UserBean{
    	private String id;
    	private String name;
    	private String sex;
    	private int age;
    	
    	public UserBean(String id, String name, String sex, int age) {
    		this.id = id;
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    	
    	public UserBean() {
    		
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "UserBean [id=" + id + ", name=" + name + ", sex=" + sex
    				+ ", age=" + age + "]";
    	}
    	
    }
    
    

    输出结果:

    排序前数据
    UserBean [id=2, name=张三, sex=男, age=23]
    UserBean [id=4, name=李四, sex=男, age=24]
    UserBean [id=3, name=王五, sex=男, age=25]
    UserBean [id=1, name=马六, sex=男, age=26]
    排序后数据
    UserBean [id=1, name=马六, sex=男, age=26]
    UserBean [id=2, name=张三, sex=男, age=23]
    UserBean [id=3, name=王五, sex=男, age=25]
    UserBean [id=4, name=李四, sex=男, age=24]
    
    

    3. 实现***Comparable***接口

    package CollectionKnowledge;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class ComparableSort {
    
    	public static void main(String[] args) {
    		List<UserBean2> list = new ArrayList<>();
    		UserBean2 user1 = new UserBean2("2", "张三", "男", 23);
    		UserBean2 user2 = new UserBean2("4", "李四", "男", 24);
    		UserBean2 user3 = new UserBean2("3", "王五", "男", 25);
    		UserBean2 user4 = new UserBean2("1", "马六", "男", 26);
    		list.add(user1);
    		list.add(user2);
    		list.add(user3);
    		list.add(user4);
    		System.out.println("排序前数据");
    		for (UserBean2 userBean2 : list)
    			System.out.println(userBean2.toString());
    		System.out.println("排序后数据");
    		Collections.sort(list);
    		for (UserBean2 userBean2 : list)
    			System.out.println(userBean2.toString());
    	}
    }
    
    /**
     * 用户pojo
     * @author sunlh
     *
     */
    class UserBean2 implements Comparable<UserBean2>{
    	private String id;
    	private String name;
    	private String sex;
    	private int age;
    	
    	public UserBean2(String id, String name, String sex, int age) {
    		this.id = id;
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    	
    	public UserBean2() {
    		
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "UserBean [id=" + id + ", name=" + name + ", sex=" + sex
    				+ ", age=" + age + "]";
    	}
    
    	@Override
    	public int compareTo(UserBean2 o) {
    		return this.id.compareToIgnoreCase(o.getId());
    	}
    }
    

    输出结果(同上面一样):

    排序前数据
    UserBean [id=2, name=张三, sex=男, age=23]
    UserBean [id=4, name=李四, sex=男, age=24]
    UserBean [id=3, name=王五, sex=男, age=25]
    UserBean [id=1, name=马六, sex=男, age=26]
    排序后数据
    UserBean [id=1, name=马六, sex=男, age=26]
    UserBean [id=2, name=张三, sex=男, age=23]
    UserBean [id=3, name=王五, sex=男, age=25]
    UserBean [id=4, name=李四, sex=男, age=24]
    
    
    展开全文
  • 文章翻译自stackoverflow问题‘How to sort an NSMutableArray with custom objects in it?’ 原问题链接...以下是正文: 数组排序我们经常
  • Java按对象属性排序

    千次阅读 2019-04-24 11:11:10
    升序:从小到大排序 Collections.sort(userList, new Comparator<User>() { @Override public int compare(User o1, User o2) { return o1.getName().compareTo(o2.getName()); } }); 降序:从大到小.....
  • ObservableCollection results = new ObservableCollection(); result.ExportFiled = new ...//重新初始化对象 根据对象属性排序 result.ExportFiled = new ObservableCollection(result.ExportFiled.OrderBy(i
  • //方法一: 自定义规则排序 stuList.Sort((x, y) => x.age - y.age ); stuList.Sort((x, y) => String.Compare(x.name, y.name)); //方法二:使用Linq排序方法 stuList.AsEnumerable().OrderBy(s => s.age)....
  • List 对象属性排序

    千次阅读 2009-09-10 13:54:00
    比如我有一个Person,它的实例对象存储在ArrayList数组中,现在要把ArrayList数组中的Person对象按照年龄排序.其实这种情况经常遇到.下面给出源代码:1:Person.java文件:-------------------------------public class...
  • * 泛型集合排序,根据实体类对象的某个属性排序 * @author admin * * @param */ public class SortList<E> { public void Sort(List<E> list, final String method, final String sort) {
  • List集合中的对象根据属性排序

    万次阅读 多人点赞 2014-11-27 11:11:02
    集合List存放的数据,默认是按照放入时的顺序存放的,比如依次放入A、B、C,则取得时候,则也是A、B、C的顺序,实际场景中,有时我们需要根据自定义的规则对List中的元素进行排序,该如何实现呢?看下面小例子: ...
  • java 对象String类型属性排序

    千次阅读 2018-10-12 23:10:54
    方法一:内部实现comparator接口 代码演示 import java . util . Arrays ; import java . util . Comparator ; import java . util . Scanner ; class B { String name ; String date ; } ...
  • IOS中,对象数组排序比较复杂,笔者根据自己的经历,分享一种常见的排序方法:   假设一个对象file(文件),有type(种类),size(大小)等多个属性。    按单个属性(比如:文件大小)排序: ...
  • Java对象属性比较排序

    千次阅读 2018-08-16 15:38:26
    前言: ...对于List,我们可以使用Collections.sort(list)进行排序,如果是需要对一个实体对象进行排序呢?  Comparator接口有一个comparTo(Object o)方法,它返回整数类型。对于表达式x.compar...
  • java List中对象属性排序

    千次阅读 2017-06-28 11:53:32
    List对象排序
  • java,对象根据属性排序

    千次阅读 2017-03-07 09:53:59
    * 按照List中的某个Int类型属性进行排序 * * @param list */ @SuppressWarnings("unchecked") public static void sortIntMethod(List list) { Collections.sort(list, new Comparator()
  • 此接口强行对实现它的每个对象进行整体排序。此排序被称为该的自然排序的 compareTo 方法被称为它的自然比较方法 。实现此接口的对象列表(和数组)可以通过 Collections.sort (和 Arrays.sort )进行...
  • python 按照对象某一属性排序

    千次阅读 2020-01-22 14:51:36
    工作中经常需要用到排序,单纯的数字排序还好说,但是有时候要按照对象的某一属性对象进行排序,这时候会稍微麻烦点,不过 python 中有现成的方法解决这种窘境。 1.调用 list 排序方法 不 bb,直接上代码,总共三...
  • 如果list中放的 one_video 对象,需要按 对象的show_date属性 倒序排列,则写法如下: channel_list.sort(key=lambda one_video: one_video.show_date,reverse=True)
  • 这里主要讲解的是对象排序(按某个属性或某种规则) 首先要明白,TreeSet为什么能实现自然排序?是怎么实现的?它怎么知道谁该排在前面,谁该排在后面?引用类型排序有什么样的要求? 这里我就直接一点写了。 1....
  • Java对象数组按照其属性排序的方法

    千次阅读 2018-11-14 23:17:04
    也就是需要对象数组按照其属性排序 一 定义时实现Comparable接口,定义自身的比较算法。 要排序就要有比较的方法, 因为是自定义的, 系统不知道怎么做两个自定义的比较, 所以我们要自己在内写两个的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 297,907
精华内容 119,162
关键字:

不同的类对象的属性排序