具有不同长度乘法的Java数组

Question

Hello I am working on a project and have come up against an issue I just can't figure out.

I have 3 arrays all double... hours[], rate[], prevHrs[]. i copied the hours and prevhrs to a new array called monthhours[], now I need to rearrange it so that the elements in the hours array are each separately put into the proper place. I need the first 3 elements of prevhrs then the first element from hours, then the 4,5,6 element of prevhrs and the 2nd element of hours and so on. Then after all that is done I need to take each element from this new monthHours array and multiply it by the elements in the rate array. basically rate[0] would multiply by mountHours[0][1][2][3] then rate[1] multiply by monthHours[4][5][6][7]

if anyone can help it would be much appreciated. This is what I have so far, and I have asked almighty google but haven't been able to find what im looking for.

String [] names = {"Barry", "Lindsey", "Arron", "Brent"};
    double [] hours = {40.0, 37.5, 39.5, 18.5};
    double [] rate = {15.67, 8.90, 8.90, 12.33};
    double [] prevHrs = {32.0, 40.0, 39.0, 28.5, 31.5, 38.0, 40.0, 24.0, 36.0, 40.0, 40.0, 22.5};
    double [] monthHours = new double[16];
    double mostHours;
    mostHours =FinalMethods.getHighest(hours);
    double pay[] = FinalMethods.calculatePay(hours, rate);
    double totalPay[] = FinalMethods.calculateMonthpay(monthHours, rate);

    System.out.printf("The employee who Worked the most hours is %s" + " With %.2f" + "hours\n",names[0], mostHours);
    System.out.println(" ");
    System.out.println("Name \tHours \tRate \tTotal");
    for(int i=0;i<names.length;i++)
        System.out.printf(names[i] +"\t"+ hours[i] +"\t"+ rate[i] +"\t"+ pay[i]+"\n" );


    System.arraycopy(hours, 0, monthHours, 0, hours.length);
System.arraycopy(prevHrs, 0, monthHours, hours.length, prevHrs.length);

    System.out.println(" ");
    System.out.println("Employee Monthly Pay");
    System.out.println(" ");
    System.out.println("Name \tTotal");
    for(int i=0;i<names.length;i++)
        System.out.printf(names[i] +"\t"+ totalPay[i]+"\n" );


} 

    // Calculate Pay
            public  static double[] calculatePay(double[] hours, double[] rate){

                double[] pay = new double[hours.length];
                for (int i = 0; i < hours.length; i++) {
                        pay[i] = hours[i] * rate[i];
                }
                return pay;
            }
// Calculate Monthly Pay 
    public static double[] calculateMonthpay(double[] monthHours, double[] rate){

        double[] totalPay = new double[monthHours.length];
        for(int i = 0; i < monthHours.length; i++){
            totalPay[i] = monthHours[i] * rate[i] % rate[rate.length];
        }
            return totalPay;

}    

Answer 1

If you step away from the seemingly safe ground of arrays and plunge into the scary abyss of Object Oriented Programming you can make your life much easier.

Here I hold an array of Employees and make them calculate their own pay.

class Employee {

    final String name;
    final double hours;
    final double rate;
    final double[] prevHours;

    public Employee(String name, double hours, double rate, double[] prevHours) {
        this.name = name;
        this.hours = hours;
        this.rate = rate;
        this.prevHours = prevHours;
    }

    public String getName() {
        return name;
    }

    public double getHours() {
        return hours;
    }

    public double getRate() {
        return rate;
    }

    public double[] getPrevHours() {
        return prevHours;
    }

    public double getPay() {
        return rate * hours;
    }

    public double getMonthsPay() {
        double monthsPay = getPay();
        for (double h : prevHours) {
            monthsPay += rate * h;
        }
        return monthsPay;
    }

}

private Employee getMostHours(Employee[] employees) {
    Employee most = null;
    for (Employee employee : employees) {
        if (most == null || employee.getHours() > most.getHours()) {
            most = employee;
        }
    }
    return most;
}

public void test() {
    System.out.println("Hello");
    Employee[] employees = {
        new Employee("Barry", 40.0, 15.67, new double[]{32.0, 40.0, 39.0}),
        new Employee("Lindsey", 37.5, 8.90, new double[]{28.5, 31.5, 38.0}),
        new Employee("Arron", 39.5, 8.90, new double[]{28.5, 31.5, 38.0}),
        new Employee("Brent", 18.5, 12.33, new double[]{28.5, 31.5, 38.0})};
    Employee mostHours = getMostHours(employees);
    System.out.printf("The employee who Worked the most hours is %s" + " With %.2f" + "hours\n", mostHours.getName(), mostHours.getHours());
    System.out.println();
    System.out.println("Name \tHours \tRate \tTotal \tMonth");
    for (Employee employee : employees) {
        System.out.println(employee.getName()
                + "\t" + employee.getHours()
                + "\t" + employee.getRate()
                + "\t" + employee.getPay()
                + "\t" + employee.getMonthsPay());
    }
}

Answer 2

I agree that object oriented programming approach is better, however since it was asked on one might do this manually, I wrote up a little example for your first usecase.

So this is combining the arrays by adding 3 elements, then 1 other element. It is not pretty, but should hopefully illustrate the idea:

public static void main(String[] args) {
        double [] hours = {40.0, 37.5, 39.5, 18.5};
        double [] prevHrs = {32.0, 40.0, 39.0, 28.5, 31.5, 38.0, 40.0, 24.0, 36.0, 40.0, 40.0, 22.5};

        // 3 elements of prevHrs, 1 element of hours
        int newSize = hours.length + prevHrs.length;
        double[] combinedArray = new double[newSize];

        int prevHrsOffset = 0;

        for(int i= 0; i < hours.length; i++) {

            for( int j=0; j<3; j++) { // 3 elements
                combinedArray[i+prevHrsOffset] = prevHrs[prevHrsOffset];
                prevHrsOffset ++;

                // TODO insert safety check for arrayoutofbounds
            }

            combinedArray[i+prevHrsOffset] = hours[i];
        }


        for(int i=0; i < combinedArray.length; i++) {
            System.out.println(combinedArray[i]);
        }

    }

The output is:

32.0, 40.0, 39.0, 40.0, 28.5, 31.5, 38.0, 37.5, 40.0, 24.0, 36.0, 39.5, 40.0, 40.0, 22.5, 18.5

Note, this is not a very safe approach, you would have to guard against index violations etc.

You could use a list to add to (at least that way the index is not a problem).

Also, the length of hours and prevHrs might differ and then the combination won't work anymore.

Hope that answers your question and gives you an idea on how to do that.

Calculating the total pay in a similar manner:

double [] rate = {15.67, 8.90, 8.90, 12.33};
        double[] totalPay = new double[newSize]; // the total pay based on that other array
        int combinedArrayOffset = 0;
        for (int i = 0; i < rate.length; i++) {

            for (int j = 0; j < 4; j++) { // 4 elements
                totalPay[combinedArrayOffset] = rate[i] * combinedArray[combinedArrayOffset];
                combinedArrayOffset++;
                // TODO insert safety check for arrayoutofbounds
            }
        }

        System.out.println("total pay:");

        for(int i=0; i < totalPay.length; i++) {
            System.out.print(totalPay[i] + ", ");
        }

Answer 3

I highly recommend getting used to object oriented programming, as already suggested, but since you asked for help with your current code, here is my solution - written in "the seemingly safe ground of arrays":

Code:

public class FinalMethods {
    public static void main(String[] args) {
        String[] names = {"Barry", "Lindsey", "Arron", "Brent"};
        double[] hours = {40.0, 37.5, 39.5, 18.5};
        double[] rate = {15.67, 8.90, 8.90, 12.33};
        double[] prevHrs = {
                32.0, 40.0, 39.0,
                28.5, 31.5, 38.0,
                40.0, 24.0, 36.0,
                40.0, 40.0, 22.5
        };
        double[] monthHours;
        {
            // we have name.length employees, and for each 3 prevHrs entries and 1 hours entry
            monthHours = new double[names.length * 4];
            for (int i = 0; i < names.length; i++) {
                // append/copy range of 3 prevHrs entries to monthHours
                System.arraycopy(prevHrs, i * 3, monthHours, i * 4, 3);
                // append/copy range of 1 hours entries to monthHours
                System.arraycopy(hours, i, monthHours, i * 4 + 3, 1);

                // equivalent to:
                /*
                    monthHours[i * 4] = prevHrs[i * 3];
                    monthHours[i * 4 + 1] = prevHrs[i * 3 + 1];
                    monthHours[i * 4 + 2] = prevHrs[i * 3 + 2];
                    monthHours[i * 4 + 3] = hours[i];
                */
            }
        }
        int mostHoursIndex = FinalMethods.getHighest(hours);
        double pay[] = FinalMethods.calculatePay(hours, rate);
        double totalPay[] = FinalMethods.calculateMonthPay(monthHours, rate);

        // most worked
        System.out.printf("The employee who worked most hours is %s with %.2f hours\n", names[mostHoursIndex], hours[mostHoursIndex]);

        System.out.println();

        // print pay table
        System.out.println("\n-- Employee Pay --\n");
        System.out.printf("%-10s %-10s %-10s %-10s\n", "Name", "Hours", "Rate", "Total");
        System.out.println();
        for (int i = 0; i < names.length; i++) {
            System.out.printf("%-10s %-10.2f %-10.2f %-10.2f\n", names[i], hours[i], rate[i], pay[i]);
        }

        System.out.println();

        // print monthly pay table
        System.out.println("\n-- Employee Monthly Pay --\n");
        System.out.printf("%-10s %-10s\n", "Name", "Total");
        System.out.println();
        for (int i = 0; i < names.length; i++) {
            System.out.printf("%-10s %-10.2f\n", names[i], totalPay[i]);
        }
    }

    public static int getHighest(double... values) {
        // result will be -1 for empty arrays
        int result = -1;
        // EVERY value should be > max when starting, thus:
        double max = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < values.length; i++) {
            double value = values[i];
            if (value > max) {
                // found a higher entry, mark index and update max
                max = value;
                result = i;
            }
        }
        // return index of highest entry
        return result;
    }

    public static double[] calculatePay(double[] hours, double[] rate) {
        double[] result = new double[rate.length];
        // for each employee
        for (int i = 0; i < result.length; i++) {
            // sum his hours (1 entry) * his rate
            result[i] = hours[i] * rate[i];
        }
        return result;
    }

    public static double[] calculateMonthPay(double[] monthHours, double[] rate) {
        double[] result = new double[rate.length];
        // for each employee
        for (int i = 0; i < result.length; i++) {
            // sum his monthHours (4 entries) * his rate
            double monthPay = 0;
            for (int j = 0; j < 4; j++) {
                monthPay += monthHours[i * 4 + j] * rate[i];
            }

            result[i] = monthPay;
        }
        return result;
    }
}

Output:

The employee who worked most hours is Barry with 40,00 hours


-- Employee Pay --

Name       Hours      Rate       Total     

Barry      40,00      15,67      626,80    
Lindsey    37,50      8,90       333,75    
Arron      39,50      8,90       351,55    
Brent      18,50      12,33      228,11    


-- Employee Monthly Pay --

Name       Total     

Barry      2366,17   
Lindsey    1205,95   
Arron      1241,55   
Brent      1491,93