数据和集合的排序

/*
 * 文 件 名:  ArrayAndListSort.java
 * 描    述:  数据和集合的排序（包括自然排序和反向排序）
 * 修 改 人:  Administrator
 * 修改时间:  Dec 14, 2010
 */
package com.sort;

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

/**
 * 数据和集合的排序 
 * 包括自然排序和反向排序，集合转换成数组，数组转换成集合，集合的比较器等
 * @author Administrator
 */
public class ArrayAndListSort
{
    /**
     * 测试方法（main：程序入口）
     */
    public static void main(String[] args)
    {
        ArrayAndListSort arrayAndListSort = new ArrayAndListSort();
        arrayAndListSort.arrayToList();
        arrayAndListSort.listToArray();
        arrayAndListSort.comparatorList();
    }

    /**
     * 集合转换成数组后排序
     */
    public void listToArray()
    {
        List<String> list_string = new ArrayList<String>();
        list_string.add("Andy");
        list_string.add("Felix");
        list_string.add("Bill");
        list_string.add("Helen");
        list_string.add("Cindy");
        list_string.add("Douglas");

        Object[] object = list_string.toArray();

        // 打印验证
        for (int i = 0; i < object.length; i++)
        {
            System.out.println("listToArray:  " + object[i]);
        }

        // 自然排序
        Arrays.sort(object);
        // 下面代码是严格按字母表顺序排序，也就是忽略大小写排序
        // Arrays.sort(array_string, String.CASE_INSENSITIVE_ORDER);
        for (int i = 0; i < object.length; i++)
        {
            System.out.println("listToArray Arrays.sort:  " + object[i]);
        }
        
        // 反向排序
        Arrays.sort(object, Collections.reverseOrder());
        for (int i = 0; i < object.length; i++)
        {
            System.out.println("listToArray Collections.reverseOrder():  " + object[i]);
        }
    }

    /**
     * 数组转换成集合
     */
    public void arrayToList()
    {
        String[] array_string = new String[] { "Andy", "Felix", "Bill",
                "Helen", "Cindy", "Douglas" };

        List<String> list_string = Arrays.asList(array_string);

        for (int i = 0; i < list_string.size(); i++)
        {
            System.out.println("arrayToList:  " + list_string.get(i));
        }

        // 自然排序
        Collections.sort(list_string);
        for (int i = 0; i < list_string.size(); i++)
        {
            System.out.println("arrayToList sort:  " + list_string.get(i));
        }

        // 反向排序
        Collections.reverse(list_string);
        for (int i = 0; i < list_string.size(); i++)
        {
            System.out.println("arrayToList reverse:  " + list_string.get(i));
        }
    }

    /**
     * 对较器排序方法 包括自然排序和反向排序
     */
    public void comparatorList()
    {
        List<SortEntity> list_sortEntity = new ArrayList<SortEntity>();
        list_sortEntity.add(new SortEntity("Andy", 21, 2000));
        list_sortEntity.add(new SortEntity("Felix", 21, 3000));
        list_sortEntity.add(new SortEntity("Bill", 35, 20000));
        list_sortEntity.add(new SortEntity("Helen", 21, 10000));
        list_sortEntity.add(new SortEntity("Cindy", 28, 8000));
        list_sortEntity.add(new SortEntity("Douglas", 25, 5000));

        // 比较器：按名称排序
        // 此处使用匿名内部类
        Comparator c_name = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                SortEntity se1 = (SortEntity) o1;
                SortEntity se2 = (SortEntity) o2;
                // String.compareTo(String anotherString):按字典顺序比较两个字符串
                return se1.getName().compareTo(se2.getName());
            }
        };

        // 比较器：按年龄排序
        Comparator c_age = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                SortEntity se1 = (SortEntity) o1;
                SortEntity se2 = (SortEntity) o2;
                return se1.getAge() - se2.getAge();
            }
        };

        // 比较器：排序薪水排序
        Comparator c_salary = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                SortEntity se1 = (SortEntity) o1;
                SortEntity se2 = (SortEntity) o2;
                return se1.getSalary() - se2.getSalary();
            }
        };

        // 根据指定比较器产生的顺序对指定列表进行排序（自然排序）
        // 按名称
        Collections.sort(list_sortEntity, c_name);
        // 打印验证
        for (int i = 0; i < list_sortEntity.size(); i++)
        {
            SortEntity sortEntity = list_sortEntity.get(i);
            System.out.println("comparatorTest sort:  " + sortEntity.getName());
            System.out.println("comparatorTest sort:  " + sortEntity.getAge());
            System.out.println("comparatorTest sort:  " + sortEntity.getSalary());
        }
        // 按年龄
        // Collections.sort(list_sortEntity, c_age);
        // 按薪水
        // Collections.sort(list_sortEntity, c_salary);

        // 自然排序后，可调用以下方法进行反向排序
        Collections.reverse(list_sortEntity);

        // 打印验证
        for (int i = 0; i < list_sortEntity.size(); i++)
        {
            SortEntity sortEntity = list_sortEntity.get(i);
            System.out.println("comparatorTest reverse:  " + sortEntity.getName());
            System.out.println("comparatorTest reverse:  " + sortEntity.getAge());
            System.out.println("comparatorTest reverse:  " + sortEntity.getSalary());
        }
    }
}

/*
 * 文 件 名:  SortEntity.java
 * 描    述:  用于排序的实体类
 * 修 改 人:  Administrator
 */

package com.sort;

/**
 * 用于排序的实体类
 * @author Administrator
 */
public class SortEntity
{
    private String name;
    private int age;
    private int salary;

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

    public int getAge()
    {
        return age;
    }

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

    public String getName()
    {
        return name;
    }

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

    public int getSalary()
    {
        return salary;
    }

    public void setSalary(int salary)
    {
        this.salary = salary;
    }
}