算法复习1——sort函数的使用及重写

1.1 arraylist.sort(Comparator c)

  • 升序:

    算法复习1——sort函数的使用及重写_第1张图片

    sites.sort(Comparator.naturalOrder());
    
    **Comparator 接口的 naturalOrder() 方法指定元素以自然顺序(升序)排序。**
  • 降序:

    sites.sort(Comparator.reverseOrder());

Comparator 接口的 reverseOrder() 方法指定以相反的顺序(降序)对元素进行排序。

1.2 实现Comparable接口,并重写compareTo()方法:

示例:对Person对象,先按照age升序排列,如果age相同,再按照name升序排列

重点

class Person implements Comparable{}

public int compareTo(Person p1){}

Class Person
class Person implements Comparable{
    String name;
    int age;
    public Person(String name,int age){
        this.name =name;
        this.age = age;
    }

    @Override
    public String toString(){
        return "Person:name="+this.name+" age="+this.age;
    }


    //treeSet在add一个元素的时候都会在内部调用多次这个方法,让新填入的元素与已有元素两两进行比较,最终确定新添入的元素到底放在哪里
    @Override
    public int compareTo(Person p1) {
        //先按照age升序排列,如果age相同,再按照name升序排列
        if(this.age == p1.age){
            //字符串默认已经实现了compareTo方法
            return this.name.compareTo(p1.name);
        }else{
            //升序排列
            return this.age -p1.age;
        }
    }
}
test1.java
public class test1 {
    public static void main(String[] args) {
        //TreeSet有序
        TreeSet set =new TreeSet<>();
        //初始化几个实例
        set.add(new Person("A",14));
        set.add(new Person("E",15));
        set.add(new Person("F",12));
        set.add(new Person("B",11));
        set.add(new Person("G",17));
        set.add(new Person("H",15));
        set.add(new Person("A",10));
        set.add(new Person("C",19));
        for (Person person : set) {
            System.out.println(person);
        }
    }
}

结果:

算法复习1——sort函数的使用及重写_第2张图片

1.3 重写comparator比较器的compare(Object o1,Object o2)方法

这样就不需要实体类继承Comparable接口

重点:

Class Person 没有继承Comparable接口
class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name =name;
        this.age = age;
    }

    @Override
    public String toString(){
        return "Person:name="+this.name+" age="+this.age;
    }
}
Class Mycomparator 继承了Comparator比较器,重写compare方法
class MyComparator implements Comparator{
    public int compare(Person p1,Person p2){
        //先按照age升序排列,如果age相同,再按照name升序排列
        if(p1.age == p2.age){
            //字符串默认已经实现了compareTo方法
            return p1.name.compareTo(p2.name);
        }else{
            //升序排列
            return p1.age -p2.age;
        }
    }
}
test1.java 在treeSet对象初始化的时候,就传入一个Comparator比较器,用来对treeSet内部的元素进行比较

==重点:== TreeSet set =new TreeSet(new MyComparator());

public class test1 {
    public static void main(String[] args) {
        //TreeSet有序
        TreeSet set =new TreeSet(new MyComparator());
        //初始化几个实例
        set.add(new Person("A",14));
        set.add(new Person("E",15));
        set.add(new Person("F",12));
        set.add(new Person("B",11));
        set.add(new Person("G",17));
        set.add(new Person("H",15));
        set.add(new Person("A",10));
        set.add(new Person("C",19));
        for (Person person : set) {
            System.out.println(person);
        }
    }
}

1.4 重写comparator比较器,匿名内部类的方式,不需要Mycomparator类

  • Person类和1.3相同
  • 删除Mycomparator类
  • test1.java 使用匿名内部类的方式重写comparator比较器

    写法:

    TreeSet set =new TreeSet(new Comparator(){
        @Override
        public int compare(Person p1, Person p2){
            
        }
    };

    真实代码:

    public class test1 {
        public static void main(String[] args) {
            //TreeSet有序
            TreeSet set =new TreeSet(new Comparator() {
                @Override
                public int compare(Person p1, Person p2) {
                    if(p1.age==p2.age){
                        //字符串默认已经实现了compareTo方法
                        return p1.name.compareTo(p2.name);
                    }
                    else{
                        return p1.age-p2.age;
                    }
                }
            });
            //初始化几个实例
            set.add(new Person("A",14));
            set.add(new Person("E",15));
            set.add(new Person("F",12));
            set.add(new Person("B",11));
            set.add(new Person("G",17));
            set.add(new Person("H",15));
            set.add(new Person("A",10));
            set.add(new Person("C",19));
    
            for (Person person : set) {
                System.out.println(person);
            }
        }
    }

1.5 对于List类或者数组,重写comparator方式不同

  • Person类和1.3相同
  • 删除Mycomparator类
  • 先声明ArrayList对象,使用Collectons.sort(对象名,new Comparator){}方法重写comparator并排序。

    test1.java
    public class test1 {
        public static void main(String[] args) {
            ArrayList a=new ArrayList<>();
    
            //初始化几个实例
            a.add(new Person("A",14));
            a.add(new Person("E",15));
            a.add(new Person("F",12));
            a.add(new Person("B",11));
            a.add(new Person("G",17));
            a.add(new Person("H",15));
            a.add(new Person("A",10));
            a.add(new Person("C",19));
    
            Collections.sort(a, new Comparator() {
                @Override
                public int compare(Person p1, Person p2) {
                    if(p1.age==p2.age){
                        //字符串默认已经实现了compareTo方法
                        return p1.name.compareTo(p2.name);
                    }
                    else{
                        return p1.age-p2.age;
                    }
                }
            });
    
            for (Person person : a) {
                System.out.println(person);
            }
        }
    }
  • 注意:如果是数组,重写的方式是这样的:

    Arrays.sort(数组名, new Comparator<数组元素类型>() {
                @Override
                public int compare(数组元素类型 p1, 数组元素类型 p2) {
                    //规则
                }
    });

你可能感兴趣的:(java)