I need to sort an arraylist of employee records three ways by the same two crite
ID: 3760757 • Letter: I
Question
I need to sort an arraylist of employee records three ways by the same two criteria (department and ID). Most of the code is already in place. Still need help completing the sorting methods:
1) "sortByDeptById1" needs to sort once by dept., then once by id (I've already written a good part of it. not sure how well).
2) "sortByDeptById2" needs to sort once, handling both criteria (dept & ID) in one pass. I've already go
3) "sortByDeptById3" needs to bucket sort the employees list using the 'deptToIndex method, then stable sort the buckets.
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class SortProj1{
//Read employees from file into list
static ArrayList readFromFile(String filename) {
ArrayList employees = new ArrayList();
try (Scanner in = new Scanner(new File(filename))) {
while (in.hasNextLine()){
String[] fields = in.nextLine().split(",");
employees.add(new Employee(Integer.parseInt(fields[1]), fields[0], fields[2]));
}
} catch (FileNotFoundException e){
e.printStackTrace();
}
return employees;
}
//Write employees to a file
static void writeToFile(ArrayList employees, String filename){
try (FileWriter out = new FileWriter(filename)) {
for (Employee s : employees) {
out.write(s.toString());
out.write(" ");
}
} catch (IOException e) {
e.printStackTrace();
}
}
/*Sort employees list by dept. Same dept employees are sorted by ID.
(Do this one in two separate stable sorts, one for each criteria)*/
static void sortByDeptById1(ArrayList employees){
//****************Add code here**************************************************
//Department Comparator
class EmployeeDeptCompare implements Comparator{
@Override
public int compare(Employee o1, Employee o2){
return o1.getDept().compareTo(o2.getDept());
}
}
//ID Comparator
class EmployeeIdCompare implements Comparator{
@Override
public int compare(Employee o1, Employee o2){
return o1.getId() - o2.getId();
}
}
//Instantiate comparator classes
EmployeeDeptCompare empDepts = new EmployeeDeptCompare();
EmployeeIdCompare empIds = new EmployeeIdCompare();
//Sort by dept then by ID
Collections.sort(employees, empDepts);
Collections.sort(employees, empIds);
//*******************************************************************************
}
//Sort employees list by dept. Same dept employees are sorted by ID.
//(Do this one in a single sort that handles both criteria)
static void sortByDeptById2(ArrayList employees){
//****************Add code here**************************************************
class EmployeeDeptIdCompare implements Comparator{
@Override
public int compare(Employee o1, Employee o2){
int result = o1.getId() - o2.getId();
if (result == 0) {
return o1.getDept().compareTo(o2.getDept());
} else {
return result;
}
}
}
//Instantiate comparator class
EmployeeDeptIdCompare empDeptIdComparator = new EmployeeDeptIdCompare();
//sort by department & ID in a single pass.
Collections.sort(employees, empDeptIdComparator);
//********************************************************************************
}
/*
Use this method when writing bucket sort code in "sortByDeptById3".
It returns the bucket index for each dept (depts in alphabetical order):
"ADMIN", "ENG", "HR", "MFG", "MKTNG", "PUB", "SALES"
0 1 2 3 4 5 6
*/
private static int deptToIndex(String dept) {
switch (dept) {
case "ADMIN":
return 0;
case "ENG":
return 1;
case "HR":
return 2;
case "MFG":
return 3;
case "MKTNG":
return 4;
case "PUB":
return 5;
case "SALES":
return 6;
default:
System.err.println("Unknown dept " + dept);
return -1;
}
}
/*Sort employees list by dept. Same dept employees are sorted by ID.
Start with bucket sort of employees list using the above 'deptToIndex'
method, then sort the buckets.*/
static void sortByDeptById3(ArrayList employees){
final int NUM_DEPTS = 7;
// an array of lists. Each element is a reference to a list.
ArrayList[] buckets = (ArrayList[]) new ArrayList[NUM_DEPTS];
//****************Add code here*****************************************************************
//**********************************************************************************************
}
public static void main(String[] args){
ArrayList employees1 = readFromFile("employees.txt");
// make 2 other copies so we don't have to read the file again
ArrayList employees2 = (ArrayList) employees1.clone();
ArrayList employees3 = (ArrayList) employees1.clone();
// let's time the three sorts for fun. Not really that accurate.
long start, end;
start = System.currentTimeMillis();
sortByDeptById1(employees1);
end = System.currentTimeMillis();
System.out.println("Two stable sorts took " + (end - start)
+ " milliseconds.");
start = System.currentTimeMillis();
sortByDeptById2(employees2);
end = System.currentTimeMillis();
System.out.println("One stable sort with a two criteria comparator took "
+ (end - start) + " milliseconds.");
start = System.currentTimeMillis();
sortByDeptById3(employees3);
end = System.currentTimeMillis();
System.out.println("Bucket sort took " + (end - start)
+ " milliseconds.");
if (!(employees1.equals(employees2) && employees2.equals(employees3))) {
System.out.println("Fix me: One or more sorts are incorrect.");
}
writeToFile(employees3, "employeesSorted.txt");
}
}// End of SortProj1 class
//Employee class (no changes needed here)
public class Employee {
private int id;
private String name;
private String dept;
public Employee (int id, String name, String dept) {
this.id = id;
this.name = name;
this.dept = dept;
}
int getId() {
return id;
}
String getDept() {
return dept;
}
@Override
public String toString() {
return name + "," + id + "," + dept;
}
}// End of Employee class
// employees.txt file contents:
James Goss,43901450,SALES
Jona Prince,28152842,MKTNG
Reba Zoering,28149026,HR
Jack Mercer,65030459,PUB
Vilmer Eiddlemann,42237807,ENG
Zoey Apolonese,23070708,ADMIN
Gertie Goldstein,66737716,SALES
Jean Schnarz,41549126,ENG
Marcia Faceplant,97606808,PUB
Zoma Saakan,66620395,MFG
Marina Nunmatters,99389900,ENG
Matilda Whale,59498002,MKTNG
Explanation / Answer
(1).
static void sortByDeptId1(ArrayList employees)
{
public class EmployeeDeptCompare implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getDept().compareTo(o2.getDept());
}
}
public class EmployeeIdCompare implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getId().compareTo(o2.getId());
}
}
Collections.sort(employees, new EmployeeDeptCompare());
Collections.sort(employees, new EmployeeIdCompare());
}
------------------
(2).
static void sortByDeptId2(ArrayList employees)
{
public class EmployeeComparator implements Comparator{
public int compare(Employee obj1, Employee obj2) {
Employee myObj1 = (Employee)obj1;
Employee myObj2 = (Employee)obj2;
deptRes = myObj1.getDept().compareTo(myObj2.getDept());
if (deptRes == 0) {
// Departments are equal, sort by ID
return myObj1.getId().compareTo(myObj2.getId());
}
else {
return deptRes;
}
}
}
Collections.sort(employees, new EmployeeComparator());
}
------------------------
(3).
private static int deptToIndex(String dept) {
switch (dept) {
case "ADMIN":
return 0;
case "ENG":
return 1;
case "HR":
return 2;
case "MFG":
return 3;
case "MKTNG":
return 4;
case "PUB":
return 5;
case "SALES":
return 6;
default:
System.err.println("Unknown dept " + dept);
return -1;
}
}
static void sortByDeptId3(ArrayList employees)
{
public class EmployeeDeptCompare implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getDept().compareTo(o2.getDept());
}
}
final int NUM_DEPTS = 7;
ArrayList buckets[] = new ArrayList[NUM_DEPTS];
int i = 0;
for (i=0; i<NUM_DEPTS; i++)
{
buckets[i] = new ArrayList();
}
for (i=0; i<employees.size(); i++)
{
buckets[deptToIndex(employees[i].getDept())].add[employees[i]];
}
int pointer = 0;
for (int i = 0; i < buckets.length; i++) {
Collections.sort(buckets[i], EmployeeDeptCompare);
for (int j = 0; j < buckets[i].size(); j++) { //merge the buckets
employees[pointer] = buckets[i].get(j);
pointer++;
}
}
return employees;
}