interfacesExercise - Complete

quecoder · quecoder · commit a934dcc46d82 · 2024-01-10T12:20:11.000-06:00
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Case.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Case.java
@@ -6,6 +6,7 @@
 public class Case {
     private ArrayList<Flavor> flavors = new ArrayList<>();
     private ArrayList<Cone> cones = new ArrayList<>();
+    private ArrayList<Topping> toppings = new ArrayList<>(); // Add a field for toppings
 
     public Case(){
         Cone cone1 = new Cone("Waffle", 1.25, new ArrayList<>(Arrays.asList( "gluten")));
@@ -37,11 +38,19 @@ public ArrayList<Cone> getCones() {
         return cones;
     }
 
+    public ArrayList<Topping> getToppings() { // Getter method for toppings
+        return toppings;
+    }
+
     public void setFlavors(ArrayList<Flavor> flavors) {
         this.flavors = flavors;
     }
 
     public void setCones(ArrayList<Cone> cones) {
         this.cones = cones;
     }
-}
+
+    public void addTopping(Topping topping) {
+        toppings.add(topping);
+    }
+}
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/ConeComparator.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/ConeComparator.java
@@ -0,0 +1,16 @@
+package org.launchcode;
+
+import java.util.Comparator;
+
+public class ConeComparator implements Comparator<Cone> {
+    @Override
+    public int compare(Cone cone1, Cone cone2) {
+        if (cone1.getCost() < cone2.getCost()) {
+            return -1; // Return a negative integer if cone1 is cheaper.
+        } else if (cone1.getCost() > cone2.getCost()) {
+            return 1; // Return a positive integer if cone1 is more expensive.
+        } else {
+            return 0; // Return 0 if both cones have the same cost.
+        }
+    }
+}
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/FlavorComparator.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/FlavorComparator.java
@@ -0,0 +1,13 @@
+package org.launchcode;
+import java.util.Comparator;
+
+public class FlavorComparator implements Comparator<Flavor> {
+    @Override
+    public int compare(Flavor flavor1, Flavor flavor2) {
+        int allergenCount1 = flavor1.getAllergens().size();
+        int allergenCount2 = flavor2.getAllergens().size();
+
+        // Sort in descending order (highest to lowest allergen count)
+        return Integer.compare(allergenCount2, allergenCount1);
+    }
+}
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Main.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Main.java
@@ -1,17 +1,49 @@
 package org.launchcode;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 
 public class Main {
     public static void main(String[] args) {
         Case menu = new Case();
         ArrayList<Flavor> flavors = menu.getFlavors();
         ArrayList<Cone> cones = menu.getCones();
 
-        // TODO: Use a Comparator class to sort the 'flavors' array alphabetically by the 'name' field.
+        // Add some toppings to the Case
+        Topping topping1 = new Topping("Chocolate Chips", 0.75, new ArrayList<>());
+        Topping topping2 = new Topping("Sprinkles", 0.50, new ArrayList<>());
+        Topping topping3 = new Topping("Caramel Drizzle", 1.00, new ArrayList<>());
+        menu.addTopping(topping1);
+        menu.addTopping(topping2);
+        menu.addTopping(topping3);
 
+        // TODO: Use a Comparator class to sort the 'flavors' array alphabetically by the 'name' field.
+        flavors.sort(new FlavorComparator());
         // TODO: Use a Comparator class to sort the 'cones' array in increasing order by the 'cost' field.
-
+        cones.sort(new ConeComparator());
         // TODO: Print the 'flavors' and 'cones' lists (in a clear manner) to verify the sorting.
+        System.out.println("\nFlavors:");
+        for (Flavor flavor : flavors) {
+            System.out.println(flavor.getName());
+        }
+
+        // Print the sorted 'cones' list
+        System.out.println("\nCones:");
+        for (Cone cone : cones) {
+            String formattedCost = String.format("%.2f", cone.getCost());
+            System.out.println(cone.getName() + ": $" + formattedCost);
+        }
+
+        // Sort the toppings by the number of allergens (ascending order)
+        ArrayList<Topping> toppings = menu.getToppings();
+        toppings.sort(new ToppingComparator());
+
+        // Print the sorted toppings list
+        System.out.println("\nToppings:");
+        for (Topping topping : toppings) {
+            String formattedCost = String.format("%.2f", topping.getCost());
+            System.out.println(topping.getName() + ": $" + formattedCost + " (Allergen Count: " + topping.getAllergens().size() + ")");
+        }
     }
 }
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Topping.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/Topping.java
@@ -0,0 +1,9 @@
+package org.launchcode;
+
+import java.util.ArrayList;
+
+public class Topping extends Ingredient {
+    public Topping(String aName, double aCost, ArrayList<String> someAllergens) {
+        super(aName, aCost, someAllergens);
+    }
+}
diff --git a/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/ToppingComparator.java b/interfaces/exercises/ice-cream-exercises/src/main/java/org/launchcode/ToppingComparator.java
@@ -0,0 +1,13 @@
+package org.launchcode;
+import java.util.Comparator;
+
+public class ToppingComparator implements Comparator<Topping> {
+    @Override
+    public int compare(Topping topping1, Topping topping2) {
+        int allergenCount1 = topping1.getAllergens().size();
+        int allergenCount2 = topping2.getAllergens().size();
+
+        // Sort in ascending order (from lowest to highest allergen count)
+        return Integer.compare(allergenCount1, allergenCount2);
+    }
+}
