class MinMax<T extends Comparable<T>>

Week 7: Enum, Generic Type, Streams, write to file, class diagram/07B. Generic Class MinMax????

@@ -0,0 +1,122 @@
+Write a generic class
+
+class MinMax<T extends Comparable<T>>
+...where the implementing type must implement the Comparable interface.
+
+The class has the following properties:
+1
+A constructor that takes a list as a parameter. The list contains elements of type T.
+2
+A method public T smallest(), which returns the smallest element in the list.
+3
+A method public T largest(), which returns the largest element in the list.
+4
+The comparison of list elements uses the services provided by the Comparable interface.
+
+Tip: Check out the Collections class API description - there are a couple of useful operations for finding the smallest or largest element...
+https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collections.html
+
+
+
+
+
+
+
+import java.util.Random;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Test {
+    public static void main(String[] args) {
+        final Random r = new Random();
+        
+        System.out.println("Testing the MinMax class...");
+
+        System.out.println("Testing with integers");
+        int n = -r.nextInt(200);
+        ArrayList<Integer> numbers = new ArrayList<>();
+
+        int count = r.nextInt(10) + 10;
+        for (int i = 0; i < count; i++) {
+            numbers.add(n);
+            n += r.nextInt(40);
+        }
+
+        Collections.shuffle(numbers, r);
+
+        System.out.println("List:" + numbers);
+        System.out.println("Creating object...");
+
+        MinMax<Integer> mm = new MinMax<>(numbers);
+        System.out.println("Object created!");
+
+        System.out.println("Smallest: " + mm.smallest());
+        System.out.println("Largest: " + mm.largest());
+
+        System.out.println("");
+
+        System.out.println("Testing with floating-point numbers");
+        double n2 = -r.nextInt(240);
+        ArrayList<Double> numbers2 = new ArrayList<>();
+
+        Double[] d = {0.0, 0.25, 0.5, 0.75};
+
+        count = r.nextInt(10) + 10;
+        for (int i = 0; i < count; i++) {
+            n2 += r.nextInt(40) + d[r.nextInt(d.length)];
+            numbers2.add(n2);
+        }
+
+        Collections.shuffle(numbers2, r);
+
+        System.out.println("List:" + numbers2);
+        System.out.println("Creating object...");
+
+        MinMax<Double> mm2 = new MinMax<>(numbers2);
+        System.out.println("Object created!");
+
+        System.out.println("Smallest: " + mm2.smallest());
+        System.out.println("Largest:" + mm2.largest());
+
+    }
+}
+
+
+
+
+//ADD
+class MinMax<T extends Comparable<T>> {
+    private ArrayList<T> list;
+    
+    public MinMax(ArrayList<T> list) {
+        this.list = list;
+    }
+    
+    public T smallest() {
+        return Collections.min(list);
+    }
+    
+    public T largest() {
+        return Collections.max(list);
+    }
+}
+
+
+
+
+
+Testing the MinMax class...
+Testing with integers
+List:[104, 197, 159, 178, 106, 164, 33, -20, 11, 47, 130, 209, 84, 107, 198, -51]
+Creating object...
+Object created!
+Smallest: -51
+Largest: 209
+
+Testing with floating-point numbers
+List:[207.5, 6.0, 151.0, 256.75, 115.5, 205.0, 292.75, 24.25, 180.25, 83.0, 74.0, 6.0, 41.0, 33.75, 231.0]
+Creating object...
+Object created!
+Smallest: 6.0
+Largest:292.75
+