标签: comparator

我正在尝试使用自定义排序功能实现树集。我已经通过了包含排序逻辑的比较器对象。

import java.util.Comparator;
import java.util.TreeSet;

public class MySetWithCompr {

    public static void main(String a[]){

        TreeSet<String> ts = new TreeSet<String>(new MyComp());
        ts.add("Test1");
        ts.add("Test2");
        ts.add("Test3");
        ts.add("Test4");
        System.out.println(ts);
    }
}

class MyComp implements Comparator<String>{

    @Override
    public int compare(String str1, String str2) {
        return str1.compareTo(str2);
    }

}

上面的程序给了我下面的输出

[Test1, Test2, Test3, Test4]

请建议如何实现比较器逻辑，以便结果相反

Expected Result : [Test4, Test3, Test2, Test1]

是否可以首先按员工对象的工资对员工对象进行排序，如果两个对象的工资相等，然后使用比较器和比较器接口按名称对它们进行比较？

例如，我有一个 Employee 类，如下所示

public class Employee{
    private int salary;
    private int name;
    public Employee(salary,name){
        this.salary = salary;
        this.name = name;
    }
    //...........getter methods...........
}

现在假设我们有一个 Employee 对象列表，其中包含一些工资金额和姓名。我想使用比较器或类似的接口，并以这样的方式对列表进行排序：列表根据薪水排序，如果薪水相同，那么在这种情况下，这两个 Employee 对象必须按其名称排序。有人可以告诉我是否可能吗？代码片段将不胜感激。

我在这里的第一个帖子问题，请保持温和:)

我正在尝试在 Java 中创建一个基于各种标准进行排序的比较器。Main 类是非常基础的，它有几个排序所基于的变量。

例如，一个“Book”类，它有：

• 页码，
• 标题，
• 每页平均字数。

以下是我收到的“指示”：

编写一个 ComplexComperator，它可以根据多个变量进行排序。制作2个构造函数：

一个有2个参数

 public ComplexComparator(Comparator<Book> x, Comparator<Book> y)

如果两个项目基于第一个参数相等，则根据第二个参数排序，

另一个有 4 个参数

 public ComplexComparator(Comparator<Book> x, boolean h, Comparator<Book> y, boolean i)

如果逻辑变量为真，它会根据该 Comparator 以自然顺序对其进行排序 - 因此它的工作方式与 2 参数构造函数相同。如果其中一个逻辑变量取假值，则会颠倒自然顺序。

就是这样了。我写了简单的比较器，但我不知道如何处理这个。我不知道 compare 方法应该是什么样子；或者即使我必须添加某种类变量......谢谢你的帮助！

鉴于 Java 类的这种组合：

public class OuterClass
    {
        public String           field01;
        public int              field02;
        public InnerClass       innerField
        // ...getters, setters

    public class InnerClass
        {
            public int              innerField01;
            public BigDecimal       innerField02;
            // ...getters, setters

我想按外部和内部字段对它们进行排序。现在，给定 a List<OuterClass> list，我可以轻松地对其进行排序，例如field01：

Collections.sort(list, Comparator.comparing(OuterClass::getField01));

但我可以按哪种方式排序InnerClass.innerfield.innerfield01呢？我试过

Collections.sort(list, Comparator.comparing(OuterClass::InnerField::innerField01));

以及其他一些方法，但都没有成功。也许我应该以某种方式使用OuterClass::new，但我不知道如何使用。

我想在 TreeMap 中存储键值对，并根据以下逻辑根据 Key 的值对条目进行排序：

按键的长度排序。如果两个键的长度相同，则按字母顺序对它们进行排序。例如，对于以下键值对。

IBARAKI MitoCity
TOCHIGI UtunomiyaCity
GUNMA MaehashiCity
SAITAMA SaitamaCity
CHIBA ChibaCity
TOKYO Sinjyuku
KANAGAWA YokohamaCity

预期的输出是这样的。

CHIBA : ChibaCity
GUNMA : MaehashiCity
TOKYO : Sinjyuku
IBARAKI : MitoCity
SAITAMA : SaitamaCity
TOCHIGI : UtunomiyaCity
KANAGAWA : YokohamaCity

所以我试图创建一个井字游戏，我遇到了我的一种方法的问题，我无法弄清楚为什么它会无限循环。我的代码是：

def player_input():
    marker = ''
    while marker != 'X' or marker != 'O':
        marker = input('Do you want to be X or O: ').upper()
        print(marker)

    if marker == 'X':
        return ['X','O']
    return ['O','X']

它目前正在做的是，即使用户输入 X 或 O，它也会不断提出问题。当我使用条件时，代码有效：

while not (marker == 'X' or marker == 'O'):

我有一个功能可以按 3 个整数字段对 pojo 列表进行排序。

目前我正在使用comparingInt()和thenComparingBy()。

但我可能会在两者之间得到一个空值。这会抛出一个NullPointerException.

为此，我想在末尾添加空值。Comparator.nullsLast()不适用于我的情况，因为我正在比较 3 个整数值。

有没有办法实现这一点......

我Point在头文件中定义了一个结构类，如下所示 -

namespace global_planner {
    class GlobalPlanner : public nav_core::BaseGlobalPlanner {
        struct Point {
            __uint32_t x, y; 
            bool operator==(const Point &p1 ) {
                return ((p1.x == x) && (p1.y == y));  
            }
            bool operator<(const Point &p1 ) const {
                return ((p1.x < x) || (p1.x == x && p1.y < y) ) ; 
            }   
        };
    public:
        ///
    private: 
        ////               
    };
    
};

在我的源文件（名为global_planner.cpp）中，我有一个名为的函数，generate_straight_path定义如下 -

bool GlobalPlanner::generate_straight_path(const Point &p1, const Point &p2){        
    if(costmap_ros_->getCost(p1.x, p1.y) == costmap_2d::LETHAL_OBSTACLE) …

如何根据设置位的计数对数组进行排序？我在下面的代码中遇到错误：

Arrays.sort(arr, (o1, o2) -> {
    if (Integer.bitCount(o1) <=  Integer.bitCount(o2))
        return 1;
    return -1;
});

例外：

Exception in thread "main" java.lang.IllegalArgumentException: Comparison method violates its general contract!
    at java.base/java.util.TimSort.mergeLo(TimSort.java:781)
    at java.base/java.util.TimSort.mergeAt(TimSort.java:518)
    at java.base/java.util.TimSort.mergeCollapse(TimSort.java:448)
    at java.base/java.util.TimSort.sort(TimSort.java:245)
    at java.base/java.util.Arrays.sort(Arrays.java:1441)
    at Compute.sortBySetBitCount(File.java:44)
    at GFG.main(File.java:23)

如何解决这个问题？

问题（Java 集合中没有重复的二叉树）。

我需要一个具有重复项的二叉树，我需要 O(Log(n)) 复杂度的搜索和插入，同时保持顺序（所以我不能使用哈希表），java没有实现二叉树的集合并允许重复，同时保留所有二叉树操作。

我们可以使用 TreeSet 来做到这一点吗？

我正在尝试调整 TreeSet 并通过传递一个永远不会返回 0 的比较器来允许重复项。我知道这不再是一个集合，但没关系，我需要重复项。

例子

TreeSet<Integer> binaryTreeWithDuplicates = new TreeSet<Integer>((x, y) -> x>y?1:-1);

这种实施和使用会产生不良的副作用吗？因为我们显然违反了比较器 api
中的规则，例如符号规则。