Question

我正在尝试创建一种方法，该方法使用.stream（）按字母顺序对我存储在存储库中的数据进行排序和输出。目前，我有一种方法，可以按数字顺序按CityID对数据进行排序，这将在下面添加。有没有办法让它适应相同的数据，但是按CityName按字母顺序排序？

CityID方法-

private void listCityDataInCityIdOrder() {
    System.out.format("\033[31m%s\033[0m%n", "City Id Order");
    System.out.format("\033[31m%s\033[0m%n", "=============");
    repository.getItems()
            .stream()
            .sorted()
            .map(c -> c.toString())
            .forEach(str -> System.out.print(str));
}

数据集-

1,"Cartagena","Spain",3
"2015",0.2,33,26,6,"S"
"2016",0.0,33,24,8,"SSW"
"2017",0.0,32,25,6,"E"
2,"Glasgow","Scotland",3
"2015",0.0,19,8,3,"SE"
"2016",0.1,21,11,6,"SE"
"2017",2.1,19,11,9,"SW"

城市模型类-

package model;

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

/**
 *
 * @author mga
 */
public class City implements Comparable<City>{
    private final int id;
    private String cityName;
    private String country;
    private List<YearData> yearDataCollection;

    private static int lastIdAllocated = 0;

    static final char EOLN='\n';
    static final String QUOTE="\"";

    public City() {
        this.id = ++lastIdAllocated;
        this.cityName = "TBC";
        this.country = "TBC";
        this.yearDataCollection = new ArrayList<>();
    }

    public City(String cityName, String country) {
        this.id = ++lastIdAllocated;
        this.cityName = cityName;
        this.country = country;
        this.yearDataCollection = new ArrayList<>();
    }

    public City(String cityName, String country, List<YearData> yearDataCollection) {
        this.id = ++lastIdAllocated;
        this.cityName = cityName;
        this.country = country;
        this.yearDataCollection = yearDataCollection;
    }

    public City(int id, String cityName, String country, List<YearData> yearDataCollection) {
        this.id = id;
        this.cityName = cityName;
        this.country = country;
        this.yearDataCollection = yearDataCollection;
        if (id > City.lastIdAllocated)
            City.lastIdAllocated = id;
    }


    /**
     * @return the id
     */
    public int getId() {
        return id;
    }

    // Methods required:

    public String getCityName() {
        return this.cityName;
    }

    public void setCityName(String cityName) {
        this.cityName = cityName;
    }

    public String getCountry() {
        return this.country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public List<YearData> getYearDataCollection() {
        return this.yearDataCollection;
    }

    public void setYearDataCollection(List<YearData> yearDataCollection) {
        this.yearDataCollection = yearDataCollection;
    }

    public void addYearData(YearData yearData) {
        this.yearDataCollection.add(yearData);
    }


    @Override
    public String toString() {
        return "\nCity Id: " + id + " - City Name: " + cityName +
                " - Country: " + country + "\nData: " + yearDataCollection + "\n";
    }


    public String toString(char delimiter) {
        final char EOLN='\n';
        final String QUOTE="\"";
        String str = Integer.toString(this.id) + delimiter +
                QUOTE + this.cityName + QUOTE + delimiter +
                QUOTE + this.country + QUOTE + delimiter +
                Integer.toString(yearDataCollection.size()) + EOLN;
        for (YearData yearData : yearDataCollection) {
            str += yearData.toString();
        }
        return str;
    }

    public boolean equals(Object object) {
        if (this == object) return true;
        if (!(object instanceof City)) return false;
        if (!super.equals(object)) return false;
        City city = (City) object;
        return getId() == city.getId() &&
                java.util.Objects.equals(getCityName(), city.getCityName()) &&
                java.util.Objects.equals(getCountry(), city.getCountry()) &&
                java.util.Objects.equals(getYearDataCollection(), city.getYearDataCollection());
    }

    public int hashCode() {
        return Objects.hash(super.hashCode(), getId(), getCityName(), getCountry(), getYearDataCollection());
    }

    @Override
    public int compareTo(City compareCity) {

        int cityId =
                ((City) compareCity).getId();

        //ascending order
        return this.id - cityId;

        //descending order
        //return cityId - this.id;
    }


    public static Comparator<City> CityComparator = new Comparator<City>() {
        @Override
        public int compare(City city1, City city2) {

            String cityName1 = city1.getCityName();
            String cityName2 = city2.getCityName();

            //ascending order
            //return cityName1.compareTo(cityName2);

            //descending order
            return cityName2.compareTo(cityName1);
        }
   };

}

Answer 1

确定，将您的sorted更改为：

.sorted(Comparator.comparing(City::getCityName))

或使用lambda：

.sorted(Comparator.comparing(c -> c.getCityName()))

Answer 2

您可以简化您的比较器

public static Comparator<City> CityComparator = new Comparator<City>() {
    @Override
    public int compare(City city1, City city2) {

        String cityName1 = city1.getCityName();
        String cityName2 = city2.getCityName();

        //ascending order
        //return cityName1.compareTo(cityName2);

        //descending order
        return cityName2.compareTo(cityName1);
    }
};

仅此：

Comparator<City> cityComparatorSimplified = Comparator
        .comparing(City::getCityName).reversed(); // reverse for descending order

，然后在以

排序时进一步使用它

repository.getItems().stream()
            .sorted(cityComparatorSimplified)
            .map(Object::toString)
            .forEach(System.out::print);

如何使用.stream（）

2 个答案: