带字段的比较器 类
Comparator classes with fields
在一个使用 class 实现 Comparator 接口的项目中，为了比较一些可比较的对象，我注意到我可以设计 class使用字段 实现 Comparator<> 接口 ，然后 Override compare(...) 函数并将 class 的字段用于比较函数逻辑。
所以我必须像这样调用排序函数：
Collections.sort(someArrayList, new SortClass(argument1, argument2));
我的问题是：
做这样的事情有多普遍？
是否算是好的设计？
假设我得到一个用户输入，它应该改变一些对象之间的比较逻辑，构建一个新的包装器class（使用给定的参数）会被认为是更好的解决方案？
根据要求，我的 SortClass 是（我在上一节中概括了它，但这是我真正的排序 class）：
public class SortHouses implements Comparator<Hotel> {
/** if house1 should be before house2 */
private static final int GT = -1;
/** if house1 should be after house2 */
private static final int LT = 1;
private double latitude;
private double longitude;
public SortHouses(double latitude, double longitude){
this.latitude = latitude;
this.longitude = longitude;
}
@Override
public int compare(House house1, House house2) {
double distHouse1 = Math.sqrt((Math.pow((house1.getLatitude() - latitude), 2) +
Math.pow((house1.getLongitude() - longitude), 2)));
double distHouse2 = Math.sqrt((Math.pow((house2.getLatitude() - latitude), 2) +
Math.pow((house2.getLongitude() - longitude), 2)));
if (distHouse1 < distHouse2){
return GT;
}
if (distHose1 > distHouse2) {
return LT;
}
if (house1.getNum() > house2.getNum()){
return GT;
}
return LT;
}
}
How common doing something like this is?
参数化比较器？不是很常见。通常，事物是根据它们自己的属性进行排序的。
Is it considered a good design?
是的，如果您想按到参考位置的距离对位置进行排序，那么使用参数化比较器似乎是完成此操作的好方法。
但是，我可以看到一件事我不喜欢。您的 SortHotelsByProximity 实际上是在与 POI（兴趣点？）进行 "secret" 比较，以防平局。
如果您将此逻辑移动到第二个比较器中，会更清楚，并在以后给您更多的灵活性：SortHotelsByPOI。您可以将 Comparators 组合在一起以使用方法 thenComparing 计算平局，它看起来像这样：
hotels.sort(new SortHotelsByProximity().thenComparing(new SortHotelsByPOI()))
Assuming I get a user input which should change the logic of the
comparison between some objects, building a new wrapper class (with
the given parameters) would be considered as a better solution for
that matter?
我不知道你所说的 'wrapper class' 是什么意思，但是如果你要问的话，基于用户输入动态构建比较器就可以了。
在一个使用 class 实现 Comparator 接口的项目中，为了比较一些可比较的对象，我注意到我可以设计 class使用字段 实现 Comparator<> 接口 ，然后 Override compare(...) 函数并将 class 的字段用于比较函数逻辑。
所以我必须像这样调用排序函数：
Collections.sort(someArrayList, new SortClass(argument1, argument2));
我的问题是：
做这样的事情有多普遍？
是否算是好的设计？
假设我得到一个用户输入，它应该改变一些对象之间的比较逻辑，构建一个新的包装器class（使用给定的参数）会被认为是更好的解决方案？
根据要求，我的 SortClass 是（我在上一节中概括了它，但这是我真正的排序 class）：
public class SortHouses implements Comparator<Hotel> {
/** if house1 should be before house2 */
private static final int GT = -1;
/** if house1 should be after house2 */
private static final int LT = 1;
private double latitude;
private double longitude;
public SortHouses(double latitude, double longitude){
this.latitude = latitude;
this.longitude = longitude;
}
@Override
public int compare(House house1, House house2) {
double distHouse1 = Math.sqrt((Math.pow((house1.getLatitude() - latitude), 2) +
Math.pow((house1.getLongitude() - longitude), 2)));
double distHouse2 = Math.sqrt((Math.pow((house2.getLatitude() - latitude), 2) +
Math.pow((house2.getLongitude() - longitude), 2)));
if (distHouse1 < distHouse2){
return GT;
}
if (distHose1 > distHouse2) {
return LT;
}
if (house1.getNum() > house2.getNum()){
return GT;
}
return LT;
}
}
How common doing something like this is?
参数化比较器？不是很常见。通常，事物是根据它们自己的属性进行排序的。
Is it considered a good design?
是的，如果您想按到参考位置的距离对位置进行排序，那么使用参数化比较器似乎是完成此操作的好方法。
但是，我可以看到一件事我不喜欢。您的 SortHotelsByProximity 实际上是在与 POI（兴趣点？）进行 "secret" 比较，以防平局。
如果您将此逻辑移动到第二个比较器中，会更清楚，并在以后给您更多的灵活性：SortHotelsByPOI。您可以将 Comparators 组合在一起以使用方法 thenComparing 计算平局，它看起来像这样：
hotels.sort(new SortHotelsByProximity().thenComparing(new SortHotelsByPOI()))
Assuming I get a user input which should change the logic of the comparison between some objects, building a new wrapper class (with the given parameters) would be considered as a better solution for that matter?
我不知道你所说的 'wrapper class' 是什么意思，但是如果你要问的话，基于用户输入动态构建比较器就可以了。