List集合排序（默认及自定义排序）

一.java提供的默认list排序方法

主要代码：

List<String> list = new ArrayList();

list.add("王硕");
list.add("刘媛媛");

list.add("刘迪");

list.add("刘布");

//升序
Collections.sort(list,Collator.getInstance(java.util.Locale.CHINA));//注意：是根据的汉字的拼音的字母排序的，而不是根据汉字一般的排序方法

for(int i=0;i<list.size();i++)

{

    System.out.print(list.get(i) + " ");

}

System.out.println(""); //刘布 刘迪 刘媛媛 王硕

//降序
Collections.reverse(list);//不指定排序规则时，也是按照字母的来排序的

for(int i=0;i<list.size();i++)

{

     System.out.print(list.get(i) + "" ); 

}
System.out.println("");
//王硕 刘媛媛 刘迪 刘布

二.自定义的排序规则

(1)第一种是model类实现Comparable接口，重写int compareTo(Object o)方法

public class Student implements Comparable {

    

     private String name;

     private int age;

    public String getName() {

        return name;

    }

    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(Object o) {

        // TODO Auto-generated method stub

           Student sdto = (Student)o;

           

        //   以姓名为第一关键字，年龄为第二关键字升序排序。

           int i = 0;

           i = name.compareTo(sdto.name); // 使用字符串的比较

           if(i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果

               return age - sdto.age;

           } else {

               return i; // 名字不一样, 返回比较名字的结果.

           }

    }

}

 List<Student> studentList = new ArrayList();

          Student s1 = new Student ();

          s1.setName("yuanyuan");

          s1.setAge(22);

          studentList.add(s1);

          Student s2 = new Student ();

          s2.setName("lily");

          s2.setAge(25);

          studentList.add(s2);

          

          Student s3 = new Student ();

          s3.setName("yuanyuan");

          s3.setAge(23);

          studentList.add(s3);

          

          Collections.sort(studentList);  

          System.out.print("\n");

          for(Student student : studentList){

           System.out.println(student.getAge() + " : " + student.getName() + " ");

     }

结果：

       25 : lily

       22 : yuanyuan

       23 : yuanyuan

(2)第二种是比较器类实现Comparator接口，重写int compare(Object o1, Object o2)方法；（策略设计模式）

     我们如果需要控制某个类的次序，而该类本身不支持排序（即没有实现Comparable接口）；那么可以建立一个该类的比较器来排序，这个比较器只需要实现Comparator接口即可。

namely, 通过实现Comparator类来新建一个比较器，然后通过该比较器来对类进行排序。Comparator 接口其实就是一种策略模式的实践

若不是调用sort方法，相要直接比较两个对象的大小，Comparator定义了俩个方法，分别是int compare(T o1,T o2)和boolean equals(Object   obj)。有时在实现Comparator接口时，并没有实现equals方法，可程序并没有报错，原因是实现该接口的类也是Object类的子类，而Object类已经实现了equals方法。

  比较器类：

public class StudentComparator implements Comparator {

    @Override

    public int compare(Object o1, Object o2) {

        // TODO Auto-generated method stub

          Student one = (Student) o1;

          Student another = (Student) o2;

           int i = 0;

           i = one.getName().compareTo(another.getName()); // 使用字符串的比较

           if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果

                return one.getAge() - another.getAge();

            } else {

                return i; // 名字不一样, 返回比较名字的结果.

           }

    }

}

 List<Student> studentList = new ArrayList();

          Student s1 = new Student ();

          s1.setName("yuanyuan");

          s1.setAge(22);

          studentList.add(s1);

          Student s2 = new Student ();

          s2.setName("lily");

          s2.setAge(25);

          studentList.add(s2);

          

          Student s3 = new Student ();

          s3.setName("yuanyuan");

          s3.setAge(23);

          studentList.add(s3);

          

          Collections.sort(studentList, new StudentComparator());

          System.out.print("\n");

          for(Student student : studentList){

          System.out.println(student.getAge() + ":" + student.getName() + " ");

          }

     }

结果：

       25 : lily

       22 : yuanyuan

       23 : yuanyuan

Comparable 和 Comparator比较

Comparable 是排序接口(在集合内部定义的方法实现的排序，位于java.util下)；若一个类实现了 Comparable 接口，就意味着 “该类支持排序”。

Comparator 是比较器（是在集合外部实现的排序，位于java.lang下）；我们若需要控制某个类的次序，可以建立一个 “该类的比较器” 来进行排序。

前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。可以说前者属于 “静态绑定”，而后者可以 “动态绑定”。

我们不难发现：Comparable 相当于 “内部比较器”，而 Comparator 相当于 “外部比较器”。

Map转List并排序

 public  String createString(Map<String, String> params) {

        List<String> keys = new ArrayList<String>(params.keySet());

        Collections.sort(keys);

        String prestr = "";

        for (int i = 0; i < keys.size(); i++) {

            String key = keys.get(i);

            String value = params.get(key);

            if (i == keys.size() - 1) {/

                prestr = prestr + key + "=" + value;

            } else {

                prestr = prestr + key + "=" + value + "&";

            }

        }

       

        return prestr;

    }

三.汉字根据字母排序

1.Comparator实现

public class ComparatorList implements Comparator{

@Override
public int compare(Object value1, Object value2) {
// TODO Auto-generated method stub
if(value1.getClass().getName().equals("text.listsort.Manufacturer"))
 {
String s1 = ((Manufacturer)value1).getName().toString();
     String s2 = ((Manufacturer)value2).getName().toString();
     return Collator.getInstance(Locale.CHINESE).compare(s1, s2); 
 }else
 if(value1.getClass().getName().equals("java.lang.String"))
  {
    String s1 = value1.toString();
    String s2 = value2.toString();
    return Collator.getInstance(Locale.CHINESE).compare(s1, s2); 
  }
  return 0; //0表示相同。
}

/*
* 调用Collections.sort(list, new ComparatorList());
*/
@SuppressWarnings("unchecked")
public static List<?> sort(List<?> strList)
{
 ComparatorList comp = new ComparatorList();
 Collections.sort(strList,comp);
 return strList; //返回排序后的列表
}

}