Skip to content

Commit 751a3ca

Browse files
joshiparthinjoshiparthin
committed
Changes for sorting article
1 parent 3af165f commit 751a3ca

2 files changed

Lines changed: 274 additions & 0 deletions

File tree

‎core-java/src/test/java/org/baeldung/java/sorting/Employee.java‎

Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
package org.baeldung.java.sorting;
2+
3+
public class Employee implements Comparable {
4+
5+
private String name;
6+
private int age;
7+
private double salary;
8+
9+
public Employee(String name, int age, double salary) {
10+
this.name = name;
11+
this.age = age;
12+
this.salary = salary;
13+
}
14+
15+
public String getName() {
16+
return name;
17+
}
18+
19+
public void setName(String name) {
20+
this.name = name;
21+
}
22+
23+
public int getAge() {
24+
return age;
25+
}
26+
27+
public void setAge(int age) {
28+
this.age = age;
29+
}
30+
31+
public double getSalary() {
32+
return salary;
33+
}
34+
35+
public void setSalary(double salary) {
36+
this.salary = salary;
37+
}
38+
39+
@Override
40+
public boolean equals(Object obj) {
41+
return ((Employee) obj).getName().equals(getName());
42+
}
43+
44+
@Override
45+
public int compareTo(Object o) {
46+
Employee e = (Employee) o;
47+
return getName().compareTo(e.getName());
48+
}
49+
50+
@Override
51+
public String toString() {
52+
return new StringBuffer()
53+
.append("(").append(getName())
54+
.append(getAge()).append(",")
55+
.append(getSalary()).append(")").toString();
56+
}
57+
58+
}

‎core-java/src/test/java/org/baeldung/java/sorting/JavaSorting.java‎

Lines changed: 216 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,221 @@
11
package org.baeldung.java.sorting;
22

3+
import static org.junit.Assert.assertTrue;
4+
5+
import java.util.ArrayList;
6+
import java.util.Arrays;
7+
import java.util.Collections;
8+
import java.util.Comparator;
9+
import java.util.HashMap;
10+
import java.util.HashSet;
11+
import java.util.LinkedHashMap;
12+
import java.util.LinkedHashSet;
13+
import java.util.List;
14+
import java.util.Map;
15+
import java.util.Map.Entry;
16+
17+
import org.apache.commons.lang3.ArrayUtils;
18+
import org.junit.Before;
19+
import org.junit.Test;
20+
import org.junit.runner.manipulation.Sortable;
21+
22+
import com.google.common.primitives.Ints;
23+
324
public class JavaSorting {
25+
26+
private int [] toSort;
27+
private int [] sortedInts;
28+
private int [] sortedRangeInts;
29+
// private Integer [] integers;
30+
// private Integer [] sortedIntegers;
31+
// private List<Integer> integersList;
32+
// private List<Integer> sortedIntegersList;
33+
private Employee[] employees;
34+
private Employee[] employeesSorted;
35+
private Employee[] employeesSortedByAge;
36+
private HashMap<Integer, String> map;
37+
38+
@Before
39+
public void initVariables () {
40+
41+
toSort = new int[]
42+
{ 5, 1, 89, 255, 7, 88, 200, 123, 66 };
43+
sortedInts = new int[]
44+
{1, 5, 7, 66, 88, 89, 123, 200, 255};
45+
sortedRangeInts = new int[]
46+
{5, 1, 89, 7, 88, 200, 255, 123, 66};
47+
48+
// integers = new Integer[]
49+
// { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
50+
// sortedIntegers = new Integer[]
51+
// {1, 5, 7, 66, 88, 89, 123, 200, 255};
52+
//
53+
// integersList = Arrays.asList(new Integer[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 });
54+
// sortedIntegersList = Arrays.asList(new Integer[] {1, 5, 7, 66, 88, 89, 123, 200, 255});
55+
56+
employees = new Employee[] {
57+
new Employee("John", 23, 5000),
58+
new Employee("Steve", 26, 6000),
59+
new Employee("Frank", 33, 7000),
60+
new Employee("Earl", 43, 10000),
61+
new Employee("Jessica", 23, 4000),
62+
new Employee("Pearl", 33, 6000)};
63+
employeesSorted = new Employee[] {
64+
new Employee("Earl", 43, 10000),
65+
new Employee("Frank", 33, 70000),
66+
new Employee("Jessica", 23, 4000),
67+
new Employee("John", 23, 5000),
68+
new Employee("Pearl", 33, 4000),
69+
new Employee("Steve", 26, 6000)};
70+
employeesSortedByAge = new Employee[] {
71+
new Employee("John", 23, 5000),
72+
new Employee("Jessica", 23, 4000),
73+
new Employee("Steve", 26, 6000),
74+
new Employee("Frank", 33, 70000),
75+
new Employee("Pearl", 33, 4000),
76+
new Employee("Earl", 43, 10000)};
77+
78+
HashMap<Integer, String> map = new HashMap<>();
79+
map.put(55, "John");
80+
map.put(22, "Apple");
81+
map.put(66, "Earl");
82+
map.put(77, "Pearl");
83+
map.put(12, "George");
84+
map.put(6, "Rocky");
85+
86+
}
87+
88+
@Test
89+
public void givenIntArray_whenUsingSort_thenSortedArray() {
90+
Arrays.sort(toSort);
91+
92+
assertTrue(Arrays.equals(toSort, sortedInts));
93+
}
94+
95+
@Test
96+
public void givenIntegerArray_whenUsingSort_thenSortedArray() {
97+
Integer [] integers = ArrayUtils.toObject(toSort);
98+
Arrays.sort(integers, new Comparator<Integer>() {
99+
@Override
100+
public int compare(Integer a, Integer b) {
101+
return a - b;
102+
}
103+
});
104+
105+
assertTrue(Arrays.equals(integers, ArrayUtils.toObject(sortedInts)));
106+
}
107+
108+
@Test
109+
public void givenArray_whenUsingSortWithLambdas_thenSortedArray() {
110+
Integer [] integersToSort = ArrayUtils.toObject(toSort);
111+
Arrays.sort(integersToSort, (a, b) -> {
112+
return a - b;
113+
});
114+
115+
assertTrue(Arrays.equals(integersToSort, ArrayUtils.toObject(sortedInts)));
116+
}
117+
118+
@Test
119+
public void givenEmpArray_SortEmpArray_thenSortedArrayinNaturalOrder() {
120+
Arrays.sort(employees);
121+
122+
assertTrue(Arrays.equals(employees, employeesSorted));
123+
}
124+
125+
126+
@Test
127+
public void givenIntArray_whenUsingRangeSort_thenRangeSortedArray() {
128+
Arrays.sort(toSort, 3, 7);
129+
130+
assertTrue(Arrays.equals(toSort, sortedRangeInts));
131+
}
132+
133+
@Test
134+
public void givenIntArray_whenUsingParallelSort_thenParallelSortedArray() {
135+
Arrays.parallelSort(toSort);
136+
137+
assertTrue(Arrays.equals(toSort, sortedInts));
138+
}
139+
140+
141+
142+
@Test
143+
public void givenArrayObjects_whenUsingComparing_thenSortedArrayObjects() {
144+
List<Employee> employeesList = Arrays.asList(employees);
145+
146+
employeesList.sort(Comparator.comparing(Employee::getAge));//.thenComparing(Employee::getName));
147+
148+
assertTrue(Arrays.equals(employeesList.toArray(), employeesSortedByAge));
149+
}
150+
151+
@Test
152+
public void givenList_whenUsingSort_thenSortedList() {
153+
List<Integer> toSortList = Ints.asList(toSort);
154+
Collections.sort(toSortList);
155+
156+
assertTrue(Arrays.equals(toSortList.toArray(),
157+
ArrayUtils.toObject(sortedInts)));
158+
}
159+
160+
@Test
161+
public void givenMap_whenSortingByKeys_thenSortedMap() {
162+
Integer[] sortedKeys = new Integer[] { 6, 12, 22, 55, 66, 77 };
163+
164+
List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());
165+
Collections.sort(entries, new Comparator<Entry<Integer, String>>() {
166+
@Override
167+
public int compare(Entry<Integer, String> o1, Entry<Integer, String> o2) {
168+
return o1.getKey().compareTo(o2.getKey());
169+
}
170+
});
171+
HashMap<Integer, String> sortedMap = new LinkedHashMap<>();
172+
for (Map.Entry<Integer, String> entry : entries) {
173+
sortedMap.put(entry.getKey(), entry.getValue());
174+
}
175+
176+
assertTrue(Arrays.equals(sortedMap.keySet().toArray(), sortedKeys));
177+
}
178+
179+
@Test
180+
public void givenMap_whenSortingByValues_thenSortedMap() {
181+
String[] sortedValues = new String[]
182+
{ "Apple", "Earl", "George", "John", "Pearl", "Rocky" };
183+
184+
List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());
185+
Collections.sort(entries, new Comparator<Entry<Integer, String>>() {
186+
@Override
187+
public int compare(Entry<Integer, String> o1, Entry<Integer, String> o2) {
188+
return o1.getValue().compareTo(o2.getValue());
189+
}
190+
});
191+
HashMap<Integer, String> sortedMap = new LinkedHashMap<>();
192+
for (Map.Entry<Integer, String> entry : entries) {
193+
sortedMap.put(entry.getKey(), entry.getValue());
194+
}
195+
196+
assertTrue(Arrays.equals(sortedMap.values().toArray(), sortedValues));
197+
}
198+
199+
200+
201+
202+
203+
204+
@Test
205+
public void givenSet_whenUsingSort_thenSortedSet() {
206+
HashSet<Integer> integersSet = new LinkedHashSet<>(Ints.asList(toSort));
207+
HashSet<Integer> descSortedIntegersSet = new LinkedHashSet<>(Arrays.asList(new Integer[]
208+
{255, 200, 123, 89, 88, 66, 7, 5, 1}));
209+
210+
ArrayList<Integer> list = new ArrayList<Integer>(integersSet);
211+
Collections.sort(list, (i1, i2) -> {
212+
return i2 - i1;
213+
});
214+
integersSet = new LinkedHashSet<>(list);
215+
216+
assertTrue(Arrays.equals(integersSet.toArray(), descSortedIntegersSet.toArray()));
217+
}
218+
219+
4220

5221
}

0 commit comments

Comments
 (0)