Task - Collections - Sorting Collections and Loose Coupling #50

akash-coded · 2022-03-07T05:41:57Z

akash-coded
Mar 7, 2022
Maintainer

Create an interface called Client which will have:

double getCharges()
double calculatePayment(invoiceDate): calculates the receivable amount by multiplying charges with no. of serviceable days
void sendEmail(double payment): sends an email to the client with the pending amount

Create a class Customer which implements the interface Client and declares the following:

id
name
email
charges
dateOfAgreement
parameterized constructor
override toString()

Create a class Business which implements the interface Client and declares the following:

id
name
email
charges
gstRate
dateOfAgreement
parameterized constructor
override toString()
double getGST()

In the driver class MyCompany :

Create two objects of Customer using polymorphic references.
Create two objects of business and using polymorphic references.
Create an ArrayList of Client objects
Call calculatePayment(31st March) on all the objects in the collection, and store the returned values in a double array pendingPayments. Display the array.
Use the values from pendingPayments array to send emails to all the clients
Sort the ArrayList according to id (natural order) in ascending order and print it.
Sort the ArrayList according to charges in descending order and print it
Sort the ArrayList according to dateOfAgreement in ascending order and print it

Sarfinaa · 2022-03-07T07:01:57Z

Sarfinaa
Mar 7, 2022

package week_5;

import java.util.*;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

abstract class ServiceClient implements Client, Comparable<ServiceClient> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public int compareTo(ServiceClient other) {
        return this.id - other.id;
    }

    public double getCharges() {
        return charges;
    }

    public double calculate(GregorianCalendar invoiceDate) {
        int date = invoiceDate.get(Calendar.DATE);
        int agreementDate = dateOfAgreement.get(Calendar.DATE);
        return (date - agreementDate) * getCharges();
    }

    public void sendEmail(double payment) {
        System.out.println("Pending Payment: " + payment);
    }

}

class Customer extends ServiceClient {

    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email + ", id="
                + id + ", name=" + name + "]";
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return calculate(invoiceDate);
    }

}

class Business extends ServiceClient {

    double gstRate = 12;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return calculate(invoiceDate) * getGST();
    }

    double getGST() {
        return gstRate * calculate(new GregorianCalendar(2022, 2, 31));
    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email
                + ", gstRate=" + gstRate + ", id=" + id + ", name=" + name + "]";
    }

}

public class abc {
    public static void main(String[] args) {
        ServiceClient c1 = new Customer(12, "Karan", "k@gmail.com", 1000, new GregorianCalendar(2022, 2, 7));
        ServiceClient c2 = new Customer(2, "Shivam", "s@gmail.com", 1000, new GregorianCalendar(2022, 2, 8));
        ServiceClient c3 = new Business(1, "Roger", "r@gmail.com", 2000, new GregorianCalendar(2022, 2, 9));
        ServiceClient c4 = new Business(5, "Sagar", "sc@gmail.com", 2000, new GregorianCalendar(2022, 2, 10));
        List<ServiceClient> clients = new ArrayList<>(Arrays.asList(c1, c2, c3, c4));
        double[] pendingPayments = new double[4];
        for (int i = 0; i < 4; i++) {
            pendingPayments[i] = clients.get(i).calculatePayment(new GregorianCalendar(2022, 2, 30));
        }
        System.out.println(Arrays.toString(pendingPayments));
        for (int i = 0; i < 4; i++) {
            clients.get(i).sendEmail(pendingPayments[i]);
        }
        System.out.println("Sort According to Id");
        Collections.sort(clients);
        clients.forEach(System.out::println);
        System.out.println("Sort According to charges");
        clients.sort((ServiceClient o1, ServiceClient o2) -> (int) (o2.getCharges() - o1.getCharges()));
        // Collections.sort(clients, new Comparator<Clients>() {
        // @Override
        // public int compare(Clients o1, Clients o2) {
        // return (int) (o2.getCharges() - o1.getCharges());
        // }
        // });
        clients.forEach(System.out::println);

        System.out.println("Sort According to date of Agreement");
        clients.sort((ServiceClient o1,
                ServiceClient o2) -> (o1.dateOfAgreement.get(Calendar.DATE) - o2.dateOfAgreement.get(Calendar.DATE)));
        clients.forEach(System.out::println);

    }

}

0 replies

Gaurav-Joshi-31 · 2022-03-07T07:15:52Z

Gaurav-Joshi-31
Mar 7, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class Clients implements Client, Comparable<Clients> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Clients c2 = new Customer(103, "Rohit", "xyz@email.com", 300);

        Clients b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Clients b2 = new Business(104, "Amazon", "xyz@email.com", 3000);

        List<Clients> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(c1);
        list.add(c2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

abhiraj2k · 2022-03-07T07:28:43Z

abhiraj2k
Mar 7, 2022

package collections;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(Date invoiceDate);

    void sendEmail(double payment);
}

abstract class Service implements Client, Comparable<Service> {

    int id;
    double charges;
    Date dateOfAgreement;

    public Service(int id, double charges, Date dateOfAgreement) {
        this.id = id;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Your Pending amount is: " + payment);
    }

    @Override
    public double calculatePayment(Date invoiceDate) {
        long diff = invoiceDate.getTime() - this.dateOfAgreement.getTime();
        diff = diff / (1000 * 60 * 60 * 24) % 365;
        return diff * this.getCharges();
    }

    @Override
    public int compareTo(Service o) {
        if (this.id == o.id)
            return 0;
        if (this.id > o.id)
            return 1;
        return -1;
    }
}

class Customer extends Service {
    String name;
    String email;

    public Customer(int id, String name, String email, double charges, Date dateOfAgreement) {
        super(id, charges, dateOfAgreement);
        this.name = name;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" +
                dateOfAgreement + ", email=" + email + ", id="
                + id + ", name=" + name + "]";
    }

}

class Business extends Service {
    String name;
    String email;
    double gsRate;

    public Business(int id, String name, String email, double charges, double gsRate, Date dateOfAgreement) {
        super(id, charges, dateOfAgreement);
        this.name = name;
        this.email = email;
        this.gsRate = gsRate;
    }

    double getGST() {
        return 0;
    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" +
                dateOfAgreement + ", email=" + email
                + ", gsRate=" + gsRate + ", id=" + id + ", name=" + name + "]";
    }

}

public class SortingChallenge {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("dd-mm-yyyy");
        Service cust2 = new Customer(1, "John", "john@xyz.com", 200, sdf.parse("20-02-2022"));
        Service cust1 = new Customer(2, "Jack", "jack@abc.com", 100, sdf.parse("01-02-2022"));

        Service bus2 = new Business(11, "X Corp", "xcorp@xc.com", 15000, 10.5, sdf.parse("01-01-2020"));

        Service bus1 = new Business(12, "E Corp", "ecorp@ec.com", 20000, 9.5, sdf.parse("01-04-2021"));

        List<Service> clientArr = new ArrayList<>();

        clientArr.add(cust1);
        clientArr.add(cust2);
        clientArr.add(bus1);
        clientArr.add(bus2);

        double[] pendingArr = new double[4];
        for (int i = 0; i < pendingArr.length; i++) {
            pendingArr[i] = clientArr.get(i).calculatePayment(sdf.parse("31-03-2022"));
            clientArr.get(i).sendEmail(pendingArr[i]);
        }

        Collections.sort(clientArr);

        clientArr.forEach(System.out::println);

        clientArr.sort((Service c1, Service c2) -> (int) (c2.getCharges() - c1.getCharges()));
        clientArr.forEach(System.out::println);

        clientArr.sort((Service c1, Service c2) -> (int) (c1.dateOfAgreement.getTime() - c2.dateOfAgreement.getTime()));
        clientArr.forEach(System.out::println);

    }
}

0 replies

KaminiJha · 2022-03-07T07:56:09Z

KaminiJha
Mar 7, 2022

package Collections;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

abstract class Service implements Client, Comparable<Service> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public Service(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public double getCharges() {
        return this.charges;
    }

    public void sendEmail(double pendingPayment) {
        System.out.println("Your payment of Rs." + pendingPayment + " is pending");
    }

    @Override
    public int compareTo(Service other) {
        if (this.id == other.id)
            return 0;
        if (this.id > other.id)
            return 1;
        return -1;
    }

}

class Customer extends Service {

    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {
        return (double) (getCharges() * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]\n";
    }

}

class Business extends Service {
    double gstRate;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement,
            double gstRate) {
        super(id, name, email, charges, dateOfAgreement);
        this.gstRate = gstRate;
    }

    public double getGST() {
        return this.gstRate;
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {
        return (double) (getCharges()*this.gstRate * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
    }

    // override toString()
    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", gstRate=" + gstRate + ", id=" + id + ", name=" + name + "]\n";
    }

}

public class SortingAndCouplingTask {
    public static void main(String[] args) {
        Service cus1 = new Customer(19, "kamini", "kamini12@gmail.com", 123.0, new GregorianCalendar(2022, 2, 6));
        Service cus2 = new Customer(20, "Ansh", "ansh@gmail.com", 321.0, new GregorianCalendar(2022, 2, 7));

        Service bus1 = new Business(13, "Abc", "abc@gmail.com", 100.0, new GregorianCalendar(2022, 2, 8),
                2.3);
        Service bus2 = new Business(44, "Def", "def@gmail.com", 200.0, new GregorianCalendar(2022, 2, 9),
                1.7);

        List<Service> list = new ArrayList<>();
        list.add(cus1);
        list.add(cus2);
        list.add(bus1);
        list.add(bus2);
        double[] pendingPayment = new double[4];
        for (int i = 0; i < list.size(); i++) {
            pendingPayment[i] = list.get(i).calculatePayment(new GregorianCalendar(2022, 2, 31));
            list.get(i).sendEmail(pendingPayment[i]);
        }
        // sort accoring to id
        Collections.sort(list);
        System.out.println("Accoring to id \n" + list);
        // sort accoring to charges
        list.sort((ob1, ob2) -> (int) (ob1.getCharges() - ob2.getCharges()));
        System.out.println("Accoring to charges \n" + list);
        // sort accoring to date
        list.sort((ob1, ob2) -> (int) (ob1.dateOfAgreement.get(Calendar.DATE)
                - ob2.dateOfAgreement.get(Calendar.DATE)));
        System.out.println("Accoring to date \n" + list);
    }
}

0 replies

Ashwesh09 · 2022-03-07T09:28:12Z

Ashwesh09
Mar 7, 2022

import java.util.*;
import java.text.DecimalFormat;
interface Client{
    double getCharges();

    double calculatePayments(GregorianCalendar d);
 
    void sendEmail(double payement);
}
abstract class ServiceClient implements Client, Comparable<ServiceClient> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public int compareTo(ServiceClient other) {
        return this.id - other.id;
    }

    public double getCharges() {
        return charges;
    }
    @Override
    public void sendEmail(double payement) {
        String dateOfRegistraion = dateOfAgreement.get(Calendar.DATE) + "/" + (dateOfAgreement.get(Calendar.MONTH) + 1)
                + "/"
                + dateOfAgreement.get(Calendar.YEAR);
        DecimalFormat df = new DecimalFormat("#0.00");
        System.out.println("You payment of " + df.format(payement) + " is plending from " + dateOfRegistraion);
    }
    @Override
    public String toString() {
        String dateOfRegistraion = dateOfAgreement.get(Calendar.DATE) + "/" + (dateOfAgreement.get(Calendar.MONTH) + 1)
                + "/"
                + dateOfAgreement.get(Calendar.YEAR);
        return this.getClass().getSimpleName() +"\nID:\t\t" + id + "\nName :\t" + name + "\nEmail :\t" + email+"\nDate of Aggrement :\t"+ dateOfRegistraion ;
    }
}
class Customer extends ServiceClient {

    public Customer(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = 2.36;
        this.dateOfAgreement = new GregorianCalendar(2022,3-1,(int)(Math.random() * ((15 - 1) + 1)));
    }
    private static int getNoOfDays(GregorianCalendar present, GregorianCalendar future) {
        if (future.get(Calendar.DATE) > present.get(Calendar.DATE)) {
            return future.get(Calendar.DATE) - present.get(Calendar.DATE);
        }
        return 0;
    }
    @Override
    public
    double calculatePayments(GregorianCalendar d) {
        int noOfDays = getNoOfDays(dateOfAgreement, d);
        return noOfDays * getCharges();
    }
}

class Business extends ServiceClient {
    double gstRate;
    public Business(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = 3.36;
        this.dateOfAgreement = new GregorianCalendar(2022,3-1,(int)(Math.random() * ((15 - 1) + 1)));
        this.gstRate = 20; // in precentage
    }
    
    public double getGstRate() {
        return gstRate;
    }
    private static int getNoOfDays(GregorianCalendar present, GregorianCalendar future) {
        if (future.get(Calendar.DATE) > present.get(Calendar.DATE)) {
            return future.get(Calendar.DATE) - present.get(Calendar.DATE);
        }
        return 0;
    }
    @Override
    public
    double calculatePayments(GregorianCalendar d) {
        int noOfDays = getNoOfDays(dateOfAgreement, d);
        double res = noOfDays * getCharges();
        return res + (getGstRate()/100) * res;
    }
}
public class SortingCollections {
    public static void main(String[] args) {
        ServiceClient customer1 = new Customer(123, "ABC", "abc@yahoo.com");
        ServiceClient customer2 = new Customer(124, "DEF", "def@rediffmail.com");
        ServiceClient business1 = new Business(456, "UVW", "uvw@gmail.com");
        ServiceClient business2 = new Business(457, "XYZ", "xyz@pqr.com");
        List<ServiceClient> clients = new ArrayList<>();
        List<Double> pendingPayments = new ArrayList<>();
        clients.add(customer1);
        clients.add(customer2);
        clients.add(business1);
        clients.add(business2);
        for (ServiceClient c : clients)
            pendingPayments.add(c.calculatePayments(new GregorianCalendar(2022, 3 - 1, 31)));
        int i = 0;
        for (ServiceClient c : clients) {
            if (pendingPayments.get(i) != 0)
                c.sendEmail(pendingPayments.get(i++));
            else
                i++;
        }
        Collections.sort(clients);
        clients.forEach(System.out::println);
        System.out.println("\n -----  Sorting with Charges in descending order, -----\n");
        Collections.sort(clients, (ServiceClient sc1, ServiceClient sc2) -> (int) (sc1.getCharges() - sc2.getCharges()));
        clients.forEach(System.out::println);

        System.out.println("\n ---- Sort According to date of Agreement ----- \n");
        Collections.sort(clients, (ServiceClient sc1,ServiceClient sc2) -> (sc1.dateOfAgreement.get(Calendar.DATE) - sc2.dateOfAgreement.get(Calendar.DATE)));
        clients.forEach(System.out::println);
    }
}

0 replies

Batchusatyasri · 2022-03-07T11:26:53Z

Batchusatyasri
Mar 7, 2022

import java.util.*;

interface Client {
double getCharges();

double calculatePayment(GregorianCalendar invoiceDate);

void sendemail(double payment);
}

abstract class ServiceCustomer implements Client, Comparable {
int id;
String name;
String email;
double charges;
GregorianCalendar dateOfAgreement;

@OverRide
public int compareTo(ServiceCustomer other) {
return this.id - other.id;
}

public double getCharges() {
return this.charges;
}

public double calculate(GregorianCalendar invoiceDate) {
int date = invoiceDate.get(Calendar.DATE);
int agreementDate = dateOfAgreement.get(Calendar.DATE);
return (date - agreementDate) * getCharges();
}

public void sendemail(double payment) {
System.out.println("Email is sent successfully to " + this.email + "with payment amount " + payment);
}
}

class Customer extends ServiceCustomer {
public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
this.id = id;
this.name = name;
this.email = email;
this.charges = charges;
this.dateOfAgreement = dateOfAgreement;
}

@OverRide
public String toString() {
return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
+ email + ", id="
+ id + ", name=" + name + "]";
}

@OverRide
public double calculatePayment(GregorianCalendar invoiceDate) {
return calculate(invoiceDate);
}
}

class Business extends ServiceCustomer {

double gstRate = 15;

public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
this.id = id;
this.name = name;
this.email = email;
this.charges = charges;
this.dateOfAgreement = dateOfAgreement;
}

@OverRide
public double calculatePayment(GregorianCalendar invoiceDate) {
return calculate(invoiceDate) * getGST();
}

double getGST() {
return gstRate * calculate(new GregorianCalendar(2022, 2, 31));
}

@OverRide
public String toString() {
return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
+ email + ", id="
+ id + ", name=" + name + "]";
}
}

public class MyCompany {
public static void main(String[] args) {
ServiceCustomer obj1 = new Customer(15, "satya", "batchusatyasri@gmail.com", 2000,
new GregorianCalendar(2022, 2, 7));
ServiceCustomer obj2 = new Customer(3, "vani", "vani@gmail.com", 7000, new GregorianCalendar(2022, 2, 6));
ServiceCustomer bo1 = new Business(3, "vani", "vani@gmail.com", 5000, new GregorianCalendar(2022, 2, 5));
ServiceCustomer bo2 = new Business(15, "satya", "satya@gmail.com", 6000, new GregorianCalendar(2022, 2, 9));
List clients = new ArrayList<>(Arrays.asList(obj1, obj2, bo1, bo2));
double[] pending = new double[4];
for (int i = 0; i < 4; i++) {
pending[i] = clients.get(i).calculatePayment(new GregorianCalendar(2022, 3, 30));
}
System.out.println(Arrays.toString(pending));
for (int i = 0; i < 4; i++) {
clients.get(i).sendemail(pending[i]);
}
System.out.println("Sort of Id");
Collections.sort(clients);
clients.forEach(System.out::println);
System.out.println("Sorting of charges");
clients.sort((ServiceCustomer o1, ServiceCustomer o2) -> (int) (o2.getCharges() - o1.getCharges()));
clients.forEach(System.out::println);
System.out.println("Sort of Dates of agreement");
clients.sort((ServiceCustomer o1,
ServiceCustomer o2) -> (o1.dateOfAgreement.get(Calendar.DATE) - o2.dateOfAgreement.get(Calendar.DATE)));
clients.forEach(System.out::println);
}
}

0 replies

ujjwal18bit1167 · 2022-03-07T14:40:55Z

ujjwal18bit1167
Mar 7, 2022

package collections;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.GregorianCalendar;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class ServiceClient implements Client, Comparable<ServiceClient> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public ServiceClient(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public double getCharges() {
        return charges;
    }

    public long calculateDays(GregorianCalendar invoiceDate) {
        Date d1 = invoiceDate.getTime();

        long diff = d1.getTime() - dateOfAgreement.getTime().getTime();
        return diff / (1000 * 60 * 60 * 24);
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {

        return charges * calculateDays(invoiceDate);
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("The pending amount is " + payment);
    }

    // @Override
    // public String toString() {
    // return "ServiceClient [charges=" + charges + ", dateOfAgreement=" +
    // dateOfAgreement + ", email=" + email
    // + ", id=" + id + ", name=" + name + "]";
    // }

    @Override
    public int compareTo(ServiceClient o) {
        if (this.id < o.id)
            return -1;
        else if (this.id > o.id)
            return 1;
        else
            return 0;
    }

}

class Customer extends ServiceClient {

    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }

}

class Business extends ServiceClient {
    double gstRate = 15;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = calculateDays(invoiceDate) * charges;
        return payment + (payment * gstRate) / 100;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + gstRate + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {
        ServiceClient serviceClient1 = new Customer(1, "Ram", "Ram@gmail.com", 1000,
                new GregorianCalendar(2022, 1, 12));
        ServiceClient serviceClient2 = new Customer(2, "Sohan", "Sohan@gmail.com", 2000,
                new GregorianCalendar(2020, 3, 11));
        ServiceClient serviceClient3 = new Business(3, "ujjwal", "ujjwal@gmail.com", 2500,
                new GregorianCalendar(2018, 1, 28));
        ServiceClient serviceClient4 = new Business(4, "Sanyam", "sanyam@gmail.com", 1500,
                new GregorianCalendar(2017, 5, 18));
        ArrayList<ServiceClient> arr = new ArrayList<>();
        arr.add(serviceClient1);
        arr.add(serviceClient2);
        arr.add(serviceClient3);
        arr.add(serviceClient4);

        ArrayList<Double> pendingPayments = new ArrayList<>();
        for (ServiceClient client : arr) {
            pendingPayments.add(client.calculatePayment(new GregorianCalendar(2022, 3,
                    31)));
        }
        int count = 1;
        for (Double payment : pendingPayments) {
            System.out.println("Pending Payment for client" + count + " is " + payment);
            count++;
        }

        System.out.println("Sending emails.......");
        for (int i = 0; i < 4; i++) {
            arr.get(i).sendEmail(pendingPayments.get(i));
        }
        System.out.println("Sorting according to IDs.....");
        Collections.sort(arr);
        arr.forEach(System.out::println);

        System.out.println("Sorting according charges in descending order ");
        Collections.sort(arr, new Comparator<ServiceClient>() {
            @Override
            public int compare(ServiceClient o1, ServiceClient o2) {
                return (int) (o2.charges - o1.charges);
            }
        });

        arr.forEach(System.out::println);

        System.out.println("Sorting according to Agreement Date ");
        Collections.sort(arr, new Comparator<ServiceClient>() {
            @Override
            public int compare(ServiceClient o1, ServiceClient o2) {
                long ans = o1.dateOfAgreement.getTimeInMillis() - o2.dateOfAgreement.getTimeInMillis();
                if (ans > 0)
                    return 1;
                else if (ans < 0)
                    return -1;
                else
                    return 0;

            }
        });
        arr.forEach(System.out::println);

    }
}

0 replies

PavanArvapally · 2022-03-07T15:12:16Z

PavanArvapally
Mar 7, 2022


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();
    double calculatePayment(GregorianCalendar gregorianCalendar);
    void sendEmail(double payment);
}

class Work implements Client, Comparable<Work>{
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public Work(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public double getCharges(){
        return this.charges;
    }

    public double calculatePayment(GregorianCalendar invoiceDate){
        
        return (invoiceDate.get(Calendar.DATE)-dateOfAgreement.get(Calendar.DATE))*charges;
    }

    public void sendEmail(double payment){
        System.out.println("Pending amount :" + payment);
    }

    @Override
    public int compareTo(Work o) {
       return this.id - o.id;
    }
}

class Customer extends Work {
    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

     @Override
     public String toString() {
        return "Business [ id=" + id + ", name=" + name + ", email=" + email+
         ", charges=" + charges +  ", dateOfAgreement="+ dateOfAgreement.getTime()+"]";
    }

}

class Business extends Work {
    double gstRate = 12;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    public String toString() {
        return "Business [ id=" + id + ", name=" + name + ", email=" + email+
         ", charges=" + charges +  ", dateOfAgreement="+ dateOfAgreement.getTime() + "Gst-Rate=" + gstRate +"]";
    }

    public double calculatePayment(GregorianCalendar invoiceDate){
        double payment = (invoiceDate.get(Calendar.DATE)-dateOfAgreement.get(Calendar.DATE))*charges;
        return payment + payment*0.12;
    }

    public double getGstRate() {
        return gstRate;
    }
}

public class MyCompany {
    public static void main(String[] args) {
        Work c1 = new Customer(4, "Pavan", "xyz@gmail.com", 35000, new GregorianCalendar(2022, 2, 15));
        Work c2 = new Customer(3, "Santosh", "zyx&doglapan,com", 45000, new GregorianCalendar(2022, 2, 10));

        Work b1 = new Business(2, "Accenture", "work@ccenture.com", 15000, new GregorianCalendar(2022, 2, 22));
        Work b2 = new Business(1, "TCS", "work@.com", 60000, new GregorianCalendar(2022, 2, 1));

        List<Work> clients = new ArrayList<>(Arrays.asList(c1, c2, b1, b2));
        System.out.println();

        double[] pendingPayments = new double[clients.size()];
        for(int i = 0; i<pendingPayments.length; i++){ 
            pendingPayments[i] = clients.get(i).calculatePayment(new GregorianCalendar(2022, 02, 31));
            clients.get(i).sendEmail(pendingPayments[i]);
        }
        System.out.println("Sorting ids in ascending order");
        Collections.sort(clients);
        clients.forEach(System.out::println);

        System.out.println("Sorting the charges in descending order");
        Collections.sort(clients, (Comparator<Work>)(x, y) -> (int) (y.getCharges() - x.getCharges()));
        clients.forEach(System.out::println);

        System.out.println("Sorting date of agreement in ascending order");
        Collections.sort(clients, (Comparator<Work>)(x, y) -> (int) (x.dateOfAgreement.get(Calendar.DATE) - y.dateOfAgreement.get(Calendar.DATE)));
        clients.forEach(System.out::println);
    }
}

0 replies

shreiyarandive · 2022-03-07T15:25:13Z

shreiyarandive
Mar 7, 2022

package week6;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(Date invoiceDate);

    void sendEmail(double payment);
}

class ServiceClass implements Client, Comparable<ServiceClass> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    protected Date dateOfAgreement;

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(Date invoiceDate) {
        return ((Math.abs(this.dateOfAgreement.getTime() - invoiceDate.getTime()) / (1000 * 60 * 60 * 24))
                * this.charges);
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println(this.name + " Your pending amount is " + payment);
    }

    @Override
    public int compareTo(ServiceClass o) {
        return this.id - o.id;
    }
}

class Customer extends ServiceClass {

    public Customer(int id, String name, String email, double charges, Date dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public String toString() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return String.format("Id: %d, Name: %s, email: %s, charges: %.2f, Date of agreement %s", this.id, this.name,
                this.email, this.charges, format.format(this.dateOfAgreement));
    }

}

class Business extends ServiceClass {

    private double gstRate;

    public Business(int id, String name, String email, double charges, Date dateOfAgreement, double gstRate) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
        this.gstRate = gstRate;
    }

    @Override
    public String toString() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return String.format("Id: %d, Name: %s, email: %s, charges: %.2f, Date of agreement %s, GST Rate: %.2f",
                this.id, this.name,
                this.email, this.charges, format.format(this.dateOfAgreement), this.gstRate);
    }

    public double getGstRate() {
        return gstRate;
    }

}

public class MyCompany {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        ServiceClass cust1 = new Customer(1, "Shreiya", "shreiyarandive1@gmail.com", 100, format.parse("2022-01-10"));
        ServiceClass cust2 = new Customer(2, "Ashish", "ashish@gmail.com", 10, format.parse("2021-10-10"));

        ServiceClass business2 = new Business(4, "Umbrette", "Umbrette@gmail.com", 5000, format.parse("2021-12-10"), 8);
        ServiceClass business1 = new Business(3, "Virtuate", "Virtuate@gmail.com", 20, format.parse("2022-02-05"), 10);

        List<ServiceClass> clients = new ArrayList<ServiceClass>();
        clients.add(cust1);
        clients.add(cust2);
        clients.add(business1);
        clients.add(business2);

        double[] pendingAmount = new double[4];

        Date invoiceDate = format.parse("2022-03-31");
        for (int i = 0; i < 4; i++) {
            pendingAmount[i] = clients.get(i).calculatePayment(invoiceDate);
        }

        for (int i = 0; i < 4; i++) {
            clients.get(i).sendEmail(pendingAmount[i]);
        }

        System.out.println("Sorting based on ID");
        Collections.sort(clients);
        clients.forEach(System.out::println);

        System.out.println("Sorting based on Charges");
        Collections.sort(clients, (c, d) -> (int) (c.getCharges() - d.getCharges()));
        clients.forEach(System.out::println);

        System.out.println("Sorting based on Date of agreement");
        Collections.sort(clients, (c, d) -> (int) (c.dateOfAgreement.getTime() - d.dateOfAgreement.getTime()));
        clients.forEach(System.out::println);

    }
}

0 replies

SabaMhabar · 2022-03-07T16:03:17Z

SabaMhabar
Mar 7, 2022

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
double getCharges();

double calculatePayment(Calendar invoiceDate);

void sendEmail(double payment);

}

abstract class ServiceClient implements Client, Comparable {
int id;
String name;
String email;
double charges;
Calendar dateOfAgreement;

public ServiceClient(int id, String name, String email, double charges, Calendar dateOfAgreement) {
    this.id = id;
    this.name = name;
    this.email = email;
    this.charges = charges;
    this.dateOfAgreement = dateOfAgreement;
}

public double getCharges() {
    return this.charges;
}

public void sendEmail(double pendingPayment) {
    System.out.println("Your payment of Rs." + pendingPayment + " is pending");
}

@Override
public int compareTo(ServiceClient other) {
    if (this.id == other.id)
        return 0;
    if (this.id > other.id)
        return 1;
    return -1;
}

}

class Customer extends ServiceClient {

public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
    super(id, name, email, charges, dateOfAgreement);
}

public double calculatePayment(Calendar invoiceDate) {
    return (double) (getCharges() * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
}

@Override
public String toString() {
    return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
            + ", id="
            + id + ", name=" + name + "]\n";
}

}

class Business extends ServiceClient {
double gstRate;

public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement,
        double gstRate) {
    super(id, name, email, charges, dateOfAgreement);
    this.gstRate = gstRate;
}

public double getGST() {
    return this.gstRate;
}

public double calculatePayment(Calendar invoiceDate) {
    return (double) (getCharges() * this.gstRate
            * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
}

@Override
public String toString() {
    return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
            + ", gstRate=" + gstRate + ", id=" + id + ", name=" + name + "]\n";
}

}

public class MyCompany {
public static void main(String[] args) {
ServiceClient cus1 = new Customer(87, "Saba", "sabam@gmail.com", 5200, new GregorianCalendar(2022, 1, 2));
ServiceClient cus2 = new Customer(25, "Madhuri", "madhu@gmail.com", 3500.0, new GregorianCalendar(2022, 1, 14));

    ServiceClient bus1 = new Business(43, "Priya", "priya@gmail.com", 2100.0, new GregorianCalendar(2022, 1, 26),
            2.3);
    ServiceClient bus2 = new Business(14, "Ateeb", "ateeb@gmail.com", 4200.0, new GregorianCalendar(2022, 1, 18),
            1.7);

    List<ServiceClient> list = new ArrayList<>();
    list.add(cus1);
    list.add(cus2);
    list.add(bus1);
    list.add(bus2);
    double[] pendingPayment = new double[4];
    for (int i = 0; i < list.size(); i++) {
        pendingPayment[i] = list.get(i).calculatePayment(new GregorianCalendar(2022, 2, 1));
        list.get(i).sendEmail(pendingPayment[i]);
    }
    // sort accoring to id
    Collections.sort(list);
    System.out.println("Sorted according to id \n" + list);
    // sort accoring to charges
    list.sort((ob1, ob2) -> (int) (ob2.getCharges() - ob1.getCharges()));
    System.out.println("Sorted according to charges \n" + list);
    // sort accoring to date
    list.sort((ob1, ob2) -> (int) (ob1.dateOfAgreement.get(Calendar.DATE)
            - ob2.dateOfAgreement.get(Calendar.DATE)));
    System.out.println("Sorted according to date \n" + list);
}

}

0 replies

Shubhi27 · 2022-03-07T17:32:00Z

Shubhi27
Mar 7, 2022


package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class Services implements Client, Comparable<Services> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Services(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Services o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Services {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Services {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Services c1 = new Customer(101, "Shubhi", "abc12@email.com", 300);
        Services c2 = new Customer(102, "ABC", "xyz13@email.com", 350);

        Services c3 = new Business(103, "Microsoft", "zm1@email.com", 6000);
        Services c4 = new Business(104, "Lenskart", "po45@email.com", 9000);

        List<Services> clients = new ArrayList<>();
        clients.add(c1);
        clients.add(c2);
        clients.add(c3);
        clients.add(c4);
        clients.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        clients.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 29))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < clients.size(); i++) {
            clients.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(clients);
        clients.forEach(System.out::println);

        Collections.sort(clients, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        clients.forEach(System.out::println);

        Collections.sort(clients,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        clients.forEach(System.out::println);

    }
}

0 replies

GantaGreeshma · 2022-03-07T18:16:20Z

GantaGreeshma
Mar 7, 2022

package collection_framework;

import java.util.*;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar gregorianCalendar);

    void sendEmail(double payment);
}

class ServiceClient implements Client, Comparable {
    int id;
    String name;
    String email;
    double charges;
    Calendar dateOfAgreement;

    public ServiceClient(int id, String name, String email, double charges, Calendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public double getCharges() {
        return this.charges;
    }

    public void sendEmail(double pendingPayment) {
        System.out.println("pending payment of" + pendingPayment);
    }

    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public double calculatePayment(GregorianCalendar gregorianCalendar) {
        // TODO Auto-generated method stub
        return 0;
    }
}

class Customer extends ServiceClient {
    public Customer(int id, String name, String email, double charges, Calendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {
        return (double) (getCharges() * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfagreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }

}

class Business extends ServiceClient {
    double gstRate;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement,
            double gstRate) {
        super(id, name, email, charges, dateOfAgreement);
        this.gstRate = gstRate;
    }

    public double getGst() {
        return this.gstRate;
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {
        return (double) (getCharges() * (invoiceDate.get(Calendar.DATE) - dateOfAgreement.get(Calendar.DATE)));
    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfagreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "gstRate=" + gstRate + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {
        ServiceClient customer1 = new Customer(2, "greeshma", "1234@gmail.com", 54, new GregorianCalendar(3, 2, 2022));
        ServiceClient customer2 = new Customer(1, "satya", "12343@gmail.com", 44, new GregorianCalendar(2, 2, 2022));
        ServiceClient business1 = new Business(3, "surya", "12345@gmail.com", 44, new GregorianCalendar(1, 2, 2022),
                5.2);
        ServiceClient business2 = new Business(4, "saranya", "saranya5@gmail.com", 23,
                new GregorianCalendar(4, 4, 2022), 4.5);
        ArrayList<ServiceClient> list = new ArrayList<>();
        list.add(customer1);
        list.add(customer2);
        list.add(business1);
        list.add(business2);
        double[] pendingPayment = new double[4];
        for (int i = 0; i < list.size(); i++) {
            pendingPayment[i] = list.get(i).calculatePayment(new GregorianCalendar(2022, 2, 31));
            list.get(i).sendEmail(pendingPayment[i]);
        }
        Collections.sort(list);
        System.out.println("Acc to id" + list);
        list.sort((ob1, ob2) -> (int) (ob1.getCharges() - ob2.getCharges()));
        System.out.println("Acc to charges" + list);
        list.sort((ob1, ob2) -> (int) (((Calendar) ob1.dateOfAgreement).get(Calendar.DATE)
                - ((Calendar) ob2.dateOfAgreement).get(Calendar.DATE)));
        System.out.println("Acc to date" + list);
    }

}

0 replies

rakeshGit419 · 2022-03-07T19:09:25Z

rakeshGit419
Mar 7, 2022

import java.util.*;

interface Client {
    double getCharges();
    double calculatePayment(GregorianCalendar invoiceDate);
    void sendEmail(double payment);
}

class Clients implements Client, Comparable<Clients> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.id;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return getDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Your Pending with :" + payment);
    }

    protected long getDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return (getDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges*GST_RATE)/100;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class SortCollectionsLooseCoupling{
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "ShowBot", "showbot@email.com", 2000);
        Clients c2 = new Customer(105, "Rakesh", "rakesh@email.com", 3000);
        Clients b1 = new Business(102, "Wipro", "wipro@email.com", 200);
        Clients b2 = new Business(103, "Infosys", "infosys@email.com", 300);

        List<Clients> list = Arrays.asList(c1,c2,b1,b2);

        List<Double> pendingPayments = new ArrayList<>();

        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) ->(int)(a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,(a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

RohitN09 · 2022-03-07T19:26:30Z

RohitN09
Mar 7, 2022

package Week_6.Collection;

import java.util.*;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

class Service implements Client, Comparable<Service> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Service(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Service o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Service {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Service {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {

    public static void main(String[] args) {

        Service c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Service c2 = new Customer(103, "Rohit", "xyz@email.com", 300);

        Service b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Service b2 = new Business(104, "Amazon", "xyz@email.com", 3000);

        List<Service> list = new ArrayList<>(Arrays.asList(b1, b2, c1, c2));

        System.out.println("Original: ");
        list.forEach(System.out::println);

        System.out.println("\nPending Payments: ");
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);

        System.out.println("\nEmails: ");
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        System.out.println("\nDefault Sorting: ");
        Collections.sort(list);
        list.forEach(System.out::println);

        System.out.println("\nSorting (Charges): ");
        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));
        list.forEach(System.out::println);

        System.out.println("\nSorting (Date of Agreement): ");
        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));
        list.forEach(System.out::println);

    }
}

0 replies

Khyati-tripathi · 2022-03-07T19:40:14Z

Khyati-tripathi
Mar 7, 2022


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.GregorianCalendar;
import java.util.Collections;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

class Details implements Client, Comparable<Details> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public Details(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public double getCharges() {
        return charges;
    }

    public double calculatePayment(GregorianCalendar invoiceDate) {

        return ((int) invoiceDate.get(Calendar.DATE) - (int) dateOfAgreement.get(Calendar.DATE)) * getCharges();

    }

    public void sendEmail(double payment) {
        System.out.println("Your pending amount is: " + payment);
    }

    @Override
    public int compareTo(Details o) {
        return this.id - o.id;
    }

}

class Customer extends Details {

    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    public String toString() {
        return " Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email + ", id="
                + id + ", name=" + name + "]";
    }

}

class Business extends Details {
    double gstRate;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement,
            double gstRate) {
        super(id, name, email, charges, dateOfAgreement);
        this.gstRate = gstRate;
    }

    double getGST() {
        return gstRate;

    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double pay = super.calculatePayment(invoiceDate);
        pay = pay + pay * (getGST() / 100);
        return pay;

    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email
                + ", gstRate=" + gstRate + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Details cust1 = new Customer(1, "Tony Stark", "Stark@gmail.com", 60, new GregorianCalendar(2022, 1, 14));
        Details cust2 = new Customer(2, "DeadPool", "wade@gmail.com", 55, new GregorianCalendar(2022, 3, 5));
        Details buss1 = new Business(121, "Electronics", "ele@gamil.com", 70.5, new GregorianCalendar(2022, 2, 1), 2.5);
        Details buss2 = new Business(123, "Grocery", "abc@gmail.com", 56.75, new GregorianCalendar(2022, 3, 7), 4);
        ArrayList<Details> list = new ArrayList<>();
        list.add(cust1);
        list.add(cust2);
        list.add(buss1);
        list.add(buss2);
        int n = list.size();
        double[] pendingPayments = new double[n];

        for (int i = 0; i < n; i++) {
            pendingPayments[i] = list.get(i).calculatePayment(new GregorianCalendar(2022, 3, 30));
            System.out.print(pendingPayments[i] + " ");

        }
        System.out.println();

        for (int i = 0; i < n; i++) {

            list.get(i).sendEmail(pendingPayments[i]);

        }
        System.out.println();
        System.out.println("Sorting according to ID: ");
        Collections.sort(list);
        list.forEach(System.out::println);
        System.out.println();
        System.out.println("Sorting According to charges: ");
        list.sort((Details obj1, Details obj2) -> (int) (obj2.getCharges() - obj1.getCharges()));
        list.forEach(System.out::println);
        System.out.println();
        System.out.println("Sorting According to date of Agreement: ");
        list.sort((Details obj1,
                Details obj2) -> (obj1.dateOfAgreement.get(Calendar.DATE) - obj2.dateOfAgreement.get(Calendar.DATE)));
        list.forEach(System.out::println);

    }
}

0 replies

mkaifahmed · 2022-03-08T03:22:44Z

mkaifahmed
Mar 8, 2022

package Week6;

import java.util.*;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

class Service implements Client, Comparable<Service> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Service(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Service o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Service {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Service {
    private final double gstRate = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.gstRate;
    }

    @Override
    public String toString() {
        return "Business [gstRate=" + gstRate + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {

    public static void main(String[] args) {

        Service c1 = new Customer(101, "arpit", "xyz@email.com", 200);
        Service c2 = new Customer(103, "vaars", "xyz@email.com", 300);

        Service b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Service b2 = new Business(104, "Amazon", "xyz@email.com", 3000);

        List<Service> list = new ArrayList<>(Arrays.asList(b1, b2, c1, c2));

        System.out.println("Original: ");
        list.forEach(System.out::println);

        System.out.println("\nPending Payments: ");
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);

        System.out.println("\nEmails: ");
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        System.out.println("\nDefault Sorting: ");
        Collections.sort(list);
        list.forEach(System.out::println);

        System.out.println("\nSorting (Charges): ");
        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));
        list.forEach(System.out::println);

        System.out.println("\nSorting (Date of Agreement): ");
        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));
        list.forEach(System.out::println);

    }
}

0 replies

RohitNaikade1 · 2022-03-08T03:22:54Z

RohitNaikade1
Mar 8, 2022

import java.util.*;

interface Client{
    double getCharges();
    double calculatePayment(GregorianCalendar invoiceDate);
    void sendEmail(double payment);
}

class Clients implements Client,Comparable<Clients>{
    protected int id;
    protected String name,email;
    protected double charges;
    GregorianCalendar dateOfAgreement;
    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement=new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id-o.id;
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findDays(invoiceDate,this.dateOfAgreement)*charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);
        
    }
    
    protected long findDays(Date d1, Date d2){
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
    
}
class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class SortCollections{
    public static void main(String[] args) {
        Clients cust1=new Customer(101,"Rohit","rohit@gmail.com",200);
        Clients cust2=new Customer(102,"Omkar","omkar@gmail.com",400);
        Clients bus1=new Business(103,"Rohit","rohit@gmail.com",200);
        Clients bus2=new Business(104,"Omkar","omkar@gmail.com",400);

        ArrayList<Clients> list = new ArrayList<>();
        
        list.add(cust1);
        list.add(cust2);
        list.add(bus1);
        list.add(bus2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);
        

    }
}

0 replies

SrideviYamala · 2022-03-08T03:29:32Z

SrideviYamala
Mar 8, 2022

package collections;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.List;

interface Client{
    double getCharges();

    double calculatePayment(Calendar invoiceDate);

    void sendEmail(double payment);
}

abstract class ServiceClient implements Client,Comparable<ServiceClient> {
    int id;
    String name;
    String email;
    double charges;
    Calendar dateOfAgreement;
    protected ServiceClient(int id, String name, String email, double charges, Calendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }
    
    @Override
    public double getCharges() {
        return charges;
    }

    @Override
    public int compareTo(ServiceClient other) {
        return this.id - other.id;
    }

    @Override
    public String toString() {
        return "charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id=" + id + ", name=" + name;
    }
   
}

class Customer extends ServiceClient {
    
    public Customer(int id, String name, String email, double charges, Calendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    public double calculatePayment(Calendar invoiceDate) {
        int invoicedate = invoiceDate.get(Calendar.DATE);
        int dateofAgreement = this.dateOfAgreement.get(Calendar.DATE);
        return (invoicedate - dateofAgreement) * getCharges();
    }
    
    @Override
    public void sendEmail(double payment) {
        System.out.println("Dear Customer! You have a pending payment of " + payment);
    }

    @Override
    public String toString() {
        return "Customer [" + super.toString() + "]";
    }

}

class Business extends ServiceClient {
    
    double gstRate=0.18;
    
    public Business(int id, String name, String email, double charges, Calendar dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    double getGST() {
        return gstRate;
    }

    @Override
    public double calculatePayment(Calendar invoiceDate) {
        int invoicedate = invoiceDate.get(Calendar.DATE);
        int dateofAgreement = this.dateOfAgreement.get(Calendar.DATE);
        return (invoicedate - dateofAgreement) * getCharges() * getGST();
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Dear Business Client! You have a pending payment of " + payment);
    }

    @Override
    public String toString() {
        return "Business [" + super.toString() + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {
        ServiceClient cust1 = new Customer(119, "Sri", "sri@gmail.com", 200, new GregorianCalendar(2022,2,5));
        ServiceClient cust2 = new Customer(108, "Aish", "aish@gmail.com", 300, new GregorianCalendar(2022, 2, 10));
        ServiceClient busi1 = new Business(116, "Snapdeal", "snap@gmail.com", 2000, new GregorianCalendar(2022, 2, 15));
        ServiceClient busi2 = new Business(105, "Vodafone", "voda@gmail.com", 3000, new GregorianCalendar(2022, 2, 20));
        List<ServiceClient> arrayOfClients = new ArrayList<>();
        arrayOfClients.add(cust1);
        arrayOfClients.add(cust2);
        arrayOfClients.add(busi1);
        arrayOfClients.add(busi2);
        int n = arrayOfClients.size();
        double[] pendingPayments = new double[n];
        for (int i = 0; i < n; i++) {
            pendingPayments[i] = arrayOfClients.get(i).calculatePayment(new GregorianCalendar(2022, 2, 31));
            arrayOfClients.get(i).sendEmail(pendingPayments[i]);
        }
        System.out.println("Natural Ordering:");
        Collections.sort(arrayOfClients);
        arrayOfClients.forEach(System.out::println);
        System.out.println();
        System.out.println("Sort according to charges:");
        arrayOfClients.sort((ob1, ob2) -> (int) (ob2.getCharges() - ob1.getCharges()));
        System.out.println(arrayOfClients);
        System.out.println();
        System.out.println("Sort according to date:");
        arrayOfClients.sort((ob1, ob2) -> (ob1.dateOfAgreement.get(Calendar.DATE)
                - ob2.dateOfAgreement.get(Calendar.DATE)));
        System.out.println(arrayOfClients);
    }
}

0 replies

lalit-ky · 2022-03-08T04:08:25Z

lalit-ky
Mar 8, 2022

package MyCompany;

import java.util.ArrayList;
import java.util.Collections;
import java.util.GregorianCalendar;

interface Client {

    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

class Clients implements Client, Comparable<Clients> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    @Override
    public double getCharges() {
        return charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        long days = (invoiceDate.getTime().getTime() - this.dateOfAgreement.getTime().getTime()) / (1000 * 3600 * 24);
        return charges * days;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Sent an Email to " + email + " for the payment of " + payment);
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.id;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Clients other = (Clients) obj;
        if (id != other.id)
            return false;
        return true;
    }

}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public String toString() {
        return "Customer [charges = " + charges + ", dateOfAgreement = " + dateOfAgreement.getTime() + ", email = "
                + email + ", id = " + id + ", name = " + name + "]";
    }

}

class Business extends Clients {
    static double gstRate;
    static {
        gstRate = 0.18;
    }

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public double getGST() {
        return charges * gstRate;
    }

    @Override
    public String toString() {
        return "Business [charges = " + charges + ", dateOfAgreement = " + dateOfAgreement.getTime() + ", email = "
                + email + ", id = " + id + ", name = " + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {
        Clients a1 = new Customer(1, "A1", "a1@gmail.com", 100, new GregorianCalendar(2022, 1, 28));
        Clients a2 = new Customer(3, "A1", "a2@gmail.com", 120, new GregorianCalendar(2022, 1, 25));

        Clients b1 = new Business(2, "B1", "b1@gmail.com", 90, new GregorianCalendar(2022, 2, 1));
        Clients b2 = new Business(4, "B2", "b2@gmail.com", 50, new GregorianCalendar(2022, 0, 4));

        ArrayList<Clients> list = new ArrayList<>();
        list.add(a1);
        list.add(a2);
        list.add(b1);
        list.add(b2);

        ArrayList<Double> pendingPayments = new ArrayList<>();

        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));

        pendingPayments.forEach(System.out::println);
        System.out.println();

        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }
        System.out.println();

        Collections.sort(list);
        list.forEach(System.out::println);
        System.out.println();

        Collections.sort(list, (a, b) -> (int) (b.getCharges() - a.getCharges()));
        list.forEach(System.out::println);
        System.out.println();

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));
        list.forEach(System.out::println);
        System.out.println();

    }

}

0 replies

Mrafe · 2022-03-08T05:15:18Z

Mrafe
Mar 8, 2022

package week6.monday;

import java.util.*;

interface Client {
    double getCharges();

    double calculatePayment(String invoiceDate);

    void sendEmail(double payment);
}

class Client2 implements Client, Comparable<Client2> {

    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    protected String dateOfAgreement;

    public Client2(int id, String name, String email, double charges, String dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    public int getId() {
        return this.id;
    }

    int getDays(String invoiceDate) {
        return Integer.parseInt(invoiceDate.substring(3, 5)) * 30 + Integer.parseInt(invoiceDate.substring(0, 2))
                - Integer.parseInt(dateOfAgreement.substring(3, 5)) * 30
                - Integer.parseInt(dateOfAgreement.substring(0, 2)) + ((Integer.parseInt(invoiceDate.substring(6, 10))
                        - (Integer.parseInt(dateOfAgreement.substring(6, 10)))) * 365);
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(String invoiceDate) {
        return charges * getDays(invoiceDate);
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent " + payment + " pending payment");

    }

    @Override
    public int compareTo(Client2 o) {
        return this.id - o.getId();
    }

}

class Customer extends Client2 {

    public Customer(int id, String name, String email, double charges, String dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    int getDays(String invoiceDate) {
        return Integer.parseInt(invoiceDate.substring(3, 5)) * 30 + Integer.parseInt(invoiceDate.substring(0, 2))
                - Integer.parseInt(dateOfAgreement.substring(3, 5)) * 30
                - Integer.parseInt(dateOfAgreement.substring(0, 2)) + ((Integer.parseInt(invoiceDate.substring(6, 10))
                        - (Integer.parseInt(dateOfAgreement.substring(6, 10)))) * 365);
    }

    @Override
    public double getCharges() {
        return charges;
    }

    @Override
    public double calculatePayment(String invoiceDate) {
        return charges * getDays(invoiceDate);
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent regarding " + payment + " amount of pending payment");

    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement + ", email=" + email + ", id="
                + id + ", name=" + name + "]";
    }

}

class Business extends Client2 {
    static final double GST = 18;

    public Business(int id, String name, String email, double charges, String dateOfAgreement) {
        super(id, name, email, charges, dateOfAgreement);
    }

    @Override
    int getDays(String invoiceDate) {
        return Integer.parseInt(invoiceDate.substring(3, 5)) * 30 + Integer.parseInt(invoiceDate.substring(0, 2))
                - Integer.parseInt(dateOfAgreement.substring(3, 5)) * 30
                - Integer.parseInt(dateOfAgreement.substring(0, 2)) + ((Integer.parseInt(invoiceDate.substring(6, 10))
                        - (Integer.parseInt(dateOfAgreement.substring(6, 10)))) * 365);
    }

    @Override
    public double getCharges() {
        return charges;
    }

    @Override
    public double calculatePayment(String invoiceDate) {
        return charges * getDays(invoiceDate);
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent regarding " + payment + " amount of pending payment");

    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement + ", email=" + email
                + ", GST=" + GST + ", id=" + id + ", name=" + name + "]";
    }

    double getGST() {
        return GST * charges;
    }

}

class MyCompany {
    public static void main(String[] args) {
        Client2 customer1 = new Customer(123, "Mai Sakurajima", "Mai@xyz.com", 250.0, "14/11/2020");
        Client2 customer2 = new Customer(124, "Shoko Makinohara", "Shoko@xyz.com", 300.0, "31/10/2020");
        Client2 business1 = new Business(321, "Anime", "Anime@xyz.com", 350.0, "12/11/2020");
        Client2 business2 = new Business(322, "Manga", "Manga@xyz.com", 200.0, "23/12/2020");
        String date = "31/03/2022";

        List<Client2> clients = new ArrayList<>(Arrays.asList(customer1, customer2, business1, business2));

        clients.forEach(System.out::println);

        double[] pendingPayment = new double[4];
        for (int i = 0; i < 4; i++) {
            pendingPayment[i] = clients.get(i).calculatePayment(date);
        }
        System.out.println(Arrays.toString(pendingPayment));

        Collections.sort(clients);
        clients.forEach(System.out::println);

        Collections.sort(clients, (client1, client2) -> (int) (client1.getCharges() - client2.getCharges()));
        clients.forEach(System.out::println);

        Collections.sort(clients,
                (client1, client2) -> (client1.getDays(date) - client2.getDays(date)));
        clients.forEach(System.out::println);

    }
}

0 replies

Ashritha-sd · 2022-03-08T16:14:20Z

Ashritha-sd
Mar 8, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
interface Client {
double getCharges();
double calculatePayment(GregorianCalendar invoiceDate);
void sendEmail(double payment);
}
class Clients implements Client, Comparable {
protected int id;
protected String name;
protected String email;
protected double charges;
GregorianCalendar dateOfAgreement;
public Clients(int id, String name, String email, double charges) {
this.id = id;
this.name = name;
this.email = email;
this.charges = charges;
this.dateOfAgreement = new GregorianCalendar();
}
public int getId() {
return id;
}
public GregorianCalendar getDateOfAgreement() {
return dateOfAgreement;
}
@OverRide
public int compareTo(Clients o) {
return this.id - o.getId();
}
@OverRide
public double getCharges() {
return this.charges;
}
@OverRide
public double calculatePayment(GregorianCalendar invoiceDate) {
return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
}
@OverRide
public void sendEmail(double payment) {
System.out.println("pending payment :" + payment);
}
protected long findServicableDays(Date d1, Date d2) {
return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
}
}
class Customer extends Clients {
public Customer(int id, String name, String email, double charges) {
super(id, name, email, charges);
}
@OverRide
public String toString() {
return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email + ", id=" + id + ", name=" + name + "]";
}
}
class Business extends Clients {
private final double GST_RATE = 18;
public Business(int id, String name, String email, double charges) {
super(id, name, email, charges);
}
@OverRide
public double calculatePayment(GregorianCalendar invoiceDate) {
double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
return payment + payment * .18;
}
public double getGst() {
return this.GST_RATE;
}
@OverRide
public String toString() {
return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email + ", id=" + id + ", name=" + name + "]";
}
}
public class SortingCollections {
public static void main(String[] args) {
Clients c1 = new Customer(101, "Ashritha", "ashritha@email.com", 500);
Clients c2 = new Customer(103, "Dharma", "dharma@email.com", 200);
Clients b1 = new Business(102, "abc", "abc@email.com", 1000);
Clients b2 = new Business(104, "def", "def@email.com", 2000);
List list = new ArrayList<>();
list.add(b1);
list.add(b2);
list.add(c1);
list.add(c2);
list.forEach(System.out::println);
List pendingPayments = new ArrayList<>();
list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
pendingPayments.forEach(System.out::println);
for (int i = 0; i < list.size(); i++) {
list.get(i).sendEmail(pendingPayments.get(i));
}
Collections.sort(list);
list.forEach(System.out::println);
Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));
list.forEach(System.out::println);
Collections.sort(list,
(a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));
list.forEach(System.out::println);
}
}

0 replies

Snehil6197 · 2022-03-09T15:11:15Z

Snehil6197
Mar 9, 2022

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Consumer;

interface Client extends Comparable {
double getCharges();

double calculatePayment(String invoiceDate);

void sendEmail(double payment);

}

abstract class Clients implements Client {
int id;
String name;
String email;
double charges;
double tAmount;
double tCharges;
Date dateOfAgreement;
long pdate;

Clients(int id, String name, String email, double charges, String doe) {
    this.id = id;
    this.name = name;
    this.email = email;
    this.charges = charges;
    SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
    try {
        Date d = sdf.parse(doe);
        this.dateOfAgreement = d;
    } catch (Exception e) {
        System.out.println("exception occured");
    }

}

@Override
public int compareTo(Object obj) {
    Clients c = (Clients) obj;
    return this.id - c.id;
}

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

}

class Customer extends Clients {

Customer(int id, String name, String email, double charges, String doe) {
    super(id, name, email, charges, doe);
}
// @Override
// public int compareTo(Object ob){

// }

public double calculatePayment(String invoiceDate) {
    try {
        pdate = SortingCollections.convert(this.dateOfAgreement, invoiceDate);

    } catch (ParseException e) {
        System.out.println("exception");
    }
    this.tAmount = pdate * this.charges;
    this.tCharges = this.tAmount;
    return this.tAmount;

}

public double getCharges() {
    return this.tCharges;
}

public void sendEmail(double payment) {
    System.out.println("pending amount :" + payment);
}

}

class Business extends Clients {

double gstRate = 18;

Business(int id, String name, String email, double charges, String doe) {
    super(id, name, email, charges, doe);
}

public double calculatePayment(String invoiceDate) {
    try {
        pdate = SortingCollections.convert(this.dateOfAgreement, invoiceDate);

    } catch (ParseException e) {
        System.out.println("exception");
    }
    this.tAmount = (pdate * this.charges) + (0.18 * pdate * this.charges);
    this.tCharges = tAmount;
    return this.tAmount;

}

public double getCharges() {
    return this.tAmount;
}

public void sendEmail(double payment) {
    System.out.println("pending amount :" + payment);
}

double getGST() {
    return this.tCharges;
}

}

public class SortingCollections {
public static void main(String[] args) throws ParseException {
List clientList = new ArrayList<>();
double[] pendingPay = new double[4];

    String tDate = "31-03-2022";

    Clients c1 = new Customer(203, "bran", "bran@pmail.com", 200, "10-03-2022");
    clientList.add(c1);
    Clients c2 = new Customer(628, "arya", "arya@pmail.com", 500, "28-02-2022");
    clientList.add(c2);
    Clients c3 = new Business(288, "flipkart", "flipkart@pmail.com", 3000.63, "1-02-2022");
    clientList.add(c3);
    Clients c4 = new Business(2003, "ebay", "ebay@pmail.com", 2628.38, "1-01-2022");
    clientList.add(c4);

    pendingPay[0] = c1.calculatePayment(tDate);
    c1.sendEmail(pendingPay[0]);
    pendingPay[1] = c2.calculatePayment(tDate);
    c1.sendEmail(pendingPay[1]);
    pendingPay[2] = c3.calculatePayment(tDate);
    c1.sendEmail(pendingPay[2]);
    pendingPay[3] = c4.calculatePayment(tDate);
    c1.sendEmail(pendingPay[3]);

    System.out.println("before sorting");
    clientList.forEach((obj) -> System.out.println(obj));

    System.out.println("sorting in natural order");
    Collections.sort(clientList);
    clientList.forEach((obj) -> System.out.println(obj));

    // (Consumer<clientList>)(obj) -> System.out.println(obj);)
    System.out.println("sorting according to charges");
    clientList.sort((ob1, ob2) -> (int) (ob1.tCharges - ob2.tCharges));
    // Collections.sort(clientList,Collections.reverseOrder());
    clientList.forEach(System.out::println);

    System.out.println("sorting according to date of aggrement");

    Collections.sort(clientList, (ob1, ob2) -> (int) (ob1.pdate - ob2.pdate));
    clientList.forEach(System.out::println);


}

public static long convert(Date d1, String d2) throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
    Date date2 = sdf.parse(d2);
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(d1);
    Calendar calendar2 = Calendar.getInstance();
    calendar2.setTime(date2);
    long sec = calendar2.getTimeInMillis() - calendar.getTimeInMillis();
    long res = sec / (long) (60 * 60 * 24 * 1000);
    return res;

}

}
``

0 replies

ShraddhaPenshanwar · 2022-03-13T19:45:51Z

ShraddhaPenshanwar
Mar 13, 2022

`package collections;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

interface Client {
double getCharges();

double calculatePayment(Date invoiceDate);

void sendEmail(double payment);

}

abstract class Service implements Client, Comparable {

int id;
double charges;
Date dateOfAgreement;

public Service(int id, double charges, Date dateOfAgreement) {
    this.id = id;
    this.charges = charges;
    this.dateOfAgreement = dateOfAgreement;
}

@Override
public double getCharges() {
    return this.charges;
}

@Override
public void sendEmail(double payment) {
    System.out.println("Your Pending amount is: " + payment);
}

@Override
public double calculatePayment(Date invoiceDate) {
    long diff = invoiceDate.getTime() - this.dateOfAgreement.getTime();
    diff = diff / (1000 * 60 * 60 * 24) % 365;
    return diff * this.getCharges();
}

@Override
public int compareTo(Service o) {
    if (this.id == o.id)
        return 0;
    if (this.id > o.id)
        return 1;
    return -1;
}

}

class Customer extends Service {
String name;
String email;

public Customer(int id, String name, String email, double charges, Date dateOfAgreement) {
    super(id, charges, dateOfAgreement);
    this.name = name;
    this.email = email;
}

@Override
public String toString() {
    return "Customer [charges=" + charges + ", dateOfAgreement=" +
            dateOfAgreement + ", email=" + email + ", id="
            + id + ", name=" + name + "]";
}

}

class Business extends Service {
String name;
String email;
double gsRate;

public Business(int id, String name, String email, double charges, double gsRate, Date dateOfAgreement) {
    super(id, charges, dateOfAgreement);
    this.name = name;
    this.email = email;
    this.gsRate = gsRate;
}

double getGST() {
    return 0;
}

@Override
public String toString() {
    return "Business [charges=" + charges + ", dateOfAgreement=" +
            dateOfAgreement + ", email=" + email
            + ", gsRate=" + gsRate + ", id=" + id + ", name=" + name + "]";
}

}

public class SortingChallenge {
public static void main(String[] args) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("dd-mm-yyyy");
Service cust2 = new Customer(1, "John", "john@xyz.com", 200, sdf.parse("20-02-2022"));
Service cust1 = new Customer(2, "Jack", "jack@abc.com", 100, sdf.parse("01-02-2022"));

    Service bus2 = new Business(11, "X Corp", "xcorp@xc.com", 15000, 10.5, sdf.parse("01-01-2020"));

    Service bus1 = new Business(12, "E Corp", "ecorp@ec.com", 20000, 9.5, sdf.parse("01-04-2021"));

    List<Service> clientArr = new ArrayList<>();

    clientArr.add(cust1);
    clientArr.add(cust2);
    clientArr.add(bus1);
    clientArr.add(bus2);

    double[] pendingArr = new double[4];
    for (int i = 0; i < pendingArr.length; i++) {
        pendingArr[i] = clientArr.get(i).calculatePayment(sdf.parse("31-03-2022"));
        clientArr.get(i).sendEmail(pendingArr[i]);
    }

    Collections.sort(clientArr);

    clientArr.forEach(System.out::println);

    clientArr.sort((Service c1, Service c2) -> (int) (c2.getCharges() - c1.getCharges()));
    clientArr.forEach(System.out::println);

    clientArr.sort((Service c1, Service c2) -> (int) (c1.dateOfAgreement.getTime() - c2.dateOfAgreement.getTime()));
    clientArr.forEach(System.out::println);

}

}`

0 replies

uzma23 · 2022-07-19T06:04:25Z

uzma23
Jul 19, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class Clients implements Client, Comparable<Clients> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Clients c2 = new Customer(103, "Rohit", "xyz@email.com", 300);

        Clients b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Clients b2 = new Business(104, "Amazon", "xyz@email.com", 3000);

        List<Clients> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(c1);
        list.add(c2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

meghvi-raj · 2022-07-19T06:47:00Z

meghvi-raj
Jul 19, 2022

import java.util.*;

public class D50 {
    public static void main(String[] args) {

        // task 1
        ServiceClient c1 = new Customer1(3, "James", "jk@gmail.com", 1000, new GregorianCalendar(2022, 2, 7));
        ServiceClient c2 = new Customer1(2, "Adam", "as@gmail.com", 1000, new GregorianCalendar(2022, 2, 8));
        // task 2
        ServiceClient c3 = new Business(1, "Marie", "er@gmail.com", 2000, new GregorianCalendar(2022, 2, 9));
        ServiceClient c4 = new Business(5, "Nick", "nb@gmail.com", 2000, new GregorianCalendar(2022, 2, 10));
        // task 3
        List<ServiceClient> clients = new ArrayList<>();
        clients.add(c1);
        clients.add(c2);
        clients.add(c3);
        clients.add(c4);
        // task 4
        double[] pendingPayments = new double[4];

        for (int i = 0; i < 4; i++) {
            pendingPayments[i] = clients.get(i).calculatePayment(new GregorianCalendar(2022, 2, 30));
        }
        System.out.println(Arrays.toString(pendingPayments));
        // task 5
        for (int i = 0; i < 4; i++) {
            clients.get(i).sendEmail(pendingPayments[i]);
        }
        System.out.println();

        // task 6
        System.out.println("Sort According to Id");
        Collections.sort(clients);
        clients.forEach(System.out::println);
        System.out.println();
        // task 7
        System.out.println("Sort According to charges");
        clients.sort((ServiceClient o1, ServiceClient o2) -> (int) (o2.getCharges() - o1.getCharges()));
        clients.forEach(System.out::println);
        System.out.println();
        // task 8
        System.out.println("Sort According to date of Agreement");
        clients.sort((ServiceClient o1,
                ServiceClient o2) -> (o1.dateOfAgreement.get(Calendar.DATE) - o2.dateOfAgreement.get(Calendar.DATE)));
        clients.forEach(System.out::println);

    }

}

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);
}

abstract class ServiceClient implements Client, Comparable<ServiceClient> {
    int id;
    String name;
    String email;
    double charges;
    GregorianCalendar dateOfAgreement;

    public int compareTo(ServiceClient other) {
        return this.id - other.id;
    }

    public double getCharges() {
        return charges;
    }

    public double calculate(GregorianCalendar invoiceDate) {
        int date = invoiceDate.get(Calendar.DATE);
        int agreementDate = dateOfAgreement.get(Calendar.DATE);
        return (date - agreementDate) * getCharges();
    }

    public void sendEmail(double payment) {
        System.out.println("Pending Payment: " + payment);
    }

}

class Customer1 extends ServiceClient {

    public Customer1(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email + ", id="
                + id + ", name=" + name + "]";
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return calculate(invoiceDate);
    }

}

class Business extends ServiceClient {

    double gstRate = 12;

    public Business(int id, String name, String email, double charges, GregorianCalendar dateOfAgreement) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return calculate(invoiceDate) * getGST();
    }

    double getGST() {
        return gstRate;
    }

    @Override
    public String toString() {
        return "Business [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.get(Calendar.DATE) + ", email="
                + email
                + ", gstRate=" + gstRate + ", id=" + id + ", name=" + name + "]";
    }

}

0 replies

gayatribabar · 2022-07-19T06:54:10Z

gayatribabar
Jul 19, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class Clients implements Client, Comparable<Clients> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Clients c2 = new Customer(103, "Rohit", "xyz@email.com", 300);

        Clients b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Clients b2 = new Business(104, "Amazon", "xyz@email.com", 3000);

        List<Clients> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(c1);
        list.add(c2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

ghost · 2022-07-19T06:56:42Z

ghost
Jul 19, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();
    double calculatePayment(GregorianCalendar invoiceDate);
    void sendEmail(double payment);
}

class Clients implements Client, Comparable<Clients> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .18;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }
}
public class d50 {
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Clients c2 = new Customer(103, "Rohit", "xyz@email.com", 300);

        Clients b1 = new Business(102, "Google", "xyz@email.com", 2000);
        Clients b2 = new Business(104, "Amazon", "xyz@email.com", 3000);
        List<Clients> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(c1);
        list.add(c2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2022, 2, 31))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

Gauravkumar930 · 2022-08-26T16:09:15Z

Gauravkumar930
Aug 26, 2022

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();

    double calculatePayment(GregorianCalendar invoiceDate);

    void sendEmail(double payment);

}

class Clients implements Client, Comparable<Clients> {
    protected int id;
    protected String name;
    protected String email;
    protected double charges;
    GregorianCalendar dateOfAgreement;

    public Clients(int id, String name, String email, double charges) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = new GregorianCalendar();
    }

    public int getId() {
        return id;
    }

    public GregorianCalendar getDateOfAgreement() {
        return dateOfAgreement;
    }

    @Override
    public int compareTo(Clients o) {
        return this.id - o.getId();
    }

    @Override
    public double getCharges() {
        return this.charges;
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
    }

    @Override
    public void sendEmail(double payment) {
        System.out.println("Email sent with pending payment :" + payment);

    }

    protected long findServicableDays(Date d1, Date d2) {
        return (d1.getTime() - d2.getTime()) / (1000 * 3600 * 24);
    }
}

class Customer extends Clients {

    public Customer(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges + ", dateOfAgreement=" + dateOfAgreement.getTime() + ", email=" + email
                + ", id="
                + id + ", name=" + name + "]";
    }
}

class Business extends Clients {
    private final double GST_RATE = 18;

    public Business(int id, String name, String email, double charges) {
        super(id, name, email, charges);
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        double payment = findServicableDays(invoiceDate.getTime(), this.dateOfAgreement.getTime()) * charges;
        return payment + payment * .21;
    }

    public double getGst() {
        return this.GST_RATE;
    }

    @Override
    public String toString() {
        return "Business [GST_RATE=" + GST_RATE + ", charges=" + charges + ", dateOfAgreement="
                + dateOfAgreement.getTime()
                + ", email=" + email + ", id=" + id + ", name=" + name + "]";
    }

}

public class MyCompany {
    public static void main(String[] args) {

        Clients c1 = new Customer(101, "Gaurav", "xyz@email.com", 200);
        Clients c2 = new Customer(103, "Pankaj", "xyz@email.com", 300);

        Clients b1 = new Business(102, "Facebook", "xyz@email.com", 2000);
        Clients b2 = new Business(104, "Instagram", "xyz@email.com", 3000);

        List<Clients> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(c1);
        list.add(c2);
        list.forEach(System.out::println);
        List<Double> pendingPayments = new ArrayList<>();
        list.forEach(ele -> pendingPayments.add(ele.calculatePayment(new GregorianCalendar(2019, 5, 15))));
        pendingPayments.forEach(System.out::println);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).sendEmail(pendingPayments.get(i));
        }

        Collections.sort(list);
        list.forEach(System.out::println);

        Collections.sort(list, (a, b) -> (int) (a.getCharges() - b.getCharges()));

        list.forEach(System.out::println);

        Collections.sort(list,
                (a, b) -> (int) (a.dateOfAgreement.getTimeInMillis() - b.dateOfAgreement.getTimeInMillis()));

        list.forEach(System.out::println);

    }
}

0 replies

Shivani2145 · 2022-08-28T05:01:39Z

Shivani2145
Aug 28, 2022

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.List;

interface Client {
    double getCharges();
    double calculatePayment(GregorianCalendar invoiceDate);
    void sendEmail(double payment);
}

abstract class ServiceClient implements Client, Comparable<ServiceClient> {
int id;
String name;
String email;
double charges;
GregorianCalendar dateOfAgreement;

public int compareTo (ServiceClient other) {
    return this.id - other.id;
}
public double getCharges() {
    return charges;
}

public double calculate(GregorianCalendar invoiceDate) {
int date = invoiceDate.get(Calendar.DATE);
int agreementDate = dateOfAgreement.get(Calendar.DATE);
return(date-agreementDate)*getCharges();
}
public void sendEmail(double payment) {
    System.out.println("Pending Payment: " +payment);
}
}
class Customer extends ServiceClient {
    public Customer(int id,String name,String email,double charges,GregorianCalendar dateOfAgreement){
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;
    }

    @Override
    public String toString() {
        return "Customer [charges=" + charges +",dateOfAgreement" + dateOfAgreement.get(Calendar.DATE) + ",email="+ email +", id=" + id +",name=" + name +"]";
    }

    @Override
    public double calculatePayment(GregorianCalendar invoiceDate){
        return calculate(invoiceDate);
    }
}
class Business extends ServiceClient {
    double gstRate = 12;
    public Business(int id,String name,String email,double charges,GregorianCalendar dateOfAgreement){
        this.id = id;
        this.name = name;
        this.email = email;
        this.charges = charges;
        this.dateOfAgreement = dateOfAgreement;

    }
    
    @Override
    public double calculatePayment(GregorianCalendar invoiceDate) {
        return calculate(invoiceDate) * getGST();
    }
    double getGST(){
        return gstRate * calculate(new GregorianCalendar(2022,3,31))
    }
    @Override
    public String toString() {
        return "Business [gstRate=" + gstRate +", name=" + name +", email=" + email +", charges=" + charges +", dateOfAgreement=" +dateOfAgreement.get(Calendar.DATE) +"]";
    }

}

public class MyCompany {
    public static void main(String[] args) {
        ServiceClient c1 = new Customer(10,"Kiran","k@gmail.com",1000, new GregorianCalendar(2022,3,8));
        ServiceClient c2 = new Customer(5,"Kiya","ki@gmail.com",2000, new GregorianCalendar(2022,3,9));
        ServiceClient c3 = new Customer(2,"Rohan","r@gmail.com",2000,  new GregorianCalendar(2022,3,10));
        ServiceClient c4 = new Customer(12,"Sag","s@gmail.com",3000, new GregorianCalendar(2022,3,11));
        List<ServiceClient> clients = new ArrayList<>(Arrays.asList(c1, c2, c3, c4));
        double[] pendingPayments = new double[4];
        for (int i = 0; i < 4; i++) {
            pendingPayments[i] = clients.get(i).calculatePayment(new GregorianCalendar(2022,3,30));
        }
        System.out.println(Arrays.toString(pendingPayments));
        for(int i = 0; i<4; i++){
            clients.get(i).sendEmail(pendingPayments[i]);
        }
        System.out.println("Sort According to Id");
        Collections.sort(clients);
        clients.forEach(System.out::println);
        System.out.println("Sort According to charges");
        clients.sort((ServiceClient o1, ServiceClient o2)-> (int) (o2.getCharges()-o1.getCharges()));
        clients.forEach(System.out::println);
        System.out.println("Sort According to date of Agreement");
        clients.sort((ServiceClient o1, ServiceClient o2)-> (o1.dateOfAgreement.get(Calendar.DATE)-o2.dateOfAgreement.get(Calendar.DATE)));
        clients.forEach(System.out::println);
    }
}

0 replies

shriramram · 2023-09-28T03:56:02Z

shriramram
Sep 28, 2023

@akash-coded
Name - Dattatraya Rajaram Shriram
Description - Implemented number 50 assignment
Uploading assignment50.zip…

0 replies

Task - Collections - Sorting Collections and Loose Coupling #50

Uh oh!

Uh oh!

akash-coded Mar 7, 2022 Maintainer

Create an interface called Client which will have:

Create a class Customer which implements the interface Client and declares the following:

Create a class Business which implements the interface Client and declares the following:

In the driver class MyCompany :

Replies: 33 comments

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

akash-coded
Mar 7, 2022
Maintainer