Lambda - mapping and streaming only part of a list

[Tom Worden]

I cannot seem to figure out these two problems. I need to have the list print out but only display the PartDescription and Quantity for the first problem and the next print out the PartDescription and Amount (product of Quantity * Price), I think I may need to use a binary operator. I do not know how to get started on this. Any help would be appreciated. My code is below.

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ProcessInvoices {

    public static void main(String[] args) {
        // initialize array of Invoices
        Invoice[] invoice = {
            new Invoice(83, "Electric sander", 7, 57.98),
            new Invoice(24, "Power saw", 18, 99.99),
            new Invoice(7, "Sledge hammer", 11, 21.50),
            new Invoice(77, "Hammer", 76, 11.99),
            new Invoice(39, "Lawn Mower", 3, 79.50),
            new Invoice(68, "Screwdriver", 106, 6.99),
            new Invoice(56, "Jig saw", 21, 11.00),
            new Invoice(3, "Wrench", 34, 7.50)
        };
                
        // get List view of the Invoices
        List<Invoice> list = Arrays.asList(invoice);

        // Functions for getting elements from Invoice
        Function<Invoice, String> byPartDescription = Invoice::getPartDescription;
        Function<Invoice, Double> byPrice = Invoice::getPrice;
        Function<Invoice, Integer> byQuantity = Invoice::getQuantity;

        // Comparator for comparing Invoices by Part Description
        Comparator<Invoice> PartDescription
                = Comparator.comparing(byPartDescription);

        // Comparator for comparing Invoices by Price
        Comparator<Invoice> Price
                = Comparator.comparing(byPrice);

        // Comparator for comparing Invoices by Quantity
        Comparator<Invoice> Quantity
                = Comparator.comparing(byQuantity);

        // Comparator for comparing Invoices by Amount
        Comparator<Invoice> Amount
                = Comparator.comparing(byAmount);
        
         // sort by Quantity and map Part Description and Amount 
        System.out.printf("%nInvoices mapped to description and amount:%n");
        list.stream()
                .sorted(Quantity)
                .map(Invoice::getQuantity)
                .forEach(System.out::println);

                // sort by Quantity and map Part Description and Quantity 
        System.out.printf("%nInvoices mapped to description and amount:%n");
        list.stream()
                .sorted(Quantity)
                .map(Invoice::getQuantity)
                .forEach(System.out::println);
        
    }
}

____________________________________________________________

public class Invoice 
{
   private final int partNumber; 
   private final String partDescription;
   private int quantity;
   private double price;

   // constructor
   public Invoice(int partNumber, String partDescription, int quantity,
      double price)
   {
      if (quantity < 0) // validate quantity
         throw new IllegalArgumentException("Quantity must be >= 0");

      if (price < 0.0) // validate price
         throw new IllegalArgumentException(
            "Price per item must be >= 0");

      this.partNumber = partNumber;
      this.partDescription = partDescription;
      this.quantity = quantity;
      this.price = price;
   } // end constructor

   // get part number
   public int getPartNumber()
   {
      return partNumber; // should validate
   } 

   // get description
   public String getPartDescription()
   {
      return partDescription;
   } 

   // set quantity
   public void setQuantity(int quantity)
   {
      if (quantity < 0) // validate quantity
         throw new IllegalArgumentException("Quantity must be >= 0");

      this.quantity = quantity;
   } 

   // get quantity
   public int getQuantity()
   {
      return quantity;
   }

   // set price per item
   public void setPrice(double price)
   {
      if (price < 0.0) // validate price
         throw new IllegalArgumentException(
            "Price per item must be >= 0");

      this.price = price;
   } 

   // get price per item
   public double getPrice()
   {
      return price;
   } 

   // return String representation of Invoice object
   @Override
   public String toString()
   {
      return String.format(
         "Part #: %-2d  Description: %-15s  Quantity: %-4d  Price: $%,6.2f", 
         getPartNumber(), getPartDescription(), 
         getQuantity(), getPrice());
   } 
} // end class Invoice

[edited to fix code tags]

[Jeanne Boyarsky]

Tom,
Welcome to CodeRanch!

For the first one, it sounds like you want to display two fields. You have two choices for this.

Replace the method reference in map() with i -> i.getPartDescription() + " " + i.getQuantity()

Add a method to Invoice that returns a String with what you want to display

For the second one, you can you a similar technique.

Note that the code you posted does not compile. I think you forgot to remove Comparator<Invoice> _Amount = Comparator.comparing(byAmount);

[Tom Worden]

Thank you.

[Pierre-Yves Saumont]

Hi Tom,

The answer given by Jeanne is perfectly correct, and it might be what you are looking for. However, Your code is having design problems. So minimal changes will not really fix it. The major problem is about your model. Your are dealing with invoices. Invoices are made of invoice lines, each line referencing a part and a quantity. So you should start with creating the right model for your problem.

A Part may be modeled as:

public class Part {

  public final int partNumber;
  public final String name;
  public final double price;

  private Part(int partNumber, String name, double price) {
    this.partNumber = partNumber;
    this.name = name;
    this.price = price;
  }

  public String getName() {
    return name;
  }

  public double getPrice() {
    return price;
  }

  public static Part product(int partNumber, String name, double price) {
    // add validation here possibly throwing exceptions
    return new Part(partNumber, name, price);
  }
}

Note that validation should not be made in the constructor. Constructors should never show exceptions. Also note that the product method could, instead of throwing exceptions, return a special kind of Optional that might contain the exception, letting the choice to the caller to either throw it or do something else. Java 8 does not offer such a class, but I describe one in my book, Functional Programming in Java.

Next you need an InvoiceLine class to represent each line in an invoice. An InvoiceLine is constructed with a reference to a part and a quantity. This class will also be responsible for calculating the total price for the line, and for providing the comparators:

import java.util.Comparator;

public class InvoiceLine {

  private final Part part;
  private final int quantity;
  private final double totaPrice;

  private InvoiceLine(Part part, int quantity, double totaPrice) {
    this.part = part;
    this.quantity = quantity;
    this.totaPrice = totaPrice;
  }

  public Part getPart() {
    return part;
  }

  public int getQuantity() {
    return quantity;
  }

  public double getTotaPrice() {
    return totaPrice;
  }

  public String getProductName() {
    return part.getName();
  }

  public double getProductPrice() {
    return part.getPrice();
  }

  public String getDescriptionQuantity() {
    return String.format("%s %s", part.getName(), quantity);
  }

  public String getDescriptionTotalPrice() {
    return String.format("%s %s", part.getName(), totaPrice);
  }

  public static InvoiceLine invoiceLine(Part part, int quantity) {
    // add validation here
    return new InvoiceLine(part, quantity, quantity * part.price);
  }

  public static Comparator<InvoiceLine> productComparator = Comparator.comparing(InvoiceLine::getProductName);

  public static Comparator<InvoiceLine> priceComparator = Comparator.comparing(InvoiceLine::getProductPrice);

  public static Comparator<InvoiceLine> quantityComparator = Comparator.comparing(InvoiceLine::getQuantity);
}

Note that you should NEVER use double to represent prices, since prices are fix decimal value while double are floating decimals. But this is another story.

Then you need an Invoice class to represent each invoice:

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

public class Invoice {

  private final List<InvoiceLine> lines = new ArrayList<>();

  private Invoice() {
    // add invoice related stuff like invoice number, customer reference, date, etc.
  }

  public List<InvoiceLine> getLines() {
    return lines;
  }

  public static Invoice invoice(InvoiceLine... lines) {
    // add invoice related stuff like invoice number, customer reference, date, etc.
    Invoice invoice = new Invoice();
    Collections.addAll(invoice.lines, lines);
    return invoice;
  }
}

Now, you may write the ProcessInvoices program as:

public class ProcessInvoices {

  public static void main(String[] args) {
    Invoice invoice = invoice(
        invoiceLine(product(83, "Electric sander", 57.98), 7),
        invoiceLine(product(24, "Power saw", 99.99), 18),
        invoiceLine(product(7, "Sledge hammer", 21.50), 11),
        invoiceLine(product(77, "Hammer", 11.99), 76),
        invoiceLine(product(39, "Lawn Mower", 79.50), 3),
        invoiceLine(product(68, "Screwdriver", 6.99), 106),
        invoiceLine(product(56, "Jig saw", 11.00), 21),
        invoiceLine(product(3, "Wrench", 7.50), 34));
    
    System.out.printf("%nInvoices mapped to description and quantity:%n");
    invoice.getLines().stream()
        .sorted(InvoiceLine.quantityComparator)
        .map(InvoiceLine::getDescriptionQuantity)
        .forEach(System.out::println);

    System.out.printf("%nInvoices mapped to description and amount:%n");
    invoice.getLines().stream()
        .sorted(InvoiceLine.quantityComparator)
        .map(InvoiceLine::getDescriptionTotalPrice)
        .forEach(System.out::println);
  }
}

Note that there is no need to write something like:

Function<Invoice, String> byPartDescription = Invoice::getPartDescription;

Doing this could lead the compiler to create unnecessary object. In general, you should not declare explicit object to wrap functions. Lambdas and method references free us from writing anonymous classes, but it also free the compiler (and/or the JVM) to create useless objects.

However, it might sometimes be interesting to create such objects in order to eliminate duplicate code. For example, you could replace:

    System.out.printf("%nInvoices mapped to description and quantity:%n");
    invoice.getLines().stream()
        .sorted(InvoiceLine.quantityComparator)
        .map(InvoiceLine::getDescriptionQuantity)
        .forEach(System.out::println);

    System.out.printf("%nInvoices mapped to description and amount:%n");
    invoice.getLines().stream()
        .sorted(InvoiceLine.quantityComparator)
        .map(InvoiceLine::getDescriptionTotalPrice)
        .forEach(System.out::println);

with:

    ...
    printSortedBy(invoice, InvoiceLine::getDescriptionQuantity, "Invoices mapped to description and quantity");
    printSortedBy(invoice, InvoiceLine::getDescriptionTotalPrice, "Invoices mapped to description and amount");

  }

  private static void printSortedBy(Invoice invoice, Function<InvoiceLine, String> f, String title) {
    System.out.printf("%n" + title + ":%n");
    invoice.getLines().stream()
        .sorted(InvoiceLine.quantityComparator)
        .map(f)
        .forEach(System.out::println);
  }

Not sure if the compiler or the JVM are able to optimize this code by using a method reference for the map parameter, but even if not, this version is better because it reduces duplication.