Сортировать объект списка в том же порядке другого массива java

Question

Здравствуйте, я хочу заказать список сотрудников для объектов отдела, но у меня есть порядок в массиве здесь объектов и пример

public class Employee {

    private String name;
    private int age;
    private double salary;
    private Department department;
    public Employee(String name, int age, double salary, Department department) {
        ...
    }

    // standard getters, setters and toString
 }

public class Department  {

    private Integer id;
    private String name;

    public Department(Integer id, String name) {
        ...
    }

    // standard getters, setters and toString
}

       Department[] departments = new Department[] {
                new Department(1, "Computing" ), new Department(2, "Human Resources"),
                new Department(3, "administration"), new Department(4, "operations"),
                new Department(5, "marketing"), new Department(6, "communication")
        };

  Employee[] employees = new Employee[] {
                new Employee("John", 23, 5000, departments[5]), new Employee("Steve", 26, 6000, departments[3]),
                new Employee("Frank", 33, 7000,departments[4]), new Employee("Earl", 43, 10000, departments[2]),
                new Employee("Jessica", 23, 4000, departments[1]), new Employee("Pearl", 33, 6000, departments[0])};


        String[] arrOrderDepartment = new String[]{"marketing", "Computing", "administration", "Human Resources", "communication", "operations"};

нижняя строка сотрудники, заказанные по приказу организации отдела

employeesSortedByDepartment = [Employee{"Frank", 33, 7000, Department{id=5, name='marketing'}},Employee{ "Jessica", 23, 4000, Department{id=6, name='communication'} },Employee{"Steve", 26, 6000, Department{id=3, name='administration'} },Employee{"Earl", 43, 10000, Department{id=2, name='Human Resources'}},Employee{ "Pearl", 33, 6000, =Department{id=6, name='communication'} },Employee{ "John", 23, 5000, Department{id=4, name='operations'} }];

Я использовал что-то во время работы, но это не дает мне ожидаемый результат

 Collections.sort(department, new Comparator<String>(){
            public int compare(String left, String right) {
                return arrOrderDepartment[stringList.indexOf(left)] - arrOrder[stringList.indexOf(right)];
            }
        });

Я использую java 6

большое спасибо за то, что вы можете мне помочь

Answer 1

Вы можете сделать это следующим образом:

public class Main {
    public static void main(String[] args) {
        Department[] departments = new Department[] { new Department(1, "Computing"),
                new Department(2, "Human Resources"), new Department(3, "administration"),
                new Department(4, "operations"), new Department(5, "marketing"), new Department(6, "communication") };

        Employee[] employees = new Employee[] { new Employee("John", 23, 5000, departments[5]),
                new Employee("Steve", 26, 6000, departments[3]), new Employee("Frank", 33, 7000, departments[4]),
                new Employee("Earl", 43, 10000, departments[2]), new Employee("Jessica", 23, 4000, departments[1]),
                new Employee("Pearl", 33, 6000, departments[0]) };

        String[] arrOrderDepartment = new String[] { "marketing", "Computing", "administration", "Human Resources",
                "communication", "operations" };
        Employee[] employeesSortedByDepartment = new Employee[employees.length];
        for (int i = 0; i < arrOrderDepartment.length; i++) {
            employeesSortedByDepartment[i] = getEmployeeByDeptId(employees,
                    findDeptIdByDeptName(departments, arrOrderDepartment[i]));
        }
        for (Employee employee : employeesSortedByDepartment) {
            System.out.println(employee);
        }
    }

    static int findDeptIdByDeptName(Department[] departments, String departmentName) {
        for (int i = 0; i < departments.length; i++) {
            if (departments[i].getName().equalsIgnoreCase(departmentName)) {
                return departments[i].getId();
            }
        }
        return -1;
    }

    static Employee getEmployeeByDeptId(Employee[] employees, int id) {
        for (Employee employee : employees) {
            if (employee.getDepartment().getId() == id) {
                return employee;
            }
        }
        return null;
    }
}

Вывод:

Employee [name=Frank, age=33, salary=7000.0, department=Department [id=5, name=marketing]]
Employee [name=Pearl, age=33, salary=6000.0, department=Department [id=1, name=Computing]]
Employee [name=Earl, age=43, salary=10000.0, department=Department [id=3, name=administration]]
Employee [name=Jessica, age=23, salary=4000.0, department=Department [id=2, name=Human Resources]]
Employee [name=John, age=23, salary=5000.0, department=Department [id=6, name=communication]]
Employee [name=Steve, age=26, salary=6000.0, department=Department [id=4, name=operations]]

Answer 2

спасибо за ваш ответ. Вчера из анализа и тестирования я получил решение, содержащее что-то похожее на ответ Арвинд Кумар Авина sh! дал мне здесь, я положил код

public class Main {

    public static void main(String[] args) {

        Department[] departments = new Department[] {
                new Department(1, "Computing" ), new Department(2, "Human Resources"),
                new Department(3, "administration"), new Department(4, "operations"),
                new Department(5, "marketing"), new Department(6, "communication"),
                new Department(7, "shopping"), new Department(6, "Inventory")
        };

        final Employee[] employees = new Employee[] {
                new Employee("John", 23, 5000, departments[5]), new Employee("Steve", 26, 6000, departments[3]),
                new Employee("Frank", 33, 7000,departments[4]), new Employee("Earl", 43, 10000, departments[2]),
                new Employee("Jessica", 23, 4000, departments[1]), new Employee("Pearl", 33, 6000, departments[0]),
                new Employee("Pearl", 33, 6000, departments[6]), new Employee("Pearl", 33, 6000, departments[7])
        };


       final String[] arrOrderDepartment = new String[]{"operations", "Computing", "administration", "Inventory", "Human Resources", "communication", "marketing"};

        final List<Employee> employeeList = Arrays.asList(employees);
        List<Employee> copyEmployeeList = Arrays.asList(employees);

        Collections.sort(copyEmployeeList, new Comparator<Employee>(){

            public int compare(Employee o1, Employee o2)
            {
                String a = getDepartmentOfList(o1.getDepartment().getName(), employeeList);
                String b = getDepartmentOfList(o2.getDepartment().getName(), employeeList);

              return  indexOf(a, arrOrderDepartment) - indexOf(b, arrOrderDepartment);
            }
        });

        System.out.println(copyEmployeeList);
    }

    private static String getDepartmentOfList(String name, List<Employee> employeeList) {
        for (Employee employee: employeeList) {
            if (name.equalsIgnoreCase(employee.getDepartment().getName())){
                return employee.getDepartment().getName();
            }
        }
        return null;
    }

    private static int indexOf( String c , String[] arr ) {
        for( int i = 0 ; i < arr.length ; i++ ) {
            if( arr[i].equalsIgnoreCase(c) ) {
                return i;
            }
        }
        return -1;
    }
}

добавить другие отделы, чтобы посмотреть, как код себя ведет, и добавить его, а также другие отделы, чтобы посмотреть, как код себя ведет, и сначала добавить его

Answer 3

Я думаю, вы можете решить эту проблему с помощью сопоставимых форм Java 8 (я полагаю).

Вот документ oracle по этой ссылке. https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html

И эта ссылка содержит пример вашего вопроса. Как отсортировать массив объектов в Java?

Answer 4

Поскольку ваш массив отделов уже находится в порядке 1-6, вам не нужно "сортировать" - вам нужно только применить требуемый порядок.

int[] arrOrderDepartment = {5, 1, 3, 2, 6, 4};

Department[] sortedDepartment = new Department[6];
for (int i = 0; i < 6; i++) {
    sortedDepartment[i] = department[arrOrderDepartment[i] - 1]
}

Сейчас sortedDepartment[0] будет указывать на отдел 5, а sortedDepartment[1] будет указывать на отделение 1 и т. Д.