集合的排序

一、集合中的基本数据类型排序

1. 使用Collections类的sort()方法

2.sort(List<T> list):

　　根据元素的自然顺序对指定列表按照升序进行排序

package com.mpp.sort;

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

public class IntSort {
    public static void main(String[] args) {
        //对存储在List中的整形数据进行排序
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(9);
        list.add(3);
        list.add(1);
        System.out.println("排序前：");
        for(int n:list){
            System.out.print(n+" ");
        }
        System.out.println();
        //对list中的数据进行排序
        System.out.println("排序后:");
        Collections.sort(list);
        for(int n:list){
            System.out.print(n+" ");
        }
    }
}

二、集合中的字符串排序

package com.mpp.sort;

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

public class StringSort {
    public static void main(String[] args) {
        //对存放在List中的字符串进行排序
        List<String> list = new ArrayList<String>();
        list.add("orange");
        list.add("blue");
        list.add("yellow");
        list.add("gray");
        System.out.println("排序前：");
        for(String s:list){
            System.out.print(s+ " ");
        }
        System.out.println();
        Collections.sort(list);
        System.out.println("排序后：");   //按照ascll码值进行排序
        for(String s:list){
            System.out.print(s+ " ");
        }
    }
}

三、Comparator接口

1. 强行对某个对象进行整体排序的比较函数

2. 可以将Comparator传递给sort方法（如Collections.sort或Array.sort）

3. int compare(T o1,T o2)比较用来排序的两个参数

　　-如果o1<o2，返回负整数

　　-如果o1==o2，返回0

　　-如果o1>o2，返回正整数

4. boolean equals(Object obj)指示某个其他对象是否“等于”此Comparator

　　此方法可以被Object类中的equals方法覆盖，不必重写

例题：对宠物猫分别按名字升序，年龄降序

Cat类：

package com.mpp.sort;

public class Cat {
    private String name;    //名字
    private int mounth;     //年龄
    private String species;//品种

    public Cat(String name,int mounth,String species){
        super();
        this.setName(name);
        this.setMounth(mounth);
        this.setSpecies(species);
    }

    public String getName() {
        return name;
    }

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

    public int getMounth() {
        return mounth;
    }

    public void setMounth(int mounth) {
        this.mounth = mounth;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    //toString方法重写
    @Override
    public String toString(){
        return "[名字："+name+"，年龄："+mounth+",品种："+species+"]";
    }

}

NameComparator类：

package com.mpp.sort;

import java.util.Comparator;

public class NameComparator implements Comparator<Cat> {

    @Override
    public int compare(Cat o1,Cat o2){
        //按名字升序排序
        String name1 = o1.getName();
        String name2 = o2.getName();
        //升序比较
//        int n = name1.compareTo(name2);  //name1>name2返回正整数，反之返回负整数，相等返回0
        //倒序比较
        int n = name2.compareTo(name1);
        return n;
    }
}

AgeComparator类

package com.mpp.sort;

import java.util.Comparator;

public class AgeComparator implements Comparator<Cat> {

    @Override
    public int compare(Cat o1,Cat o2){
        //按年龄降序排序
        int age1 = o1.getMounth();
        int age2 = o2.getMounth();
        int n = age1-age2;   //如果age1>age2,返回正数，反之返回负数，相等返回0
        return age2-age1;   //降序
//        return age1-age2;   //升序
    }
}

CatTest类：

package com.mpp.sort;

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

public class CatTest {
    public static void main(String[] args) {
        //按照名字升序排序
        Cat cafe = new Cat("cafe",5,"美短");
        Cat milk = new Cat("milk",3,"橘猫");
        Cat huahua = new Cat("huahua",2,"橘猫");
        List<Cat> list = new ArrayList<>();
        list.add(cafe);
        list.add(milk);
        list.add(huahua);
        //排序前
        System.out.println("排序前：");
        for(Cat cat:list){
            System.out.println(cat);
        }

        //按名字进行排序
        Collections.sort(list,new NameComparator());
        System.out.println("按名字排序后：");
        for(Cat cat:list){
            System.out.println(cat);
        }

        //按年龄进行降序排序
        Collections.sort(list,new AgeComparator());
        System.out.println("按年龄降序排序后：");
        for(Cat cat:list){
            System.out.println(cat);
        }
    }
}

 总结排序方式：

　　1. 定义宠物猫类

　　2. 定义比较器类，实现Conparator接口

　　3. 排序，调用Collections.sort()方法，传入要排序的存放类的list和比较器

四、Comparable接口

1. 此接口强行对实现它的每个类的对象进行整体排序

2. 这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法

3. 对于集合，通过调用Collections.sort方法进行排序

4. 对于数组，通过调用Array.sort方法进行排序

5. int compareTo(T o)方法

　　该对象小于，等于或大于指定对象，则分别返回负整数，零或正整数

例：对商品价格进行降序排列

商品类：

package com.mpp.sort;

public class Goods implements Comparable<Goods> {
    private String id;
    private String name;
    private double price;

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public void setId(String id) {
        this.id = id;
    }

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

    public void setPrice(double price) {
        this.price = price;
    }

    public Goods(String id,String name,double price){
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String toString(){
        return "商品编号："+id+",商品名称："+name+",商品价格："+price;
    }

    @Override
    public int compareTo(Goods o) {
        //取出商品价格
        double price1 = this.getPrice();
        double price2 = o.getPrice();
        int n = new Double(price1-price2).intValue();  //升级排序
        //price2-price1;   //降序
        return n;
    }
}

商品测试类：

package com.mpp.sort;

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

public class GoodsTest {
    public static void main(String[] args) {
        Goods g1 = new Goods("s001","手机",2000);
        Goods g2 = new Goods("s002","冰箱",5000);
        Goods g3 = new Goods("s003","电视机",3000);
        List<Goods> goodsList = new ArrayList<Goods>();

        goodsList.add(g1);
        goodsList.add(g2);
        goodsList.add(g3);

        //排序前
        System.out.println("排序前：");
        for(Goods g:goodsList){
            System.out.println(g);
        }
        Collections.sort(goodsList);
        //排序后
        System.out.println("排序后：");
        for(Goods g:goodsList){
            System.out.println(g);
        }

    }
}

总结排序方式：

　　1. 定义商品类并实现Comparable接口，并且重写compareTo()方法

　　2. 定义商品测试类，把商品实例添加到ArrayList中，调用Colletcions.sort()做比较，传入商品实例的list