乐趣区

关于java:算法复习1sort函数的使用及重写

jiezi

1.1 arraylist.sort(Comparator c)

  • 升序：

    sites.sort(Comparator.naturalOrder());

**Comparator 接口的 naturalOrder() 办法指定元素以天然程序（升序）排序。**

  • 降序：

    sites.sort(Comparator.reverseOrder());

Comparator 接口的 reverseOrder() 办法指定以相同的程序（降序）对元素进行排序。

1.2 实现 Comparable 接口，并重写 compareTo()办法：

示例：对 Person 对象，先依照 age 升序排列，如果 age 雷同，再依照 name 升序排列

重点

class Person implements Comparable<Person>{}

public int compareTo(Person p1){}

Class Person 
class Person implements Comparable<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;}


    //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<Person> 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.3 重写 comparator 比拟器的 compare(Object o1,Object o2)办法

这样 就不须要实体类继承 Comparable<Object> 接口

重点：

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<Object> 比拟器，重写 compare<Object o1,Object o2> 办法 
class MyComparator implements Comparator<Person>{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<Person> set =new TreeSet<Person>(new MyComparator());

public class test1 {public static void main(String[] args) {
        //TreeSet 有序
        TreeSet<Person> set =new TreeSet<Person>(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<Person> set =new TreeSet<Person>(new Comparator<Person>(){
    @Override
    public int compare(Person p1, Person p2){}};

    实在代码：

    public class test1 {public static void main(String[] args) {
        //TreeSet 有序
        TreeSet<Person> set =new TreeSet<Person>(new Comparator<Person>() {
            @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<Person>){}办法重写 comparator 并排序。

    test1.java 
    public class test1 {public static void main(String[] args) {ArrayList<Person> 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<Person>() {
            @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) {// 规定}
});
退出移动版