Java：按两列对多维数据进行排序，并在顶部设置特定行

假设我有一个数组：

[
  ['Chief 1', 'Chief 1'],
  ['Employee 5', 'Chief 2'],
  ['Employee 4', 'Chief 1'],
  ['Employee 2', 'Chief 1'],
  ['Chief 2', 'Chief 2'],
]

我的目标：

[
    ['Chief 1', 'Chief 1'],
    ['Employee 2', 'Chief 1'],
    ['Employee 4', 'Chief 1'],
    ['Chief 2', 'Chief 2'],
    ['Employee 5', 'Chief 2'],
]

我想按每个员工的主管对其进行分组，以便根据字母顺序对数组进行排序，并使主管位于顶部。
这是我迄今为止所做的，但仍然没有达到预期的效果：

Object[][] data = new Object[2][5];
// after filling the data array
Arrays.sort(data, new Comparator<Object[]>() {
                @Override
                public int compare(Object[] o1, Object[] o2) {
                    String employee1 = (String) o1[0];
                    String employee2 = (String) o2[0];
                    String chief1 = (String) o1[1];
                    String chief2 = (String) o2[1];

                    if(employee1.equals(chief1)){// column 1 equal to column 2 so this is a chief and must stay first
                        return -1;
                    }else{
                        if(chief1.equals(chief2)){// if row 1 equals row 2 so it's the same chief then compare by employe
                            return employee1.compareTo(employee2);
                        }
                        return chief1.compareTo(chief2);// else compare by chief
                    }
                }
            });

在本例中，我有两位酋长

BRAHMI Younes

和

NACEUR Mohamed Ali

我的当前代码给出了这个结果，他们按字母顺序排序，但酋长不显示在其员工的顶部。

Arrays.sort（数据，new Comparator（）{
Arrays.sort(data, new Comparator<Object[]>() {
            @Override
            public int compare(Object[] o1, Object[] o2) {
                String employee1 = (String) o1[0];
                String employee2 = (String) o2[0];
                String chief1 = (String) o1[1];
                String chief2 = (String) o2[1];

                if(chief1.equals(chief2))
                    // same chief, sort by empolyee keeping Chief at top
                    if(employee1.equals(chief1))
                        return -1;
                    else if(employee2.equals(chief2))
                        return 1;
                    else
                        return employee1.compareTo(employee2);
                else
                    // if chiefs aren't equals, sort relying on them
                    return chief1.compareTo(chief2);
            }
        });

@凌驾
公共整数比较（对象[]o1，对象[]o2）{
字符串employee1=（字符串）o1[0]；
字符串employee2=（字符串）o2[0]；
字符串chief1=（字符串）o1[1]；
字符串chief2=（字符串）o2[1]；
如果（chief1等于（chief2））
//同一个首领，按empolyee排序保持首领在顶端
如果（雇员1.等于（chief1））
返回-1；
else if（雇员2.等于（chief2））
返回1；
其他的
返回员工1.与（员工2）进行比较；
其他的
//如果酋长们不平等，那就依靠他们
返回chief1.compareTo（chief2）；
}
});

数组。排序（数据，新比较器（）{
@凌驾
公共整数比较（对象[]o1，对象[]o2）{
字符串employee1=（字符串）o1[0]；
字符串employee2=（字符串）o2[0]；
字符串chief1=（字符串）o1[1]；
字符串chief2=（字符串）o2[1]；
如果（chief1等于（chief2））
//同一个首领，按empolyee排序保持首领在顶端
如果（雇员1.等于（chief1））
返回-1；
else if（雇员2.等于（chief2））
返回1；
其他的
返回员工1.与（员工2）进行比较；
其他的
//如果酋长们不平等，那就依靠他们
返回chief1.compareTo（chief2）；
}
});

基本上，您要做的是对行进行排序，然后按进行分组。使用Java8流可以更干净地完成这项工作

假设您定义了一个辅助类

关系

来表示每一行：

class Relation implements Comparable<Relation> {
    String chief;        
    String employee;

    public Relation(String[] row) {
        employee = row[0];            
        chief = row[1];
    }

    @Override
    public int compareTo(Relation other) {
        return chief.equals(employee) ? -1 : employee.compareTo(other.employee);        
    }

    @Override
    public String toString() {
        return String.format("[%s, %s]", employee, chief);
    }
}

---

基本上，您要做的是对行进行排序并按分组。使用Java8流可以更干净地完成这项工作

假设您定义了一个辅助类

关系

来表示每一行：

class Relation implements Comparable<Relation> {
    String chief;        
    String employee;

    public Relation(String[] row) {
        employee = row[0];            
        chief = row[1];
    }

    @Override
    public int compareTo(Relation other) {
        return chief.equals(employee) ? -1 : employee.compareTo(other.employee);        
    }

    @Override
    public String toString() {
        return String.format("[%s, %s]", employee, chief);
    }
}

---

不要用“酋长”作为第二维度，你能用数字并按它排序吗？（即，[首席1'，1]，[员工1'，1]…[员工5'，2]）@DanielGale不行，一定是Strings所有的

首席#

都保证在字典上比任何给定的

员工#

？@JanezKuhar我编辑了我的问题，你可以找到我处境的真实例子。不要使用“首席”作为第二维度，你能用这个号码按它排序吗？（即[首席1'，1]，“员工1'，1]…[员工5'，2]）@DanielGale不，我不能，一定是Strings所有的

主管
都保证比任何给定的
员工都小
？@JanezKuhar我编辑了我的问题你可以找到一个真实的我的情况的例子。我会尝试一下，但我不认为这会让主管在他的员工面前保持领先地位，局长仍然没有出现在他的员工的最高层。你是对的，我的错，我跳过了问题的那一部分。编辑应该又坏了，没有看到问题if（employee1.equals（chief1））的op编辑不是if（employee1.equals（employee1）。我会试试，但我不认为这会让主管保持在员工的顶部。例如，主管仍然没有出现在员工的顶部。你是对的，我的错，我跳过了问题的这一部分。编辑应该再次起作用。汤米·巴德，没有看到问题的op编辑if（employee1.equals（chief1））not if（employee1.equals）（chief1））not if（employee1.equals（雇员1）这看起来真的很干净，但我不认为这会让主管在员工中占据上风，不管他的名字是什么。我说的对吗？@SlimenTN是的，会的。这看起来真的很干净，但我不认为这会让主管在员工中占据上风，不管他的名字是什么。我说的对吗？@SlimenTN是的，会的。
relations.stream()
    .sorted()
    .collect(Collectors.groupingBy(s -> s.chief))
    .values().stream()
    .flatMap(Collection::stream)
    .forEach(System.out::println);