Name Hours per day
John 5 6 4 7 8
Jack 7 3 5 7 4
Jill 2 9 4 3 5
James 6 6 2 4 5
Jacob 5 6 6 3 3
Jeremy 5 5 5 8 8
Jim 8 8 4 7 4
Jerry 6 4 5 6 7
Jamie 3 2 6 7 4
If worker payment is $6.50 per hour, write methods to calculate:
Average Working hours for every Worker -> Return array
Average Payment for every worker -> Return array
Total Working hours for every worker -> Return array
Total payment for every worker -> Return array
Sort according to:
Average Pay
Average Working hours
Total Pay
Total Working hours
Write a test program that tests all the methods according to the table above
Sure, I can help you with that. Here's the code to calculate the average working hours for every worker:
```java
import java.util.Arrays;
public class WorkerCalculations {
private static final int PAY_RATE = 6.50;
public static int[] calculateAverageWorkingHours(int[][] hours) {
int[] averageWorkingHours = new int[hours.length];
for (int i = 0; i < hours.length; i++) {
int total = 0;
for (int j = 0; j < hours[i].length; j++) {
total += hours[i][j];
}
averageWorkingHours[i] = total / hours[i].length;
}
return averageWorkingHours;
}
// ... other methods for calculations
public static void main(String[] args) {
int[][] hours = {
{5, 6, 4, 7, 8},
{7, 3, 5, 7, 4},
{2, 9, 4, 3, 5},
{6, 6, 2, 4, 5},
{5, 6, 6, 3, 3},
{5, 5, 5, 8, 8},
{8, 8, 4, 7, 4},
{6, 4, 5, 6, 7},
{3, 2, 6, 7, 4}
};
int[] averageWorkingHours = calculateAverageWorkingHours(hours);
System.out.println("Average working hours for every worker: " + Arrays.toString(averageWorkingHours));
}
}
```
To calculate the average payment for every worker, you can use a similar approach:
```java
public static double[] calculateAveragePayment(int[][] hours) {
double[] averagePayment = new double[hours.length];
for (int i = 0; i < hours.length; i++) {
int total = 0;
for (int j = 0; j < hours[i].length; j++) {
total += hours[i][j];
}
averagePayment[i] = total * PAY_RATE;
}
return averagePayment;
}
```
To calculate the total working hours for every worker:
```java
public static int[] calculateTotalWorkingHours(int[][] hours) {
int[] totalWorkingHours = new int[hours.length];
for (int i = 0; i < hours.length; i++) {
int total = 0;
for (int j = 0; j < hours[i].length; j++) {
total += hours[i][j];
}
totalWorkingHours[i] = total;
}
return totalWorkingHours;
}
```
To calculate the total payment for every worker:
```java
public static double[] calculateTotalPayment(int[][] hours) {
double[] totalPayment = new double[hours.length];
for (int i = 0; i < hours.length; i++) {
int total = 0;
for (int j = 0; j < hours[i].length; j++) {
total += hours[i][j];
}
totalPayment[i] = total * PAY_RATE;
}
return totalPayment;
}
```
To sort the results, you can use the `Arrays.sort()` method along with a custom Comparator. First, let's create a class `Worker` to hold the worker name, average pay, average working hours, total pay, and total working hours:
```java
import java.util.Comparator;
public class Worker {
private String name;
private double averagePay;
private int averageWorkingHours;
private double totalPay;
private int totalWorkingHours;
// constructor, getters, setters
public static class AveragePayComparator implements Comparator<Worker> {
@Override
public int compare(Worker w1, Worker w2) {
return Double.compare(w1.getAveragePay(), w2.getAveragePay());
}
}
public static class AverageHoursComparator implements Comparator<Worker> {
@Override
public int compare(Worker w1, Worker w2) {
return Integer.compare(w1.getAverageWorkingHours(), w2.getAverageWorkingHours());
}
}
public static class TotalPayComparator implements Comparator<Worker> {
@Override
public int compare(Worker w1, Worker w2) {
return Double.compare(w1.getTotalPay(), w2.getTotalPay());
}
}
public static class TotalHoursComparator implements Comparator<Worker> {
@Override
public int compare(Worker w1, Worker w2) {
return Integer.compare(w1.getTotalWorkingHours(), w2.getTotalWorkingHours());
}
}
}
```
Now you can sort the `Worker` objects according to your requirements. For example, to sort by average pay:
```java
Worker[] workers = new Worker[hours.length];
// initialize workers array with name, average pay, average working hours, total pay, and total working hours
Arrays.sort(workers, new Worker.AveragePayComparator());
```
You can do the same for sorting by average working hours, total pay, and total working hours using the corresponding comparators.
I have provided the code for the average working hours calculation and the necessary structures. You can expand on it to complete the other methods, run the test program, and use the different comparators to sort the workers as needed.