Fixed 'Generics' issue of bubble sort since Sort class should accept

Rajkumar · Rajkumar · commit 56b374ce9fba · 2019-12-08T01:03:31.000+05:30
only comparable datatype rather than just restricting sort method
diff --git a/src/main/java/com/sorts/BubbleSort.java b/src/main/java/com/sorts/BubbleSort.java
@@ -2,7 +2,7 @@
 
 import com.types.Sort;
 
-public class BubbleSort<T> implements Sort<T> {
+public class BubbleSort<T extends Comparable<T>> implements Sort<T> {
   /**
    * This method implements the Generic Bubble Sort
    *
@@ -11,7 +11,7 @@ public class BubbleSort<T> implements Sort<T> {
    **/
 
   @Override
-  public <T extends Comparable<T>> T[] sort(T[] array) {
+  public T[] sort(T[] array) {
     int last = array.length;
     //Sorting
     boolean swap;
diff --git a/src/main/java/com/types/DataStructure.java b/src/main/java/com/types/DataStructure.java
@@ -3,7 +3,7 @@
 import java.util.Iterator;
 
 /**
- * This interface is to define bacis functionality expected out of any implementation class
+ * This interface is to define basic functionality expected out of any implementation class
  * Since this is a data structure it should have the flexibility to contain any kind of object hence it has been made generic
  * Any implementation class need not to be thread safe or it could be depending on the implementation class how does it want to behave.
  *
diff --git a/src/main/java/com/types/Sort.java b/src/main/java/com/types/Sort.java
@@ -1,7 +1,7 @@
 package com.types;
 
 @FunctionalInterface
-public interface Sort<T> {
+public interface Sort<T extends Comparable<T>> {
 
-    <T extends Comparable<T>> T[] sort(T[] array);
+    T[] sort(T[] array);
 }
diff --git a/src/test/java/com/sorts/BubbleSortTest.java b/src/test/java/com/sorts/BubbleSortTest.java
@@ -6,17 +6,32 @@
 class BubbleSortTest {
 
     @Test
-    void bubbleSortTest() {
-        BubbleSort bubbleSort = new BubbleSort();
+    void bubbleSortTestIntegers() {
+        BubbleSort<Integer> bubbleSort = new BubbleSort<>();
 
-        Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
-        Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        Integer[] unsortedInt = {0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
+        Integer[] sortedInt = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         Assertions.assertArrayEquals(sortedInt, bubbleSort.sort(unsortedInt));
 
-        Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
-        Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
+    }
+
+    @Test
+    void bubbleSortTestCharacters() {
+        BubbleSort<Character> bubbleSort = new BubbleSort<>();
+
+        Character[] unsortedChar = {'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
+        Character[] sortedChar = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
         Assertions.assertArrayEquals(sortedChar, bubbleSort.sort(unsortedChar));
 
     }
 
+    @Test
+    void bubbleSortTestStrings() {
+        BubbleSort<String> bubbleSort = new BubbleSort<>();
+
+        String[] unsortedChar = {"abc", "adc", "bcd", "abb", "abc", "acb"};
+        String[] sortedChar = {"abb", "abc", "abc", "acb", "adc", "bcd"};
+        Assertions.assertArrayEquals(sortedChar, bubbleSort.sort(unsortedChar));
+
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`import java.util.Iterator;`
`4`	`4`
`5`	`5`	`/**`
`6`		`- * This interface is to define bacis functionality expected out of any implementation class`
	`6`	`+ * This interface is to define basic functionality expected out of any implementation class`
`7`	`7`	`* Since this is a data structure it should have the flexibility to contain any kind of object hence it has been made generic`
`8`	`8`	`* Any implementation class need not to be thread safe or it could be depending on the implementation class how does it want to behave.`
`9`	`9`	`*`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`package com.types;`
`2`	`2`
`3`	`3`	`@FunctionalInterface`
`4`		`-public interface Sort<T> {`
	`4`	`+public interface Sort<T extends Comparable<T>> {`
`5`	`5`
`6`		`- <T extends Comparable<T>> T[] sort(T[] array);`
	`6`	`+ T[] sort(T[] array);`
`7`	`7`	`}`