java list排序出错

Posted 2023-05-09

对list中的字符串数据排序：

public class aaa

/**
* @param args
*/
public static void main(String[] args)
List<String> list = new ArrayList<String>();
list.add("34324324");
list.add("324");
list.add("3");
list.add("4563453");
Collections.sort(list);

for (String s : list)
System.out.println(s);




排序结果
3
324
34324324
4563453

为什么呢

参考技术A "34324324"和 34324324
完全两样的！！！
前者是字符串
后者是整型数字

把“”去掉看看！！！！ 参考技术B 你是想比较数字大小吧，你写成比较String了，我给你改了一下

import java.util.Collections;
import java.util.*;

public class aa

/**
* @param args
*/
public static void main(String[] args)
List<Integer> list = new ArrayList<Integer>();
list.add(34324324);
list.add(32);
list.add(3);
list.add(4563453);
Collections.sort(list);

for (Integer s : list)
System.out.println(s);



输出结果:
3
32
4563453
34324324
不知道这是你想要的结果吗 参考技术C 并没有出错.你使用了Collections.sort对List进行了自然排序,也就是升序排序.由于比较的对象是String,所以应该按字符的Unicode值进行排序.

比如说"abd","ace","bdr"要进行sort排序的话,比较字符的Unicode值. 应该是这样的"abd","ace","bdr". (和原顺序一样)

因为a在字典查询顺序中排在最前面,其次是b,所以"abd"排在第一位,c在b的后面,经过比较之后,第二位应该是"ace",.....
由于你写的字符串中是数字,同样按照字符的Unicode值进行排序.
先进行首位数字的比较,得到3在前4在后 (因为3最小)
接着进行第二位的比较,依次类推,
进行排序,输出上面的内容. (注意这可不是按照数字的大小排的,如果你有一个数是5,则5应该排在最后,即
3
324
34324324
5

实际上,Collections.sort对List进行了自然排序是因为你比较的对象String实现了Comparable接口的compareTo(Object o)方法,所以你能按照自然排序比较大小.否则如果你比较的对象没有实现Comparable接口,你调用Collections.sort(list); 是会抛出异常的 参考技术D 学习 第5个回答  2009-05-14 先进行首位数字的比较,得到3在前4在后
接着进行第二位的比较,依次类推,
进行排序,输出上面的内容.

(转载)java list排序

1、简介　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

这个和数组的排序又不一样了。

其实Java针对数组和List的排序都有实现，对数组而言，你可以直接使用Arrays.sort，对于List和Vector而言，你可以使用Collections.sort方法。

Java API针对集合类型的排序提供了2个方法:

java.util.Collections.sort(java.util.List)

java.util.Collections.sort(java.util.List, java.util.Comparator)

如果集合里面的元素都是相同类型的，并且实现了Comparable接口，那么可以直接调用第一个方法。

如果你有其它的排序的想法，比如你不想按照自然排序进行，还可以传一个Comparator过去，比如反向。

元素不相同的情况比较复杂，可以暂时不用考虑。

 

2、通过实现Comparable接口来实现list的排序　　　　

假如现在我们有一个Person类的list集合，要让其按照一个Order属性进行排序，我们可以让Person类实现Comparable接口，重写其CompareTo方法即可。具体实现如下：

1）、Person实体类

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());      //这里定义你排序的规则。
    }
 
}

通过重写Comparable接口的compareTo方法，可以让程序按照我们想要的排列方式进行排序，如：这里我让Person按照order属性升序排序。

2）、测试类

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);

    //打印排序后的Person
    for (Person p : listA) {
        System.out.println(p.getName());
    }
}

3）、结果：

name1
name2
name3

3、通过重载Collections.sort方法　　　　　　　　　　　　　　　　　　　　

直接重载java.util.Collections.sort(java.util.List, java.util.Comparator) 方法。可以灵活的修改我们排序的方式，具体实现如下：

1）、Person实体类

　　和上面的类相同，但没实现Comparable接口

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;
    }
 
}

2）、测试类

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());
        }
    }

从上面看到，直接在Conllections.sort（）方法中重写了一个Comparator接口，可以在不同的地方使用Person集合的不同排序方法。如上面还是按照Person的order属性升序排列，我只要改写该方法，就可以在其他地方按照其他的规则对我的list集合进行排序，但是这样子代码看起来会比前面的那种方式繁琐。

3）、结果

name1
name2
name3

　　致谢：感谢您的阅读！

 

 

4.扩展：按照两个字段排序　　　　　　

比如先按照名字排序，如果名字相同，按照小名排序；例子如下：

package com.cy.model;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Student implements Comparable<Student>{
    private int id;
    private String name;    //名字
    private String sname;    //小名
    
    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 String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public Student(int id, String name, String sname) {
        super();
        this.id = id;
        this.name = name;
        this.sname = sname;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", sname=" + sname
                + "]";
    }
    /**
     * student类的排序方法
     * 先按照name排序，如果name相同按照sname排序
     */
    @Override
    public int compareTo(Student o) {
        int r1 = this.getName().compareToIgnoreCase(o.getName());
        int r2 = this.getSname().compareToIgnoreCase(o.getSname());
        
        return  r1>0?1:
                r1<0?-1:
                r2>0?1:
                r2<0?-1:0;
    }
    
    //测试程序
    public static void main(String[] args) {
        Student s1 = new Student(2,"zhangsan","z");
        Student s2 = new Student(1, "zhangsan","b");
        Student s3 = new Student(3, "zhangsan","y");
        Student s4 = new Student(0, "lisi","s");
        Student s5 = new Student(5, "wangwu","w");
        Student s6 = new Student(10, "wangwu","xx");
        Student s7 = new Student(8, "aming","ming");
        
        List<Student> list = new ArrayList<Student>();
        list.add(s1);list.add(s2);list.add(s3);list.add(s4);
        list.add(s5);list.add(s6);list.add(s7);
        
        Collections.sort(list);
        
        for(Student s : list){
            System.out.println(s);
        }
    }
    
}

打印：

Student [id=8, name=aming, sname=ming]
Student [id=0, name=lisi, sname=s]
Student [id=5, name=wangwu, sname=w]
Student [id=10, name=wangwu, sname=xx]
Student [id=1, name=zhangsan, sname=b]
Student [id=3, name=zhangsan, sname=y]
Student [id=2, name=zhangsan, sname=z]