Question

This is the third time I'm posting this request, its a very confusing lab. Please help

My class has lab this week following these guidelines. If anyone could construct a code in JAVA with helpful comments, I would greatly appreciate it! :)

1. Create a class level method that takes an ArrayList of doubles and returns the average value using a wrapper class correspondent to double?

2. Create a class level method that takes an ArrayList of integers, store its reverse in new ArrayList and return the answer.

3. Create a class level method that takes an ArrayList of characters and swaps the first element for last element. (No need to return the ArrayList, why?)

4. Create a class level method that takes an ArrayList of bytes and returns the max value, returns the maximum value using wrapper classes correspondence for bytes?

5. Create a class level method takes an Arraylist of doubles and an ArrayList of integers and return an ArrayList that includes all the double and integers values inserted into it alternatively. 6. Create class level method that takes ArrayList and prints its elements with a tap between them?

Answer 1

import java.util.ArrayList;
import java.util.Arrays;

class AL{
    //Method to find average of the ArrayList
    public double getAvg(ArrayList<Double> list){
        double ans = 0;
        //Find sum of all elements in the list
        for(double x : list){
            ans += x;
        }
        //Return average
        return ans/list.size();
    }

    //Method to return the reverse ArrayList
    public ArrayList<Integer> getReverse(ArrayList<Integer> list){
        //Initialize ans
        ArrayList<Integer> ans = new ArrayList<>();
        //Iterate in reverse direction and add to ans
        for(int i=list.size()-1;i>=0;i--){
            ans.add(list.get(i));
        }
        return ans;
    }

    //Method to swap first and last char of the ArrayList
    public void swap(ArrayList<Character> list){
        Character t = list.get(0);
        list.set(0, list.get(list.size()-1));
        list.set(list.size()-1,t);
    }

    //Method to return the maximum byte in the arraylist
    public byte getMax(ArrayList<Byte> bytes){
        //Initialize ans
        Byte ans = bytes.get(0);
        //Iterate through al elements and update the answer
        for(Byte x : bytes){
            if(x>ans){
                ans = x;
            }
        }
        return ans;
    }

    //Method to alternatively add elements from 2 lists into a single list
    public ArrayList alternate(ArrayList<Double> doubles, ArrayList<Integer> ints){
        ArrayList ans = new ArrayList();
        int i=0,j=0;
        //Add double and int arrays to ans
        for(;i<doubles.size()&&j<doubles.size();j++,i++){
            ans.add(doubles.get(i));
            ans.add(ints.get(j));
        }
        //Add remaining elements 
        for(;i<doubles.size();i++){
            ans.add(doubles.get(i));
        }
        for(;j<ints.size();j++){
            ans.add(ints.get(j));
        }
        return ans;
    }

    //Method to print arraylist elements
    public void print(ArrayList list){
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i));
            if(i!=list.size()-1){
                System.out.print(" | ");
            }
        }
        System.out.println();
    }
}

class Main{
    public static void main(String[] args) {
        AL al = new AL();
        ArrayList<Double> dl= new ArrayList<Double>(Arrays.asList(1.38, 2.56, 4.3));
        System.out.println("Average of "+dl+" is "+al.getAvg(dl));
        ArrayList<Integer> il= new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));
        System.out.println("Reverse of "+il+" is "+al.getReverse(il));
        ArrayList<Character> cl= new ArrayList<Character>(Arrays.asList('a','b','c','d'));
        al.swap(cl);
        System.out.println("Swapping first and last of "+cl+" is "+cl);
        ArrayList<Byte> bl= new ArrayList<Byte>(Arrays.asList(new Byte((byte)2),new Byte((byte)6),new Byte((byte)3),new Byte((byte)9),new Byte((byte)5)));
        System.out.println("Maximum value of "+bl+" is "+al.getMax(bl));
        System.out.println("Alternating "+dl+" "+il+" is "+al.alternate(dl,il));
        System.out.println("Integer list is ");
        al.print(il);
    }
}

OUTPUT :

Run: → Main x Maximum value of [2, 6, 3, 9, 5] is 9 Alternating (1.38, 2.56, 4.3] [1, 2, 3, 4, 5] is [1.38, 1, 2.56, 2, 4.3, 3, 4, 5] Integer list is 1 | 2 | 3 | 4 | 5 ul { Process finished with exit code o