Core Java

# Bubble Sort Java algorithm – Code Example

The Bubble sort algorithm in Java is one of the simplest sorting algorithms. In this article, we will talk about its function and its implementation in Java. The Bubble sort algorithm sometimes is referred as sinking sort, works as continuously iterating and swapping the items adjacent to each other in an array.

We will first discuss the Java Bubble sort algorithm with some basic examples and finally, we will develop its implementation in Java.

## 1. Bubble Sort Java Algorithm

Consider a list of items in an array that needs to be sorted. The Bubble sort starts by keeping a cursor at the left-most item of the array, let’s say, at position 0. It compares it with an item adjacent to it at a position 0+1. If the item at position 0 is greater, it swaps these two elements, else it does nothing. The cursor then moves to the next position in the array. It moves and compares the two adjacent items in the array until it reaches the right end of the array when the greatest item in the array is placed in its sorted position N-1. After the first pass, we would made N-1 comparison and swaps between 0 to N-1.

The cursor then starts with the left most item of the array and repeats the process of comparing and swapping until the item reaches its proper sorted position. This time it stops at position N-2. This is because the last item at N-1 is already sorted.

It continues this process until all the items in the array are placed in their sorted order. The three simple steps for the Java Bubble sort are:

1. Compare two adjacent items in the array.
2. If the one on the left is greater, swap them.
3. Move the cursor one position right.

Repeat the steps until all the items are placed in their sorted place.

In the above figure, the items in red are the ones that get compared. If the item at the left is greater than the right one, it gets swapped, else nothing happens. The cursor moves one position at right and the next two adjacent items get compared and so on. At the end, the greater item is set to its final sorted position. On the second pass, the second greatest item will  be in its sorted position. On the third pass, the third greatest item will be in its sorted position etc…

BubblesortExample.java

 01020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364 ` ``package` `com.javacodegeeks.sorting.bubblesort;` `public` `class` `BubblesortExample {` `    ``private` `static` `int` `[]a;``    ``public` `static` `void` `main(String[] args) {``        ``// gets random generated array``        ``a = getArray();``        ``// prints the array``        ``printArray();``        ``// sorts the array``        ``sort();` `        ``System.out.println();``        ``// prints the resulted array``        ``printArray();``    ``}` `    ``// internally calls to bubbleSort() ``    ``public` `static` `void` `sort(){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;` `        ``bubbleSort(left,right);``    ``}` `    ``private` `static` `void` `bubbleSort(``int` `left,``int` `right){``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j a[j+``1``]){``                    ``swap(j, j+``1``);``                ``}``            ``}``        ``}``    ``}` `    ``// This method is used to swap the values between the two given index``    ``public` `static` `void` `swap(``int` `left,``int` `right){``        ``int` `temp = a[left];``        ``a[left] = a[right];``        ``a[right] = temp;``    ``}` `    ``public` `static` `void` `printArray(){``        ``for``(``int` `i : a){``            ``System.out.print(i+``" "``);``        ``}``    ``}` `    ``public` `static` `int``[] getArray(){``        ``int` `size=``10``;``        ``int` `[]array = ``new` `int``[size];``        ``int` `item = ``0``;``        ``for``(``int` `i=``0``;i

If we run the above code, we will have the following results:

 12 `30 67 8 13 35 10 25 85 39 58 ``8 10 13 25 30 35 39 58 67 85 `

Let’s discuss the above code.

The above snippet can be used to sort an array of integers using the Java Bubble sort. The `sort()` method calls the `bubbleSort()` internally and passes two parameters, the left and the right indexes of the array to be sorted. The right parameter sets the outer loop, which controls the limit of the inner loop. The outer loop moves from right most position of the array towards left. With each pass it decrements one position towards left. Since, after each pass the items in the indexes greater than the variable `i` of the outer loop are already sorted, they are no longer involved in the algorithm again.

The inner loop runs from `0` to the limit set by the outer loop variable `i`. It compares the two adjacent items, and if the left item is greater than the right item, they get swapped, else nothing happens. The loop then increments to one and the same steps of comparing and swapping are repeated until it reaches the end.

Let’s have a deeper look into the `bubbleSort()` method.

`for(int i=right;i>1;i--)`: The outer loop runs from the right to the left of the array and controls the inner loop. It starts from the right most item of the array at position N-1 and decrements by one in each pass.

`for(int j=0;j<i;j++)`: The inner loop runs from 0th position to i-1. The items at positions greater than the variable i are already sorted and not included in the loop.

`if(a[j] > a[j+1])`: This line of code in the inner loop compares the two adjacent items at position j and j+1. The condition is true, if the left item at j is greater than the item at j+1.

`swap(j, j+1)`: If the previous condition evaluates to true, then the items at position j and j+1 gets swapped.

The process continues until the whole array gets sorted.

### 1.1 Efficiency of the Bubble sort

The Bubble sort is the simplest sorting algorithm. But it is also the slowest of all. Let’s have a look about its efficiency. Let’s have an array of size 10 to be sorted.

In the first pass of the loop it makes 9 comparisons, and with the second pass it makes 8 comparisons, and so on, down to one comparison on the last pass. So for 10 items, it makes:

9+8+7+6+5+4+3+2+1 = 45

In general, (N-1)+(N-2)+(N-3)…+1 = N*(N-1)/2. Comparison: N^2/2

Since, there would be fewer swaps only if required, so at random data there would be half of swaps i.e. N^2/4. Both swaps and comparisons are proportional to N^2. So, we can say the Bubble sort runs in O(N^2) time.

This can also be seen by the two nested loops. The outer loop executes N times and the inner loop executes N times for each outer loop’s cycle. This becomes N*N i.e. N^2.

## 2. Bubble sort in descending order

So far, we have sort an array in ascending order, i.e. from the smallest item to the largest item. But by making a small change in the algorithm, we can sort an array in descending order, i.e. from the largest item to the smallest item.

BubblesortDescendingExample.java

 01020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364 `package` `com.javacodegeeks.sorting.bubblesort;` `public` `class` `BubblesortDescendingExample {` `    ``private` `static` `int` `[]a;``    ``public` `static` `void` `main(String[] args) {``        ``// gets random generated array``        ``a = getArray();``        ``// prints the array``        ``printArray();``        ``// sorts the array``        ``sort();``        ` `        ``System.out.println();``        ``// prints the resulted array``        ``printArray();``    ``}``    ` `    ``// internally calls to bubbleSort() ``    ``public` `static` `void` `sort(){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;``        ` `        ``bubbleSort(left,right);``    ``}``    ` `    ``private` `static` `void` `bubbleSort(``int` `left,``int` `right){``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j

If we run the above code, we will have the following results:

 12 `51 85 34 1 31 93 15 75 39 27 ``93 85 75 51 39 34 31 27 15 1 `

In the above example, we have Bubble sort the given array in a descending order. By making a small change in the program, we have sorted the array in descending order, i.e. items get sorted in an order starts from the largest item at the first index of the array and goes on to the smallest item at the last position in the array.

`if(a[j] < a[j+1])`: The only change we have made is in the comparison of the two adjacent items in the array. This time the items would be swapped, if the left item is smaller than the right item. By making this change, the smaller items swapped towards the right of the array instead of the greater items (as shown in the previous example). It continues the same process until the loop ends, which results in the larger items to start from the left of the array. The largest item comes at the first position of the array, then the next item, smaller than the item at the first position, and so on, until the last position which contains the smallest item in the array.

The rest of the code remains the same.

## 3. Bubble sort Objects

So far, we have sort an array of integers. In this section, we will see how to sort objects of any type using the Bubble sort. We will do this, by creating a sorting utility class, which contains static methods that provides different variations to sort a given array of any class. The utility class contains overloading `sort()`, in order to provide a variety of sorting  options to the given array.

SortingUtility.java

 001002003004005006007008009010011012013014015016017018019020021022023024025026027028029030031032033034035036037038039040041042043044045046047048049050051052053054055056057058059060061062063064065066067068069070071072073074075076077078079080081082083084085086087088089090091092093094095096097098099100101102103104105106107108109110111112113114115116117118119120121122123 ` `  `package` `com.javacodegeeks.sorting.utility;` `import` `java.util.Comparator;``/*`` ``* The utility class which contains static methods.`` ``* */``public` `class` `SortingUtility {`  `    ``// order constants which tells at what order the array should be sort``    ``public` `static` `final` `int` `ASC_ORDER = ``1``;``    ``public` `static` `final` `int` `DESC_ORDER = ``2``;` `    ``/* We want this class as a utility class that contains only static methods.``     ``* So, avoiding any creation of an object of this class by keeping its``     ``* constructor as private and also throwing an AssertionError to avoid ``     ``* any accidently creation of an object within the class. ``     ``* */``    ``private` `SortingUtility(){``        ``throw` `new` `AssertionError();``    ``}` `    ``public` `static``> ``void` `sort(T []a){``        ``bubbleSortInAscOrder(a);``    ``}` `    ``public` `static`` ``void` `sort(T []a, Comparatorcomparator){``        ``bubbleSortInAscOrder(a,comparator);``    ``}` `    ``public` `static``> ``void` `sort(T []a,``int` `order){` `        ``if``(order == ASC_ORDER){``            ``bubbleSortInAscOrder(a);``        ``}``else` `if``(order == DESC_ORDER){``            ``bubbleSortInDescOrder(a);``        ``}``else``{``            ``throw` `new` `UnsupportedOperationException(``"The order you specified is not supported."``);``        ``}``    ``}` `    ``public` `static`` ``void` `sort(T []a,``int` `order, Comparatorcomparator){` `        ``if``(order == ASC_ORDER){``            ``bubbleSortInAscOrder(a,comparator);``        ``}``else` `if``(order == DESC_ORDER){``            ``bubbleSortInDescOrder(a,comparator);``        ``}``else``{``            ``throw` `new` `UnsupportedOperationException(``"The order you specified is not supported."``);``        ``}``    ``}` `    ``private` `static``> ``void` `bubbleSortInAscOrder(T []a){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j)a[j]).compareTo(a[j+``1``]) > ``0``){``                    ``swap(a,j, j+``1``);``                ``}``            ``}``        ``}``    ``}` `    ``private` `static``> ``void` `bubbleSortInDescOrder(T []a){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j)a[j]).compareTo(a[j+``1``]) < ``0``){``                    ``swap(a,j, j+``1``);``                ``}``            ``}``        ``}``    ``}` `    ``private` `static`` ``void` `bubbleSortInAscOrder(T []a,Comparatorcomparator){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j ``0``){``                    ``swap(a,j, j+``1``);``                ``}``            ``}``        ``}` `    ``}` `    ``private` `static`` ``void` `bubbleSortInDescOrder(T []a,Comparatorcomparator){``        ``int` `left = ``0``;``        ``int` `right = a.length-``1``;``        ``// the outer loop, runs from right to left``        ``for``(``int` `i=right;i>``1``;i--){``            ``// the inner loops, runs from left to the right, limited by the outer loop``            ``for``(``int` `j=left;j

The above class `SortingUtility` is a utility class which contains static methods used to sort a given array of a type `T`. The class contains overloaded  `sort()` methods. These `sort()` methods internally call the `bubbleSort()` method to sort the given array.

`public static final int ASC_ORDER = 1;` : The constant field is used as a flag, if set, the sorting would be done in ascending order.

`public static final int DESC_ORDER = 2;` : The constant field is used as a flag, if set, the sorting would be done in descending order.

`public static<T extends Comparable<T>> void sort(T []a)`: This method is used to sort a given array of a type `T`. The class `T` should implement the `Comparable` interface and provide an implementation of the overridden `comparTo()` method, otherwise, it will throw a `ClassCastException`. Internally, it calls  the `bubbleSortInAscOrder()` method which sorts the array in ascending order.

`public static<T> void sort(T []a, Comparator<? super T>comparator)`: This method is used to sort a given array of a type `T` and it also takes an instance of a `Comparator` interface. The `Comparator` provides rules to compare the object of the type `T`. Internally, it calls the `bubbleSortInAscOrder()` method which sorts the array in ascending order.

`public static<T extends Comparable<T>> void sort(T []a,int order)`: This method is used to sort a given array of a type `T` which should implement the `Comparable` interface. It also contains an order as its parameter which is used to provide the order in which sorting needs to be done. If the provided value to the order doesn’t match with the flags set in the method, it will throw an `UnsupportedOperationException`.

`public static<T> void sort(T []a,int order, Comparator<? super T>comparator)`: Works same as the previous discussed method. It also takes an instance of a `Comparator` interface which provides rules to compare the object of the type `T`.

All these `sort()` methods, perform the same functionality. There are two modes of Bubble Sort methods used in the above class.

`bubbleSortInAscOrder()`: Used to Bubble sort a given array in ascending order.
`bubbleSortInDescOrder()`: Used to Bubble sort a given array in descending order.

Both of the Bubble sort methods are in two overloaded forms one of which only has an array of type `T` as its parameter. This method uses the `Comparable` interface which is implemented by the class `T` to compare the objects of the type `T`. The other method passes the `Comparator` object which defines the rule of comparison between the objects of the type `T`.

Employee.java

 01020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849 `package` `com.javacodegeeks.entity;` `public` `class` `Employee ``implements` `Comparable{` `    ``private` `String firstName;``    ``private` `String lastName;``    ``private` `int` `emplyeeCode;``    ` `    ``public` `Employee(String fistName,String lastName,``int` `emplyeeCode){``        ``this``.firstName = fistName;``        ``this``.lastName = lastName;``        ``this``.emplyeeCode = emplyeeCode;``    ``}``    ` `    ``public` `String getFirstName() {``        ``return` `firstName;``    ``}``    ``public` `void` `setFirstName(String firstName) {``        ``this``.firstName = firstName;``    ``}``    ``public` `String getLastName() {``        ``return` `lastName;``    ``}``    ``public` `void` `setLastName(String lastName) {``        ``this``.lastName = lastName;``    ``}``    ``public` `int` `getEmplyeeCode() {``        ``return` `emplyeeCode;``    ``}` `    ``public` `void` `setEmplyeeCode(``int` `emplyeeCode) {``        ``this``.emplyeeCode = emplyeeCode;``    ``}` `    ``public` `String toString(){``        ``return` `"Employee Code: "``+getEmplyeeCode()+``", Name:"``+getFirstName()+``" "``+getLastName();``    ``}` `    ``public` `int` `compareTo(Employee o) {``        ``Employee e = (Employee)o;``        ``if``(``this``.emplyeeCode > e.getEmplyeeCode())``            ``return` `1``;``        ``if``(``this``.emplyeeCode < e.getEmplyeeCode())``            ``return` `-``1``;``        ``if``(``this``.emplyeeCode == e.getEmplyeeCode())``            ``return` `0``;``        ``return` `0``;``    ``}``}`

We have created an `Employee` class which implements the `Comparable` interface and overrides the `compareTo()` method. The comparison between the `Employee` objects is defined by comparing the `employeeCode` property of the `Employee` objects. The `comparTo()` method returns an integer, which tells whether the current `employeeCode` is greater than, or smaller than or equal to the compared `employeeCode`. It returns 1, if the current `employeeCode` is greater than the compared `employeeCode`, -1 if, the current `employeeCode` is smaller than the compared `employeeCode`, else it returns 0 if both are equal. Since, the `employeeCode` is of type integer, we have compared it using the simple integer comparison operators.

EmployeeFirstNameComparatorImpl.java

 01020304050607080910111213141516171819 ` ``package` `com.javacodegeeks.entity;` `import` `java.util.Comparator;` `public` `class` `EmployeeFirstNameComparatorImpl ``implements` `Comparator{` `    ``@Override``    ``public` `int` `compare(Employee o1, Employee o2) {``        ``if``(o1.getFirstName().compareTo(o2.getFirstName()) > ``0``){``            ``return` `1``;``        ``}``else` `if``(o1.getFirstName().compareTo(o2.getFirstName()) < ``0``){``            ``return` `-``1``;``        ``}``else``{``            ``return` `0``;``        ``}` `    ``}` `}`

The class implements the `Comparator` interface of the type `Employee` and provides the comparison rules by overriding the `compare()` method. The `compare()` method takes two arguments of the type `Employee` and:-
`return 1`: if `o1.getFirstName()` is greater than `o2.getFirstName()`.
`return -1`: if `o1.getFirstName()` is smaller than `o2.getFirstName()`.
`return 0`: if `o1.getFirstName()` is equals to `o2.getFirstName()`.

Please note that the method `getFirstName()` returns `String` which implements the `Comparable` interface. We have used the `compareTo()` method of the `String` class to compare the strings.

EmployeeLastNameComparatorImpl.java

 010203040506070809101112131415161718 ` ``package` `com.javacodegeeks.entity;` `import` `java.util.Comparator;` `public` `class` `EmployeeLastNameComparatorImpl ``implements` `Comparator {` `    ``@Override``    ``public` `int` `compare(Employee o1, Employee o2) {``        ``if``(o1.getLastName().compareTo(o2.getLastName()) > ``0``){``            ``return` `1``;``        ``}``else` `if``(o1.getLastName().compareTo(o2.getLastName()) < ``0``){``            ``return` `-``1``;``        ``}``else``{``            ``return` `0``;``        ``}` `    ``}``}`

This class works the same as the above class. But this class compares the objects on the basis of the `lastName` property of the `Employee` class. The `compare()` method takes two arguments of the type `Employee `and:-
`return 1`: if `o1.getLastName()` is greater than `o2.getLastName()`.
`return -1`: if `o1.getLastName()` is smaller than `o2.getLastName()`.
`return 0`: if `o1.getLastName()` is equals to `o2.getLastName()`.

BubblesortObjectExample.java

 01020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667 ` ``package` `com.javacodegeeks.sorting.bubblesort;` `import` `com.javacodegeeks.entity.Employee;``import` `com.javacodegeeks.entity.EmployeeFirstNameComparatorImpl;``import` `com.javacodegeeks.entity.EmployeeLastNameComparatorImpl;``import` `com.javacodegeeks.sorting.utility.SortingUtility;` `public` `class` `BubblesortObjectExample {` `    ``public` `static` `void` `main(String[] args) {` `        ``Employee []employees = ``new` `Employee[``5``];``        ``Employee employee = ``new` `Employee(``"John"``,``"Carter"``,``5658``);``        ``employees[``0``] = employee;``        ``employee = ``new` `Employee(``"Mary"``,``"Carter"``,``7412``);``        ``employees[``1``] = employee;``        ``employee = ``new` `Employee(``"Alex"``,``"Lumb"``,``1158``);``        ``employees[``2``] = employee;``        ``employee = ``new` `Employee(``"David"``,``"Jhonson"``,``1254``);``        ``employees[``3``] = employee;``        ``employee = ``new` `Employee(``"Shaun"``,``"Smith"``,``4587``);``        ``employees[``4``] = employee;` `        ``System.out.println(``"Sorting in ascending order on basis of employeeCode...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees);``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);` `        ``System.out.println(``"\nSorting in ascending order on basis of employeeFirstName...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees,``new` `EmployeeFirstNameComparatorImpl());``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);` `        ``System.out.println(``"\nSorting in ascending order on basis of employeeLastName...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees,``new` `EmployeeLastNameComparatorImpl());``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);` `        ``System.out.println(``"\nSorting in descending order on basis of employeeCode...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees,SortingUtility.DESC_ORDER);``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);` `        ``System.out.println(``"\nSorting in descending order on basis of employeeFirstName...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees,SortingUtility.DESC_ORDER,``new` `EmployeeFirstNameComparatorImpl());``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);` `        ``System.out.println(``"\nSorting in descending order on basis of employeeLastName...\n"``);``        ``printArray(employees);``        ``SortingUtility.sort(employees,SortingUtility.DESC_ORDER,``new` `EmployeeLastNameComparatorImpl());``        ``System.out.println(``"After sorting..."``);``        ``printArray(employees);``    ``}` `    ``public` `static`` ``void` `printArray(T []a){``        ``for``(T t : a){``            ``System.out.println(t);``        ``}``    ``}` `}`

If we run the above code, we will have the following results:

 0102030405060708091011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283 `Sorting ``in` `ascending order on basis of employeeCode...` `Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 4587, Name:Shaun Smith``After sorting...``Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 4587, Name:Shaun Smith``Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter` `Sorting ``in` `ascending order on basis of employeeFirstName...` `Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 4587, Name:Shaun Smith``Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``After sorting...``Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``Employee Code: 4587, Name:Shaun Smith` `Sorting ``in` `ascending order on basis of employeeLastName...` `Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``Employee Code: 4587, Name:Shaun Smith``After sorting...``Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb``Employee Code: 4587, Name:Shaun Smith` `Sorting ``in` `descending order on basis of employeeCode...` `Employee Code: 5658, Name:John Carter``Employee Code: 7412, Name:Mary Carter``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb``Employee Code: 4587, Name:Shaun Smith``After sorting...``Employee Code: 7412, Name:Mary Carter``Employee Code: 5658, Name:John Carter``Employee Code: 4587, Name:Shaun Smith``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb` `Sorting ``in` `descending order on basis of employeeFirstName...` `Employee Code: 7412, Name:Mary Carter``Employee Code: 5658, Name:John Carter``Employee Code: 4587, Name:Shaun Smith``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb``After sorting...``Employee Code: 4587, Name:Shaun Smith``Employee Code: 7412, Name:Mary Carter``Employee Code: 5658, Name:John Carter``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb` `Sorting ``in` `descending order on basis of employeeLastName...` `Employee Code: 4587, Name:Shaun Smith``Employee Code: 7412, Name:Mary Carter``Employee Code: 5658, Name:John Carter``Employee Code: 1254, Name:David Jhonson``Employee Code: 1158, Name:Alex Lumb``After sorting...``Employee Code: 4587, Name:Shaun Smith``Employee Code: 1158, Name:Alex Lumb``Employee Code: 1254, Name:David Jhonson``Employee Code: 7412, Name:Mary Carter``Employee Code: 5658, Name:John Carter`

In the above class `BubblesortObjectExample`, we have created an array of the `Employee` class and passed it to the different sort methods. The results provided by the different sort methods can be seen in the output.

This was an example on the Java Bubble sort algorithm.

You can download the source code of this example from here: Bubble Sort Java algorithm – Code Example

Last updated on Jan. 15th, 2020

### Rohit Joshi

Rohit Joshi works as a Software Engineer in the Consumer Product Sector. He is a Sun Certified Java Programmer. He had worked in projects related to different domains. He is also involved in system analysis and system designing. He mainly works in Core Java and J2EE technologies but also have good experience in front-end technologies like Javascript and Jquery.
Subscribe
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.