Arrays

了解比较器之前首先来了解一下java.util包下的Arrays类。这个类主要提供了各种操作数组的方法。最常用的几个方法：

Arrays.toString(T[] data) //将数组以字符串的形式返回
Arrays.sort(T[] data)//将数组按指定的比较规则以升序的顺序排序，T类需要实现Comparable接口
Arrays.sort(T[],Comparator<? super T>)//将数组按指定的比较器以升序的顺序排序
Arrays.fill(T[] data,T val)//数组的每一个元素赋值为val

调用Arrays.sort(T[] data) 时，数组中的所有元素必须是可以比较的，如果元素是引用类型，那么必须实现Comparable接口，否则会抛异常。

import test.City;
import tmall.bean.Category;
import tmall.util.DBUtil;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        int data[]=new int[10];
        System.out.println(Arrays.toString(data));
        Arrays.fill(data,3);
        System.out.println(Arrays.toString(data));
        int data2[]={1,9,8,5,3,7,1,-1};
        System.out.println(Arrays.binarySearch(data2,9));
        Arrays.sort(data2);
        System.out.println(Arrays.toString(data2));
        System.out.println(Arrays.binarySearch(data2,9));


    }
}

运行结果：

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
-9
[-1, 1, 1, 3, 5, 7, 8, 9]
7

 

比较器之Comparable<T>接口

实现对象之间的比较有两个方法，第一个方法就是实现Compatable接口。Comparable接口是java.lang包下的。该接口只有一个方法：

int compareTo(T o)//返回三种情况：负整数、0、正整数。分别表示小于、等于、大于

当我们想要比较两个对象的大小时，由于栈中存的是对象的地址，所以无法比较。于是我们需要实现Comparable接口，并且重写compareTo方法。其实，String类就是实现了Comparable接口，才有了compareTo()的方法。

public class Main {
    public static void main(String[] args) throws IOException {
        City c1=new City("宁波","雨",1);
        City c2=new City("杭州","晴",2);
        City[] cs=new City[]{c1,c2};
        Arrays.sort(cs);
        System.out.println(Arrays.toString(cs));

    }
}

public class City implements Comparable<City>{
    private String name;
    private String weather;
    private int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getWeather() {
        return weather;
    }

    public void setWeather(String weather) {
        this.weather = weather;
    }

    public City(String name, String weather, int id) {

        this.name = name;
        this.weather=weather;
        this.id = id;
    }

    @Override
    public String toString() {
        return "City{" +
                "name='" + name + '\'' +
                ", weather='" + weather + '\'' +
                ", id=" + id +
                '}';
    }

    @Override
    public int compareTo(City o) {
        if (this.id<o.id){
            return -1;
        }else if (this.id==o.id){
            return 0;
        }else {
            return 1;
        }
    }
}

运行结果：

[City{name='宁波', weather='雨', id=1}, City{name='杭州', weather='晴', id=2}]

 

比较器之Comparator<T>接口

实现对象的比较第二个方法是额外写一个比较工具类，该工具类需要实现Comparator接口。既然有了Comparable接口可以实现比较，为什么还要有Comparator接口呢？因为Comparable接口在类定义的时候就要实现好Comparable的compareTo()方法。假设我已经写好了City类，不想再改变改类的内部结构，这时我们就可以通过再写一个工具类来实现City类的比较。另外，通过多个工具类可以实现多种不同的比较方法。

实现Comparator接口需要重写compare方法：

public class Main {
    public static void main(String[] args) throws IOException {
        City c1=new City("ningbo","雨",1);
        City c2=new City("hangzhou","晴",2);
        City[] cs=new City[]{c1,c2};
        Arrays.sort(cs, new CityIdComparator());
        System.out.println(Arrays.toString(cs));
        Arrays.sort(cs,new CityNameComparator());
        System.out.println(Arrays.toString(cs));

    }
}

import java.util.Comparator;

public class CityIdComparator implements Comparator<City> {
    @Override
    public int compare(City o1, City o2) {
        if(o1.getId()<o2.getId()){
            return -1;
        }else if (o1.getId()==o2.getId()){
            return 0;
        }else {
            return 1;
        }
    }
}

import java.util.Comparator;

public class CityNameComparator implements Comparator<City> {
    @Override
    public int compare(City o1, City o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

public class City {
    private String name;
    private String weather;
    private int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getWeather() {
        return weather;
    }

    public void setWeather(String weather) {
        this.weather = weather;
    }

    public City(String name, String weather, int id) {

        this.name = name;
        this.weather=weather;
        this.id = id;
    }

    @Override
    public String toString() {
        return "City{" +
                "name='" + name + '\'' +
                ", weather='" + weather + '\'' +
                ", id=" + id +
                '}';
    }


}

运行结果：

[City{name='ningbo', weather='雨', id=1}, City{name='hangzhou', weather='晴', id=2}]
[City{name='hangzhou', weather='晴', id=2}, City{name='ningbo', weather='雨', id=1}]

在上例中我就通过编写两个比较器来实现两种比较方法。而如果是实现Comparable接口的话就只能有一种比较方法。

不过可以看出来，实现Comparable接口的方法比较方便，可以不用再写一个比较器。所以如果我们没有特殊需要的话，一般情况下会选择用第一种方法。