Question

Objectives:

Sort data objects

Compare the CPU efficiency between the object array and ArrayList used in the sorting operation.

Input file: Data.csv (file is to big;I cannot update, you can use any data file)

there are less than 20,000 records in Data.csv Your program will skip/reject dirty data lines. For example, if a line contains 2 fields, it is considered as a dirty data line and will be rejected/skipped by your program.

You are required to develop a Java program to:

1. Read all data records from Data.csv file into 2 data structures:

An object array of MyRecord

java.util.ArrayList

2. Sort records in descending order by Price (largest first) and display the CPU time used for such an operation. Perform these operations against the object array of MyRecord and java.util.ArrayList.

Fields data is:

119736,CLAY COUNTY,792148.9

448094,CLAY COUNTY,1438163.57

206893,CLAY COUNTY,192476.78

333743,CLAY COUNTY,86854.48

172534,CLAY COUNTY,246144.49

785275,CLAY COUNTY,884419.17

995932,CLAY COUNTY,20610000

223488,CLAY COUNTY,348374.25

433512,CLAY COUNTY,265821.57

142071,CLAY COUNTY,1010842.56

253816,CLAY COUNTY,1117791.48

894922,CLAY COUNTY,33952.19

422834,CLAY COUNTY,66755.39

582721,CLAY COUNTY,42826.99

842700,CLAY COUNTY,50656.8

874333,CLAY COUNTY,67905.07

580146,CLAY COUNTY,66938.9

456149,CLAY COUNTY,86421.04

767862,CLAY COUNTY,73798.5

353022,CLAY COUNTY,62467.29

367814,CLAY COUNTY,42727.74

671392,CLAY COUNTY,11700000

772887,CLAY COUNTY,2099127.76

983122,CLAY COUNTY,211372.57

934215,CLAY COUNTY,157171.16

Answer 1

import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

class MyRecord implements Comparable<MyRecord> {
    String name;
    double price;
    long id;
    MyRecord(String name, double price, long id){
        this.name = name;
        this.price = price;
        this.id = id;
    }

    public int compareTo(MyRecord record){  
        if(price == record.price)  
            return 0;  
        else if(price > record.price)  
            return 1;  
        else  
            return -1;  
    }  
    public String toString(){
        return "id: "+ id+" name: "+ name+" price: "+price;
    }
}

public class test {

    static void merge(MyRecord arr[], int l, int m, int r) { 
        int i, j, k; 
        int n1 = m - l + 1; 
        int n2 = r - m; 
    
        
        MyRecord L[] = new MyRecord[n1];
        MyRecord R[] = new MyRecord[n2]; 
    
        /* Copy data to temp arrays L[] and R[] */
        for (i = 0; i < n1; i++) 
            L[i] = arr[l + i]; 
        for (j = 0; j < n2; j++) 
            R[j] = arr[m + 1 + j]; 
    
        /* Merge the temp arrays back into arr[l..r]*/
        i = 0; // Initial index of first subarray 
        j = 0; // Initial index of second subarray 
        k = l; // Initial index of merged subarray 
        while (i < n1 && j < n2) { 
            if (L[i].compareTo(R[j]) >= 0) { 
                arr[k] = L[i]; 
                i++; 
            } 
            else { 
                arr[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
    
        /* Copy the remaining elements of L[], if there 
        are any */
        while (i < n1) { 
            arr[k] = L[i]; 
            i++; 
            k++; 
        } 
    
        /* Copy the remaining elements of R[], if there 
        are any */
        while (j < n2) { 
            arr[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
    
    /* l is for left index and r is right index of the 
    sub-array of arr to be sorted */
    static void mergeSort(MyRecord arr[], int l, int r) 
    { 
        if (l < r) { 
            // Same as (l+r)/2, but avoids overflow for 
            // large l and h 
            int m = l + (r - l) / 2; 
    
            // Sort first and second halves 
            mergeSort(arr, l, m); 
            mergeSort(arr, m + 1, r); 
    
            merge(arr, l, m, r); 
        } 
    } 
    public static void main(String[] args) throws FileNotFoundException {
        Scanner fin = new Scanner(new File("data.csv")); //reading the data from the data.csv file
        ArrayList<MyRecord> myRecordList = new ArrayList<>(); // creating the list to store the data.

        while (fin.hasNext()) {
            String str[] = fin.nextLine().split(",");
            
            if (str.length != 3){ //checking whether the number of items is exactly 3 otherwise rejecting.
                continue;
            }
            // as no inforamaition is provided for the meaning of the each column considering the first value as the id, second value as the name, third value as the price
            MyRecord record = new MyRecord(str[1], Double.parseDouble(str[2]), Long.parseLong(str[0]) ); //creating the object of class MyRecord
            myRecordList.add(record); //adding to the list
            
        }

        fin.close();
        MyRecord[] myRecordArray = new MyRecord[myRecordList.size()]; //  declaring the array

        myRecordArray   = myRecordList.toArray(myRecordArray);       // creating the copy of the list to array

        long startTime = System.nanoTime(); // measuring the time for array sorting

        mergeSort(myRecordArray,0, myRecordArray.length -1); // using the merge sort to sort the array;
        
        long endTime = System.nanoTime();

        long timeForArraySorting = endTime -startTime; // calculating the time for array sorting

        startTime = System.nanoTime();

        Collections.sort(myRecordList, Collections.reverseOrder()); // sorting in the reverse order 

        endTime = System.nanoTime();

        long timeForListSorting = endTime - startTime;

        //priting the array of myrecord in descending order.
        for( MyRecord record: myRecordArray){
            System.out.println(record);
        }
        // time taken comparison
        System.out.println("Time taken for array sorting: "+timeForArraySorting);
        System.out.println("Time taken for list sorting: "+timeForListSorting);
        
        
    }

}