java-排序

import java.util.Arrays;/** * Created by Administrator on 2017/5/19. */public class sortTesty {    public static void main(String[] args) {        sortIntArray();        sortStringArray();    }    //对整数集合进行排序    public static void sortIntArray() {        int[] array = new int[]{8, 5, 9, 0, 6, 3, 4, 7, 2, 1};        System.out.println("整数排序前");        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + " ");        }        System.out.println();        Arrays.sort(array);        System.out.println("整数排序后");        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + " ");        }        System.out.println();    }    //对字符串集合进行排序    public static void sortStringArray() {        String[] array = new String[]{"a", "c", "e", "d", "b"};        System.out.println("字符串排序前");        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + " ");        }        System.out.println();        System.out.println("字符串排序后");        Arrays.sort(array);        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + " ");        }        System.out.println();    }}

用Collections.sort方法对list排序有两种方法

一个是Comparable：重写compareTo方法；
一个是Comparator：重写compare方法。

第一种:list中的对象实现Comparable接口

import java.util.Collections;import java.util.LinkedList;/** * Created by Administrator on 2017/5/19. */public class Animals implements Comparable<Animals> {    private String name;    public int age;    public Animals(String name, int age) {        this.name = name;        this.age = age;    }    public static void main(String[] args) {        LinkedList<Animals> list = new LinkedList<Animals>();        list.add(new Animals("a", 2));        list.add(new Animals("b", 9));        list.add(new Animals("c", 6));        //实现Comparator接口        Collections.sort(list);//需重写compareTo（）方法        for (Animals animals : list) {            System.out.println("Animals name=" + animals.name + " , age="                    + animals.age);        }    }    @Override    public int compareTo(Animals o) {        if (this.age > o.age)            return 1;        if (this.age < o.age)            return -1;        else            return 0;    }}

第二种:sort方法的第二个参数：比较器类的对象实现Comparator接口。

import java.util.Collections;import java.util.Comparator;import java.util.LinkedList;/** * Created by Administrator on 2017/5/19. */public class Person {    private String name;    public int age;    public Person(String name, int age) {        this.name = name;        this.age = age;    }    public static void main(String[] args) {        LinkedList<Person> list = new LinkedList<Person>();        list.add(new Person("a", 2));        list.add(new Person("b", 9));        list.add(new Person("c", 6));        Collections.sort(list, new PersonComparator());//sort方法的两个参数：比较的集合，比较器类的对象。        for (Person person : list) {            System.out.println("Person name=" + person.name + " , age="                    + person.age);        }    }    static class PersonComparator implements Comparator<Person> {        @Override        public int compare(Person o1, Person o2) {            if (o1.age > o2.age)                return 1;            if (o1.age < o2.age)                return -1;            else                return 0;        }    }}

前者代码结构简单，但是只能根据固定的属性排序，
后者灵活，可以临时指定排序项，但是代码不够简洁 .

实现Comparator接口可以直接使用匿名内部类

import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;/** * Created by Administrator on 2017/5/19. */public class AnotherUser {    private String name;    private Integer order;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Integer getOrder() {        return order;    }    public void setOrder(Integer order) {        this.order = order;    }    public static void main(String[] args) {        User user1 = new User();        user1.setName("a");        user1.setOrder(10);        User user2 = new User();        user2.setName("b");        user2.setOrder(2);        List<User> list = new ArrayList();        list.add(user2);        list.add(user1);        Collections.sort(list, new Comparator<User>() {            @Override            public int compare(User arg0, User arg1) {                return arg0.getOrder().compareTo(arg1.getOrder());            }        });        for (User u : list) {            System.out.println(u.getName());        }    }}

HashMap的排序：

/** * Created by Administrator on 2017/5/19. */public class MyUser {    private String name;    private int age;    public MyUser() {    }    public MyUser(String name, int age) {        this.name = name;        this.age = 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 String toString() {        return "MyUser{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}

import java.util.*;/** * Created by Administrator on 2017/5/19. */public class HashMapTest {    public static void main(String[] args) {        HashMap<Integer, MyUser> map = new HashMap<>();        map.put(1, new MyUser("张三", 25));        map.put(2, new MyUser("李四", 26));        map.put(3, new MyUser("王五", 27));        System.out.println("前------------");        System.out.println(map);        HashMap<Integer, MyUser> sortHashMap = sortHashMap(map);        System.out.println("后------------");        System.out.println(sortHashMap);    }    private static HashMap<Integer, MyUser> sortHashMap(HashMap<Integer, MyUser> map) {//map集合转成set的方法：//Set keySet();//Set entrySet();//取的是键和值的映射关系。//Entry就是Map接口中的内部接口；        Set<Map.Entry<Integer, MyUser>> entrySet = map.entrySet();//Set集合转化List集合// 其实很简单，SET集合里面的元素是不重复的,转成LIST是比较容易的，比如：// 一个set集合A 要转换成一个LIST集合那么可以这么写// List list = new ArrayList(A);        List<Map.Entry<Integer, MyUser>> list = new ArrayList<>(entrySet);//Collections.sort（）：第一个参数必须list，list有序，第二个参数：排序规则        Collections.sort(list, new Comparator<Map.Entry<Integer, MyUser>>() {            @Override            public int compare(Map.Entry<Integer, MyUser> o1, Map.Entry<Integer, MyUser> o2) {                return o2.getValue().getAge() - o1.getValue().getAge();            }        });//将list中的数据保存到LinkedHashMap中，保证有序        LinkedHashMap<Integer, MyUser> linkedHashMap = new LinkedHashMap<>();        for (Map.Entry<Integer, MyUser> entry : list) {            linkedHashMap.put(entry.getKey(), entry.getValue());        }        return linkedHashMap;    }}

结果：

前------------{1=MyUser{name='张三', age=25}, 2=MyUser{name='李四', age=26}, 3=MyUser{name='王五', age=27}}后------------{3=MyUser{name='王五', age=27}, 2=MyUser{name='李四', age=26}, 1=MyUser{name='张三', age=25}}