diff --git a/core-java/src/test/java/org/baeldung/java/sorting/Employee.java b/core-java/src/test/java/org/baeldung/java/sorting/Employee.java new file mode 100644 index 0000000000..768ee8f397 --- /dev/null +++ b/core-java/src/test/java/org/baeldung/java/sorting/Employee.java @@ -0,0 +1,58 @@ +package org.baeldung.java.sorting; + +public class Employee implements Comparable { + + private String name; + private int age; + private double salary; + + public Employee(String name, int age, double salary) { + this.name = name; + this.age = age; + this.salary = salary; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public double getSalary() { + return salary; + } + + public void setSalary(double salary) { + this.salary = salary; + } + + @Override + public boolean equals(Object obj) { + return ((Employee) obj).getName().equals(getName()); + } + + @Override + public int compareTo(Object o) { + Employee e = (Employee) o; + return getName().compareTo(e.getName()); + } + + @Override + public String toString() { + return new StringBuffer() + .append("(").append(getName()) + .append(getAge()).append(",") + .append(getSalary()).append(")").toString(); + } + +} diff --git a/core-java/src/test/java/org/baeldung/java/sorting/JavaSorting.java b/core-java/src/test/java/org/baeldung/java/sorting/JavaSorting.java index 2e15a3576f..1ae7bcbbb0 100644 --- a/core-java/src/test/java/org/baeldung/java/sorting/JavaSorting.java +++ b/core-java/src/test/java/org/baeldung/java/sorting/JavaSorting.java @@ -1,5 +1,221 @@ package org.baeldung.java.sorting; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import org.apache.commons.lang3.ArrayUtils; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.manipulation.Sortable; + +import com.google.common.primitives.Ints; + public class JavaSorting { + + private int [] toSort; + private int [] sortedInts; + private int [] sortedRangeInts; +// private Integer [] integers; +// private Integer [] sortedIntegers; +// private List integersList; +// private List sortedIntegersList; + private Employee[] employees; + private Employee[] employeesSorted; + private Employee[] employeesSortedByAge; + private HashMap map; + + @Before + public void initVariables () { + + toSort = new int[] + { 5, 1, 89, 255, 7, 88, 200, 123, 66 }; + sortedInts = new int[] + {1, 5, 7, 66, 88, 89, 123, 200, 255}; + sortedRangeInts = new int[] + {5, 1, 89, 7, 88, 200, 255, 123, 66}; + +// integers = new Integer[] +// { 5, 1, 89, 255, 7, 88, 200, 123, 66 }; +// sortedIntegers = new Integer[] +// {1, 5, 7, 66, 88, 89, 123, 200, 255}; +// +// integersList = Arrays.asList(new Integer[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 }); +// sortedIntegersList = Arrays.asList(new Integer[] {1, 5, 7, 66, 88, 89, 123, 200, 255}); + + employees = new Employee[] { + new Employee("John", 23, 5000), + new Employee("Steve", 26, 6000), + new Employee("Frank", 33, 7000), + new Employee("Earl", 43, 10000), + new Employee("Jessica", 23, 4000), + new Employee("Pearl", 33, 6000)}; + employeesSorted = new Employee[] { + new Employee("Earl", 43, 10000), + new Employee("Frank", 33, 70000), + new Employee("Jessica", 23, 4000), + new Employee("John", 23, 5000), + new Employee("Pearl", 33, 4000), + new Employee("Steve", 26, 6000)}; + employeesSortedByAge = new Employee[] { + new Employee("John", 23, 5000), + new Employee("Jessica", 23, 4000), + new Employee("Steve", 26, 6000), + new Employee("Frank", 33, 70000), + new Employee("Pearl", 33, 4000), + new Employee("Earl", 43, 10000)}; + + HashMap map = new HashMap<>(); + map.put(55, "John"); + map.put(22, "Apple"); + map.put(66, "Earl"); + map.put(77, "Pearl"); + map.put(12, "George"); + map.put(6, "Rocky"); + + } + + @Test + public void givenIntArray_whenUsingSort_thenSortedArray() { + Arrays.sort(toSort); + + assertTrue(Arrays.equals(toSort, sortedInts)); + } + + @Test + public void givenIntegerArray_whenUsingSort_thenSortedArray() { + Integer [] integers = ArrayUtils.toObject(toSort); + Arrays.sort(integers, new Comparator() { + @Override + public int compare(Integer a, Integer b) { + return a - b; + } + }); + + assertTrue(Arrays.equals(integers, ArrayUtils.toObject(sortedInts))); + } + + @Test + public void givenArray_whenUsingSortWithLambdas_thenSortedArray() { + Integer [] integersToSort = ArrayUtils.toObject(toSort); + Arrays.sort(integersToSort, (a, b) -> { + return a - b; + }); + + assertTrue(Arrays.equals(integersToSort, ArrayUtils.toObject(sortedInts))); + } + + @Test + public void givenEmpArray_SortEmpArray_thenSortedArrayinNaturalOrder() { + Arrays.sort(employees); + + assertTrue(Arrays.equals(employees, employeesSorted)); + } + + + @Test + public void givenIntArray_whenUsingRangeSort_thenRangeSortedArray() { + Arrays.sort(toSort, 3, 7); + + assertTrue(Arrays.equals(toSort, sortedRangeInts)); + } + + @Test + public void givenIntArray_whenUsingParallelSort_thenParallelSortedArray() { + Arrays.parallelSort(toSort); + + assertTrue(Arrays.equals(toSort, sortedInts)); + } + + + + @Test + public void givenArrayObjects_whenUsingComparing_thenSortedArrayObjects() { + List employeesList = Arrays.asList(employees); + + employeesList.sort(Comparator.comparing(Employee::getAge));//.thenComparing(Employee::getName)); + + assertTrue(Arrays.equals(employeesList.toArray(), employeesSortedByAge)); + } + + @Test + public void givenList_whenUsingSort_thenSortedList() { + List toSortList = Ints.asList(toSort); + Collections.sort(toSortList); + + assertTrue(Arrays.equals(toSortList.toArray(), + ArrayUtils.toObject(sortedInts))); + } + + @Test + public void givenMap_whenSortingByKeys_thenSortedMap() { + Integer[] sortedKeys = new Integer[] { 6, 12, 22, 55, 66, 77 }; + + List> entries = new ArrayList<>(map.entrySet()); + Collections.sort(entries, new Comparator>() { + @Override + public int compare(Entry o1, Entry o2) { + return o1.getKey().compareTo(o2.getKey()); + } + }); + HashMap sortedMap = new LinkedHashMap<>(); + for (Map.Entry entry : entries) { + sortedMap.put(entry.getKey(), entry.getValue()); + } + + assertTrue(Arrays.equals(sortedMap.keySet().toArray(), sortedKeys)); + } + + @Test + public void givenMap_whenSortingByValues_thenSortedMap() { + String[] sortedValues = new String[] + { "Apple", "Earl", "George", "John", "Pearl", "Rocky" }; + + List> entries = new ArrayList<>(map.entrySet()); + Collections.sort(entries, new Comparator>() { + @Override + public int compare(Entry o1, Entry o2) { + return o1.getValue().compareTo(o2.getValue()); + } + }); + HashMap sortedMap = new LinkedHashMap<>(); + for (Map.Entry entry : entries) { + sortedMap.put(entry.getKey(), entry.getValue()); + } + + assertTrue(Arrays.equals(sortedMap.values().toArray(), sortedValues)); + } + + + + + + + @Test + public void givenSet_whenUsingSort_thenSortedSet() { + HashSet integersSet = new LinkedHashSet<>(Ints.asList(toSort)); + HashSet descSortedIntegersSet = new LinkedHashSet<>(Arrays.asList(new Integer[] + {255, 200, 123, 89, 88, 66, 7, 5, 1})); + + ArrayList list = new ArrayList(integersSet); + Collections.sort(list, (i1, i2) -> { + return i2 - i1; + }); + integersSet = new LinkedHashSet<>(list); + + assertTrue(Arrays.equals(integersSet.toArray(), descSortedIntegersSet.toArray())); + } + + }