From 9d0e786887f9929e1caf977659b9fb9770d53033 Mon Sep 17 00:00:00 2001 From: fanatixan Date: Tue, 24 Jul 2018 23:17:22 +0200 Subject: [PATCH 1/2] bael-2023: removing all occurrences of a value from a list --- .../java/com/baeldung/list/RemoveAll.java | 100 ++++++++++ .../com/baeldung/list/RemoveAllUnitTest.java | 183 ++++++++++++++++++ 2 files changed, 283 insertions(+) create mode 100644 core-java-8/src/main/java/com/baeldung/list/RemoveAll.java create mode 100644 core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java diff --git a/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java b/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java new file mode 100644 index 000000000000..4b5d0a5a66e0 --- /dev/null +++ b/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java @@ -0,0 +1,100 @@ +package com.baeldung.list; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +public class RemoveAll { + + static void removeWithStandardForLoopUsingElement(List list, int element) { + for (int i = 0; i < list.size(); i++) { + if (Objects.equals(element, list.get(i))) { + list.remove(element); + } + } + } + + static void removeWithStandardForLoopUsingIndex(List list, int element) { + for (int i = 0; i < list.size(); i++) { + if (Objects.equals(element, list.get(i))) { + list.remove(i); + } + } + } + + static void removeWithForLoopDecrementOnRemove(List list, int element) { + for (int i = 0; i < list.size(); i++) { + if (Objects.equals(element, list.get(i))) { + list.remove(i); + i--; + } + } + } + + static void removeWithForLoopIncrementIfRemains(List list, int element) { + for (int i = 0; i < list.size();) { + if (Objects.equals(element, list.get(i))) { + list.remove(i); + } else { + i++; + } + } + } + + static void removeWithForEachLoop(List list, int element) { + for (Integer number : list) { + if (Objects.equals(number, element)) { + list.remove(number); + } + } + } + + static void removeWithIterator(List list, int element) { + for (Iterator i = list.iterator(); i.hasNext();) { + Integer number = i.next(); + if (Objects.equals(number, element)) { + i.remove(); + } + } + } + + static List removeWithCollectingAndReturningRemainingElements(List list, int element) { + List remainingElements = new ArrayList<>(); + for (Integer number : list) { + if (!Objects.equals(number, element)) { + remainingElements.add(number); + } + } + return remainingElements; + } + + static void removeWithCollectingRemainingElementsAndAddingToOriginalList(List list, int element) { + List remainingElements = new ArrayList<>(); + for (Integer number : list) { + if (!Objects.equals(number, element)) { + remainingElements.add(number); + } + } + + list.clear(); + list.addAll(remainingElements); + } + + static void removeWithCallingRemoveUntilModifies(List list, Integer element) { + while (list.remove(element)) + ; + } + + static List removeWithStreamFilter(List list, Integer element) { + return list.stream() + .filter(e -> !Objects.equals(e, element)) + .collect(Collectors.toList()); + } + + static void removeWithRemoveIf(List list, Integer element) { + list.removeIf(n -> Objects.equals(n, element)); + } + +} diff --git a/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java b/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java new file mode 100644 index 000000000000..575b672060d4 --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java @@ -0,0 +1,183 @@ +package com.baeldung.list; + +import static com.baeldung.list.RemoveAll.removeWithCallingRemoveUntilModifies; +import static com.baeldung.list.RemoveAll.removeWithCollectingAndReturningRemainingElements; +import static com.baeldung.list.RemoveAll.removeWithCollectingRemainingElementsAndAddingToOriginalList; +import static com.baeldung.list.RemoveAll.removeWithForEachLoop; +import static com.baeldung.list.RemoveAll.removeWithForLoopDecrementOnRemove; +import static com.baeldung.list.RemoveAll.removeWithForLoopIncrementIfRemains; +import static com.baeldung.list.RemoveAll.removeWithIterator; +import static com.baeldung.list.RemoveAll.removeWithRemoveIf; +import static com.baeldung.list.RemoveAll.removeWithStandardForLoopUsingElement; +import static com.baeldung.list.RemoveAll.removeWithStandardForLoopUsingIndex; +import static com.baeldung.list.RemoveAll.removeWithStreamFilter; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.ConcurrentModificationException; +import java.util.List; + +import org.junit.Test; + +public class RemoveAllUnitTest { + + private List list(Integer... elements) { + return new ArrayList<>(Arrays.asList(elements)); + } + + @Test + public void givenAList_whenRemovingElementsWithStandardForLoopUsingElement_thenTheResultIsIncorrect() { + // given + List list = list(1, 2, 3); + int valueToRemove = 1; + + // when + removeWithStandardForLoopUsingElement(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(1, 3)); + } + + @Test + public void givenAListWithoutDuplication_whenRemovingElementsWithStandardForLoopUsingIndex_thenTheResultIsCorrect() { + // given + List list = list(1, 2, 3); + int valueToRemove = 1; + + // when + removeWithStandardForLoopUsingIndex(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAListWithAdjacentElements_whenRemovingElementsWithStandardForLoop_thenTheResultIsInCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithStandardForLoopUsingIndex(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(1, 2, 3)); + } + + @Test + public void givenAListWithAdjacentElements_whenRemovingElementsWithForLoopAndDecrementOnRemove_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithForLoopDecrementOnRemove(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAListWithAdjacentElements_whenRemovingElementsWithForLoopAndIncrementIfRemains_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithForLoopIncrementIfRemains(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithForEachLoop_thenExceptionIsThrown() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + assertThrows(ConcurrentModificationException.class, () -> removeWithForEachLoop(list, valueToRemove)); + } + + @Test + public void givenAList_whenRemovingElementsWithIterator_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithIterator(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithCollectingAndReturningRemainingElements_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + List result = removeWithCollectingAndReturningRemainingElements(list, valueToRemove); + + // then + assertThat(result).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithCollectingRemainingAndAddingToOriginalList_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithCollectingRemainingElementsAndAddingToOriginalList(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithCallingRemoveUntilModifies_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithCallingRemoveUntilModifies(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithStreamFilter_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + List result = removeWithStreamFilter(list, valueToRemove); + + // then + assertThat(result).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithCallingRemoveIf_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; + + // when + removeWithRemoveIf(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + +} From bfa4d29b64a0fba2ed9a351b07ccf7ea001ce7cf Mon Sep 17 00:00:00 2001 From: fanatixan Date: Sun, 29 Jul 2018 21:46:37 +0200 Subject: [PATCH 2/2] adjusting examples to match the article --- .../java/com/baeldung/list/RemoveAll.java | 31 ++++++--- .../com/baeldung/list/RemoveAllUnitTest.java | 65 +++++++++++++------ 2 files changed, 66 insertions(+), 30 deletions(-) diff --git a/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java b/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java index 4b5d0a5a66e0..0dd97af6e842 100644 --- a/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java +++ b/core-java-8/src/main/java/com/baeldung/list/RemoveAll.java @@ -8,14 +8,30 @@ public class RemoveAll { - static void removeWithStandardForLoopUsingElement(List list, int element) { - for (int i = 0; i < list.size(); i++) { - if (Objects.equals(element, list.get(i))) { - list.remove(element); - } + static void removeWithWhileLoopPrimitiveElement(List list, int element) { + while (list.contains(element)) { + list.remove(element); + } + } + + static void removeWithWhileLoopNonPrimitiveElement(List list, Integer element) { + while (list.contains(element)) { + list.remove(element); } } + static void removeWithWhileLoopStoringFirstOccurrenceIndex(List list, Integer element) { + int index; + while ((index = list.indexOf(element)) >= 0) { + list.remove(index); + } + } + + static void removeWithCallingRemoveUntilModifies(List list, Integer element) { + while (list.remove(element)) + ; + } + static void removeWithStandardForLoopUsingIndex(List list, int element) { for (int i = 0; i < list.size(); i++) { if (Objects.equals(element, list.get(i))) { @@ -82,11 +98,6 @@ static void removeWithCollectingRemainingElementsAndAddingToOriginalList(List list, Integer element) { - while (list.remove(element)) - ; - } - static List removeWithStreamFilter(List list, Integer element) { return list.stream() .filter(e -> !Objects.equals(e, element)) diff --git a/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java b/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java index 575b672060d4..7ada66a49ec5 100644 --- a/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java +++ b/core-java-8/src/test/java/com/baeldung/list/RemoveAllUnitTest.java @@ -8,11 +8,11 @@ import static com.baeldung.list.RemoveAll.removeWithForLoopIncrementIfRemains; import static com.baeldung.list.RemoveAll.removeWithIterator; import static com.baeldung.list.RemoveAll.removeWithRemoveIf; -import static com.baeldung.list.RemoveAll.removeWithStandardForLoopUsingElement; import static com.baeldung.list.RemoveAll.removeWithStandardForLoopUsingIndex; import static com.baeldung.list.RemoveAll.removeWithStreamFilter; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static com.baeldung.list.RemoveAll.*; + +import static org.assertj.core.api.Assertions.*; import java.util.ArrayList; import java.util.Arrays; @@ -28,16 +28,53 @@ private List list(Integer... elements) { } @Test - public void givenAList_whenRemovingElementsWithStandardForLoopUsingElement_thenTheResultIsIncorrect() { + public void givenAList_whenRemovingElementsWithWhileLoopUsingPrimitiveElement_thenTheResultCorrect() { + // given + List list = list(1, 2, 3); + int valueToRemove = 1; + + // when + assertThatThrownBy(() -> removeWithWhileLoopPrimitiveElement(list, valueToRemove)) + .isInstanceOf(IndexOutOfBoundsException.class); + } + + @Test + public void givenAList_whenRemovingElementsWithWhileLoopUsingNonPrimitiveElement_thenTheResultCorrect() { + // given + List list = list(1, 2, 3); + int valueToRemove = 1; + + // when + removeWithWhileLoopNonPrimitiveElement(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithWhileLoopStoringFirstOccurrenceIndex_thenTheResultCorrect() { // given List list = list(1, 2, 3); int valueToRemove = 1; + + // when + removeWithWhileLoopStoringFirstOccurrenceIndex(list, valueToRemove); + + // then + assertThat(list).isEqualTo(list(2, 3)); + } + + @Test + public void givenAList_whenRemovingElementsWithCallingRemoveUntilModifies_thenTheResultIsCorrect() { + // given + List list = list(1, 1, 2, 3); + int valueToRemove = 1; // when - removeWithStandardForLoopUsingElement(list, valueToRemove); + removeWithCallingRemoveUntilModifies(list, valueToRemove); // then - assertThat(list).isEqualTo(list(1, 3)); + assertThat(list).isEqualTo(list(2, 3)); } @Test @@ -99,7 +136,8 @@ public void givenAList_whenRemovingElementsWithForEachLoop_thenExceptionIsThrown int valueToRemove = 1; // when - assertThrows(ConcurrentModificationException.class, () -> removeWithForEachLoop(list, valueToRemove)); + assertThatThrownBy(() -> removeWithForEachLoop(list, valueToRemove)) + .isInstanceOf(ConcurrentModificationException.class); } @Test @@ -141,19 +179,6 @@ public void givenAList_whenRemovingElementsWithCollectingRemainingAndAddingToOri assertThat(list).isEqualTo(list(2, 3)); } - @Test - public void givenAList_whenRemovingElementsWithCallingRemoveUntilModifies_thenTheResultIsCorrect() { - // given - List list = list(1, 1, 2, 3); - int valueToRemove = 1; - - // when - removeWithCallingRemoveUntilModifies(list, valueToRemove); - - // then - assertThat(list).isEqualTo(list(2, 3)); - } - @Test public void givenAList_whenRemovingElementsWithStreamFilter_thenTheResultIsCorrect() { // given