JavaSE---Collections

1、简介：

　　　　Collections是一个工具类

　　　　1.1　　排序

　　　　　　a,正序  　　sort是其静态方法，有2种参数形式：　　　　　　　　

　　　　public static <T extends Comparable<? super T>> void sort(List<T> list) {

　　　　　　　list.sort(null);

　　　　}

　　　　public static <T> void sort(List<T> list, Comparator<? super T> c) {

　　　　　　　list.sort(c);

　　　　}

　　　　1.2　　案例

　　【对基本类型排序】

　　　　对于Integer、String类型，已经实现了Comparable接口

　　　　　　public final class String implements java.io.Serializable, Comparable<String>, CharSequence {}

　　　　　　　public final class Integer extends Number implements Comparable<Integer> {}

　　　　

package com.an.collection.list;

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

/**
 * 基本类型测试
 */
public class CollectionsTestOne {

    public static void main(String[] args){
        List<Integer> list=new ArrayList<Integer>(5);
        list.add(9);
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(8);

        //正序
        Collections.sort(list);
        System.out.println(list);

        //倒序
        Collections.reverse(list);
        System.out.println(list);

        //自定义倒序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //o1-o2为正序、o2-o1为倒序
                return o2-o1;
            }
        });
        System.out.println(list);

        Integer max=Collections.max(list);
        System.out.println(max);

        Integer min=Collections.min(list);
        System.out.println(min);

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

        List<String> list2=new ArrayList<String>(5);
        list2.add("d");
        list2.add("a");
        list2.add("c");
        list2.add("e");
        list2.add("m");

        //正序
        Collections.sort(list2);
        System.out.println(list2);

        //倒序
        Collections.reverse(list2);
        System.out.println(list2);

        //自定义倒序
        Collections.sort(list2, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //o2.compareTo(o1)为倒序，o1.compareTo(o2)为正序
                return o2.compareTo(o1);
            }
        });
        System.out.println(list2);

        String maxString=Collections.max(list2);
        System.out.println(maxString);

        String minString=Collections.min(list2);
        System.out.println(minString);
    }
}

　　执行结果：

　　

　　【自定义数据类型排序】

package com.an.collection.list;

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

/**
 * 自定义数据类型
 */
public class CollectionsTestTwo {

    public static void main(String[] args){
　　　　　//方式1：普通java类，使用2个参数的方法
        Person1 p1=new Person1("a",1);
        Person1 p2=new Person1("d",5);
        Person1 p3=new Person1("b",2);
        Person1 p4=new Person1("e",3);
        Person1 p5=new Person1("m",9);

        List<Person1> list=new ArrayList<Person1>(5);
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);

        Collections.sort(list, new Comparator<Person1>() {
            @Override
            public int compare(Person1 o1, Person1 o2) {
                //按姓名正序
                return o1.getName().compareTo(o2.getName());
            }
        });
        System.out.println(list);

        Collections.sort(list, new Comparator<Person1>() {
            @Override
            public int compare(Person1 o1, Person1 o2) {
                //按姓名倒序
                return o2.getName().compareTo(o1.getName());
            }
        });
        System.out.println(list);

        Collections.sort(list, new Comparator<Person1>() {
            @Override
            public int compare(Person1 o1, Person1 o2) {
                //按年龄正序
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(list);

        Collections.sort(list, new Comparator<Person1>() {
            @Override
            public int compare(Person1 o1, Person1 o2) {
                //按年龄倒序
                return o2.getAge()-o1.getAge();
            }
        });
        System.out.println(list);
　　　　　
　　　　　//方式2：普通类实现Comparable接口
        List<Person2> person2List=new ArrayList<Person2>(5);
        person2List.add(new Person2("c",1));
        person2List.add(new Person2("a",3));
        person2List.add(new Person2("b",2));
        person2List.add(new Person2("e",5));

        Collections.sort(person2List);
        System.out.println(person2List);
    }
}

class Person1{
    private String name;
    private int age;

    public Person1(){

    }

    public Person1(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 this.name+":"+this.getAge();
    }
}

class Person2 implements Comparable<Person2>{
    private String name;
    private int age;

    public Person2(){

    }

    public Person2(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 this.name+":"+this.getAge();
    }

    @Override
    public int compareTo(Person2 o) {
        //按名称正序
        //return this.getName().compareTo(o.getName());
        //按名称倒序
        //return o.getName().compareTo(this.getName());
        //按年龄正序
        //return this.getAge()-o.getAge();
        //按年龄倒序序
        return o.getAge()-this.getAge();
    }
}

　　执行结果：

　　　　　　b,倒序　　　　public static void reverse(List<?> list)