集合排序的实现

List排序的实现

（1）       通过冒泡排序，根据一定的规则循环list集合进行排序

（2）       使用Collection进行排序，可以自己自定义Comparator进行排序（按照对象的某个属性排序，自定义排序规则（升序返回1，降序返回-1，没有排序返回0））。

测试

public class TestClass {

   public static voidmain(String[] args) {

            User user1 = new User();

            user1.setName("a");

            user1.setOrder(2);

            User user2 = new User();

            user2.setName("b");

            user2.setOrder(1);

            List<User> list = newArrayList<User>();

            list.add(user2);

            list.add(user1);

 

            //使用系统的Comparator

            Collections.sort(list, newComparator<User>() {

                     public intcompare(User arg0, User arg1) {

                               inti=arg0.getOrder().compareTo(arg1.getOrder());//1是升序

                               i=arg1.getOrder().compareTo(arg0.getOrder());//0是降序

                               return i;

                     }

            });

            System.out.println("---------------------------------------------------------------");

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

                     System.out.println("user降序="+list.get(i).getName());

            }

            Collections.sort(list, newComparator<User>() {

                     public intcompare(User arg0, User arg1) {

                               inti=arg0.getOrder().compareTo(arg1.getOrder());//1是升序

                               return i;

                     }

            });

            System.out.println("---------------------------------------------------------------");

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

                     System.out.println("user升序="+list.get(i).getName());

            }

            System.out.println("自定义排序");

            //使用自定义的Comparator

            Collections.sort(list,newCollectionSort(0, 0));

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

                     System.out.println("user升序="+list.get(i).getName());

            }

            System.out.println("---------------------------------------------------------------");

            Collections.sort(list, newCollectionSort(0, 1));

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

                     System.out.println("user降序="+list.get(i).getName());

            }

            System.out.println("---------------------------------------------------------------");

            Student student1 = newStudent();

            student1.setName("a");

            student1.setHeight(16.8);

            Student student2 = newStudent();

            student2.setName("b");

            student2.setHeight(18.34);

            List<Student> lists = newArrayList<Student>();

            lists.add(student1);

            lists.add(student2);

            Collections.sort(lists,newCollectionSort(1, 0));

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

                     System.out.println("student升序="+lists.get(i).getName());

            }

            System.out.println("---------------------------------------------------------------");

            Collections.sort(lists, newCollectionSort(1, 1));

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

                     System.out.println("student降序="+lists.get(i).getName());

            }

System.out.println("自定义排序规则");

            Collections.sort(lists,new CollectionSort(2, 0));

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

                     System.out.println("student升序="+lists.get(i).getName());

            }

            System.out.println("---------------------------------------------------------------");

            Collections.sort(lists, new CollectionSort(2, 1));

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

                     System.out.println("student降序="+lists.get(i).getName());

            }

   }

}

 

 

//比较类，实现Comparator重写compare(),在compare()中可以规定自己的比较规则，返回值是0没有排序，1升序排列，-1降序排列

public classCollectionSort implements Comparator<Object> {

 

         privateint lei = -1;// 类选择

         privateint paixuType;// 排序方式//0升序，1降序

 

         publicCollectionSort(int i, int paixuType) {

                   this.lei= i;

                   this.paixuType= paixuType;

         }

compareTo（）比较的参数是Double Integer类型的

         publicint compare(Object arg0, Object arg1) {

                   switch(lei) {

                   case0:

                            Useruser1 = (User) arg0;

                            Useruser2 = (User) arg1;

                            if(paixuType == 0) {

                                     returnuser1.getOrder().compareTo(user2.getOrder());

                            }else {

                                     returnuser2.getOrder().compareTo(user1.getOrder());

                            }

                   case1:

                            Studentstudent1=(Student) arg0;

                            Studentstudent2=(Student) arg1;

                            if(paixuType==0){

                                     returnDouble.valueOf(student1.getHeight()).compareTo(Double.valueOf(student2.getHeight()));

                            }else{

                                     returnDouble.valueOf(student2.getHeight()).compareTo(Double.valueOf(student1.getHeight()));

                            }

case 2:

                            if(paixuType==0){

                                     return 1;

                            }else {

                                     return -1;

                            }

                   default:

                            break;

                   }

                   return0;

         }

}

（3）       使用list的sort进行排序

List<Integer> data=newArrayList<Integer>();

                   data.add(8);

                   data.add(4);

                   data.add(5);

                   data.sort(new Comparator<Integer>() {

                            public int compare(Integerarg0, Integer arg1) {

                                     returnarg0.compareTo(arg1);

                            };

                   });

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

                            System.out.println(data.get(i));

                   }

                   System.out.println("---------------------------------------------------------------");

                   Studentstudent1 = new Student();

                   student1.setName("a");

                   student1.setHeight(16.8);

                   Studentstudent2 = new Student();

                   student2.setName("b");

                   student2.setHeight(18.34);

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

                   lists.add(student1);

                   lists.add(student2);

                   lists.sort(new CollectionSort(1, 0));//自定义比较类

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

                            System.out.println(lists.get(i).getName());

                   }

                   Useruser1 = new User();

                   user1.setName("a");

                   user1.setOrder(2);

                   Useruser2 = new User();

                   user2.setName("b");

                   user2.setOrder(1);

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

                   list.add(user2);

                   list.add(user1);

                   list.sort(new CollectionSort(0, 0)); //自定义比较类

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

                            System.out.println(list.get(i).getName());

                   }

List保存的对象实现Comparable<Teacher>接口在其中规定比较规则

public class Teacher implementsComparable<Teacher> {

         private String name;

         private double height;

         public String getName() {

                   return name;

         }

         public voidsetName(String name) {

                   this.name = name;

         }

         public double getHeight(){

                   return height;

         }

         public void setHeight(doubleheight) {

                   this.height = height;

         }

         public int compareTo(Teacher arg0) {

//在这里定义比较规则

                   returnDouble.valueOf(arg0.height).compareTo(Double.valueOf(this.height));

         }

}

//使用

Teacherteacher1 = new Teacher();

                   teacher1.setName("张老师");

                   teacher1.setHeight(16.8);

                   Teacher teacher2 = newTeacher();

                   teacher2.setName("李老师");

                   teacher2.setHeight(18.34);

                   List<Teacher> listss = newArrayList<Teacher>();

                   listss.add(teacher1);

                   listss.add(teacher2);

                   Collections.sort(listss);

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

                            System.out.println(listss.get(i).getName());

                   }

 

总结：list集合的排序1.直接Comparator对象，通过Collections.sort排序2.自定义类继承Comparator,调用Collections.sort参数是我们自定义的比较器。3.定义实体类实现Comparable<Teacher>接口定义比较规则，Collections.sort(listss);进行排序