Sort integers and strings using the same java class (Bubble Sort)

Question

How do I amend my code for bubble sorting integers so I can re-use it for strings too? Or do I need to create a completely new class for sorting strings exclusively. Thanks!

MAIN CLASS:

public class BubbleSortTest {

    public static void main(String[] args) {
        Integer[] integers = {25, 15, 45, 5, 40, 50, 10, 20, 35, 30};
        ArrayUtility.display(integers);
        BubbleSort.sort(integers);
        ArrayUtility.display(integers);

        String[] strings = {"def", "efg", "bcd", "abc", "fgh", "cde", null};
        ArrayUtility.display(strings);
        BubbleSort.sort(strings);
        ArrayUtility.display(strings);
    }
}

SORT CLASS:

public class BubbleSort {

    public static void sort(Integer[] numbers) {
        Integer temp;

        for (Integer i = 0; i < numbers.length; i++) {
            for (Integer j = 1; j < (numbers.length) - i; j++) {
                if (numbers[j - 1] > numbers[j]) {

                    //SWAPPING ELEMENTS
                    temp = numbers[j - 1];
                    numbers[j - 1] = numbers[j];
                    numbers[j] = temp;
                }
            }
        }
    }
}

google 'Java generics', or, pass type 'Comparable' or similar — Stultuske
– Stultuske, Commented Nov 16, 2017 at 10:38
Look at how it's done in e.g. TreeSet. (Generics + Comparator) — JimmyB
– JimmyB, Commented Nov 16, 2017 at 10:54

slim · Accepted Answer · 2017-11-16 13:36:12Z

1

You can use Generic Types:

Something like this could be valid:

public static <E extends Comparable<E>> void bubbleSort(E[] unsorted) {
        for(int iter =1; iter< unsorted.length; iter++){
            for(int inner = 0; inner < (unsorted.length - iter); inner ++){
                if(unsorted[inner].compareTo(unsorted[inner+1]) > 0){
                    E tmp = unsorted[inner];
                    unsorted[inner] = unsorted[inner + 1];
                    unsorted[inner + 1] = tmp;
                }                
            }
        }
    }

What this means is, the method works with an array of any type, as long as it implements Comparable. Whatever type that is, will be used as E throughout the method. Since the compiler knows that E is a Comparable, the compiler knows that objects of this type have .compareTo(...).

edited Nov 16, 2017 at 13:36

slim

41.5k14 gold badges101 silver badges131 bronze badges

answered Nov 16, 2017 at 10:42

canillas

4343 silver badges14 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Joop Eggen Over a year ago

<E extends Comparable<E>> and the cast is not needed and all safe.

slim Over a year ago

I took the liberty of editing to use what @JoopEggen correctly suggested.

DodgyCodeException Over a year ago

Very good answer, but I wouldn't call the argument 'unsorted' because it doesn't stay unsorted for long.

Collectives™ on Stack Overflow

Sort integers and strings using the same java class (Bubble Sort)

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related