Sort ArrayList

giaunv · giaunv · commit bb530e32f5b7 · 2019-10-03T19:09:29.000+08:00
diff --git a/java-examples/java-core/src/test/java/com/hellokoding/java/collections/ArrayListSortingTest.java b/java-examples/java-core/src/test/java/com/hellokoding/java/collections/ArrayListSortingTest.java
@@ -1,58 +1,103 @@
 package com.hellokoding.java.collections;
 
+import org.assertj.core.api.ThrowableAssert;
 import org.junit.Test;
 
-import java.util.*;
-import java.util.stream.Collectors;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class ArrayListSortingTest {
     @Test
-    public void givenNonComparableAndComparator_whenSortAsc_thenSuccess(){
-        // given
-        List<NonComparableBook> bookList = new ArrayList<>();
-        bookList.add(new NonComparableBook("C"));
-        bookList.add(new NonComparableBook("A"));
-        bookList.add(new NonComparableBook("D"));
-
-        // when sorting in natural / ascending order
-        bookList.sort(Comparator.comparing(e -> e.title));
-
-        // then
-        String actual = bookList.stream().map(e -> e.title).collect(Collectors.joining());
-        assertThat(actual).isEqualTo("ACD");
+    public void sortStrings(){
+        List<String> strings = new ArrayList<>(List.of("c", "a", "b"));
+
+        strings.sort(Comparator.naturalOrder());
+        assertThat(strings).containsExactly("a", "b", "c");
+
+        strings.sort(Comparator.reverseOrder());
+        assertThat(strings).containsExactly("c", "b", "a");
+    }
+
+    @Test
+    public void sortNumbers() {
+        List<Integer> numbers = new ArrayList<>(List.of(3, 1, 2));
+
+        numbers.sort(Comparator.naturalOrder());
+        assertThat(numbers).containsExactly(1, 2, 3);
+
+        numbers.sort(Comparator.reverseOrder());
+        assertThat(numbers).containsExactly(3, 2, 1);
     }
 
     @Test
-    public void givenComparable_whenSortAsc_thenSuccess(){
-        // given
-        List<ComparableBook> bookList = new ArrayList<>();
-        bookList.add(new ComparableBook("C"));
-        bookList.add(new ComparableBook("A"));
-        bookList.add(new ComparableBook("D"));
-
-        // when sorting in natural / ascending order
-        bookList.sort(Comparator.naturalOrder());
-
-        // then
-        String actual = bookList.stream().map(e -> e.title).collect(Collectors.joining());
-        assertThat(actual).isEqualTo("ACD");
+    public void sortDates() {
+        LocalDate ld1 = LocalDate.of(2019, 3, 1);
+        LocalDate ld2 = LocalDate.of(2019, 1, 1);
+        LocalDate ld3 = LocalDate.of(2019, 2, 1);
+        List<LocalDate> dates = new ArrayList<>(List.of(ld1, ld2, ld3));
+
+        dates.sort(Comparator.naturalOrder());
+        assertThat(dates).containsExactly(ld2, ld3, ld1);
+
+        dates.sort(Comparator.reverseOrder());
+        assertThat(dates).containsExactly(ld1, ld3, ld2);
+    }
+
+    @Test
+    public void sortNullObject() {
+        List<Integer> lst = new ArrayList<>(Arrays.asList(3, 1, null));
+
+        ThrowableAssert.ThrowingCallable c = () -> lst.sort(Comparator.naturalOrder());
+        assertThatThrownBy(c).isInstanceOf(NullPointerException.class);
     }
 
     @Test
-    public void givenComparable_whenSortDesc_thenSuccess(){
-        // given
-        List<ComparableBook> bookList = new ArrayList<>();
-        bookList.add(new ComparableBook("C"));
-        bookList.add(new ComparableBook("A"));
-        bookList.add(new ComparableBook("D"));
-
-        // when sorting in reverse / descending order
-        bookList.sort(Comparator.reverseOrder());
-
-        // then
-        String actual = bookList.stream().map(e -> e.title).collect(Collectors.joining());
-        assertThat(actual).isEqualTo("DCA");
+    public void sortOneField() {
+        Book book1 = new Book(1, "b");
+        Book book2 = new Book(2, "c");
+        Book book3 = new Book(3, "a");
+
+        List<Book> list = Arrays.asList(book1, book2, book3);
+        list.sort(Comparator.comparing(Book::getTitle));
+
+        assertThat(list).containsExactly(book3, book1, book2);
+    }
+
+    @Test
+    public void sortMultipleFields() {
+        Book book1 = new Book(1, "b");
+        Book book2 = new Book(2, "c");
+        Book book3 = new Book(3, "c");
+
+        List<Book> list = Arrays.asList(book1, book2, book3);
+        list.sort(Comparator
+            .comparing(Book::getTitle, Comparator.reverseOrder())
+            .thenComparing(Book::getId, Comparator.reverseOrder()));
+
+        assertThat(list).containsExactly(book3, book2, book1);
+    }
+
+    static class Book {
+        int id;
+        String title;
+
+        Book(int id, String title) {
+            this.id = id;
+            this.title = title;
+        }
+
+        int getId() {
+            return id;
+        }
+
+        String getTitle() {
+            return title;
+        }
     }
 }
diff --git a/java-examples/java-core/src/test/java/com/hellokoding/java/collections/HashSetSortingTest.java b/java-examples/java-core/src/test/java/com/hellokoding/java/collections/HashSetSortingTest.java
@@ -26,7 +26,7 @@ public void sortDescWithTreeSet() {
     }
 
     @Test
-    public void sortWithTreeSetAndComparator() {
+    public void sortDescWithTreeSet2() {
         Set<Integer> set = new HashSet<>(Set.of(3, 1, 2));
         NavigableSet<Integer> sortedSet = new TreeSet<>(Comparator.reverseOrder());
         sortedSet.addAll(set);

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public void sortDescWithTreeSet() {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Test`
`29`		`- public void sortWithTreeSetAndComparator() {`
	`29`	`+ public void sortDescWithTreeSet2() {`
`30`	`30`	`Set<Integer> set = new HashSet<>(Set.of(3, 1, 2));`
`31`	`31`	`NavigableSet<Integer> sortedSet = new TreeSet<>(Comparator.reverseOrder());`
`32`	`32`	`sortedSet.addAll(set);`