集合的排序

在之前我们所学的java的时候排序用到的是    Arrays.sort(a); //进行排序 这个排序的方法适用于数组,当我们的学习深入之后呢就学到了集合，集合也有排序只是与数组的排序不同而已

集合的排序用到了 Collections.sort(集合名);

当然这个排序也是有限制的并不是所有的集合都能排序比如：集合里面放的对象，当我们对对象进行排序的时候呢这个方法就会存在问题了 下面一个简单的市里代码 带大家看看对集合对象排序的三种方法：

 class Jicheng {
        static class Person implements  Comparable<Person>{
            private String name;
            private int age;

            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }

            public String getName() {
                return name;
            }

            @Override
            public String toString() {
                return String.format("我是%s，今年%d岁",name,age);
            }

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

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            @Override
            public int compareTo(Person o) {
                return this.name.compareTo(o.name)*1000+o.age-this.age;
            }
        }

        public static void main(String[] args) {
            List<Person> ps=new ArrayList<>();
            ps.add(new Person("zhangsan",19));
            ps.add(new Person("lisi",17));
            ps.add(new Person("zhangsan",21));
            ps.add(new Person("wangwu",23));
            System.out.println("没有排序");
            for (Person p :
                    ps) {
                System.out.println(p);
            }
            System.out.println("排序后");
            //数据自身可以比较（实现了comparable）,2.数据自身比较，使用比较器（comparator）
            Collections.sort(ps);//第一种
            //第二种,借助第三方给排序
            Collections.sort(ps, new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    Collator c= Collator.getInstance();
                    return o1.name.compareTo(o2.name)*1000+o2.age-o1.age;
                }
            });
            //jdk1.8 用lambda表达式第三种
//            Collection.sort(ps,(o1,o2)->{
//                Collator c= Collator.getInstance();
//                return o1.name.compareTo(o2.name)*1000+o2.age-o1.age;
//            });
            for (Person p :
                    ps) {
                System.out.println(p);
            }

        }
    }
在上述的代码中呢其中第二种 和第三中比较接近 但是是不同的 因为lambda表达式是在jdk1.8才推出来的

同样的Python的集合的排序也与之类似代码如下：

class person:
    def __init__(self,name=None,age=None):
        self.name=name
        self.age=age
    def __str__(self):
         return "我是{0}，今年{1}岁".format(self.name,self.age)
    def __add__(self, other):
        return person(self.name+other.name,self.age+other.age)

    def __lt__(self, other):
         if self.name== other.name:
            return  other.age < self.age
         else:
            return self.name.encode('gbk')< other.name.encode('gbk')

p=person(name="zs",age=19)
p1=person(name="zs",age=19)
print(p+p1)
ps=[person("张三",19),person("李四",21),person("王五",16),person("张三",15),person("张三",23)]
print("-----------------未排序-------------------------")
for pl in ps:
    print(pl)
print("-----------------排序-------------------------")
#排序做出来
'''
1.在要排序的对象体内声明 def __lt__(self, other):
后边才可以调用store的排序方法
2.key=lambda  a:(a.name.encode('gbk')-a.age) lambda表达式的排序方法
'''
for p1 in sorted(ps,key=lambda  a:(a.name.encode('gbk'),-a.age)):
    print(p1)

上边的放法中只能按某一中的比较方式排序，所以在用的时候注意注释掉