Merge pull request #2434 from apache/GROOVY-11903

Author: eric-milles

src/main/java/org/codehaus/groovy/runtime/DefaultGroovyMethods.java

@@ -10695,36 +10695,36 @@ public static <K, V> Map.Entry<K, V> min(Map<K, V> self, @ClosureParams(value=Fr
      * Create a Set composed of the elements of the first Set minus the
      * elements of the given Collection.
      *
-     * @param self     a Set object
-     * @param removeMe the items to remove from the Set
-     * @return the resulting Set
+     * @param self     a Set
+     * @param removeMe the elements to exclude
+     * @return a new Set
      * @since 1.5.0
      */
     @SuppressWarnings("unchecked")
     public static <T> Set<T> minus(Set<T> self, Collection<?> removeMe) {
-        Comparator comparator = (self instanceof SortedSet) ? ((SortedSet) self).comparator() : null;
-        final Set<T> ansSet = createSimilarSet(self);
-        ansSet.addAll(self);
+        Comparator comparator = self instanceof SortedSet set ? set.comparator() : null;
+        Set<T> answer = createSimilarSet(self);
+        answer.addAll(self);
         if (removeMe != null) {
             for (T o1 : self) {
                 for (Object o2 : removeMe) {
                     boolean areEqual = (comparator != null) ? (comparator.compare(o1, o2) == 0) : coercedEquals(o1, o2);
                     if (areEqual) {
-                        ansSet.remove(o1);
+                        answer.remove(o1);
                     }
                 }
             }
         }
-        return ansSet;
+        return answer;
     }
 
     /**
      * Create a Set composed of the elements of the first Set minus the
      * elements from the given Iterable.
      *
-     * @param self     a Set object
-     * @param removeMe the items to remove from the Set
-     * @return the resulting Set
+     * @param self     a Set
+     * @param removeMe the elements to exclude
+     * @return a new Set
      * @since 1.8.7
      */
     public static <T> Set<T> minus(Set<T> self, Iterable<?> removeMe) {
@@ -10734,29 +10734,29 @@ public static <T> Set<T> minus(Set<T> self, Iterable<?> removeMe) {
     /**
      * Create a Set composed of the elements of the first Set minus the given element.
      *
-     * @param self     a Set object
-     * @param removeMe the element to remove from the Set
-     * @return the resulting Set
+     * @param self     a Set
+     * @param removeMe the element to exclude
+     * @return a new Set
      * @since 1.5.0
      */
     @SuppressWarnings("unchecked")
     public static <T> Set<T> minus(Set<T> self, Object removeMe) {
-        Comparator comparator = (self instanceof SortedSet) ? ((SortedSet) self).comparator() : null;
-        final Set<T> ansSet = createSimilarSet(self);
+        Comparator comparator = self instanceof SortedSet set ? set.comparator() : null;
+        Set<T> answer = createSimilarSet(self);
         for (T t : self) {
-            boolean areEqual = (comparator != null)? (comparator.compare(t, removeMe) == 0) : coercedEquals(t, removeMe);
-            if (!areEqual) ansSet.add(t);
+            boolean areEqual = (comparator != null) ? (comparator.compare(t, removeMe) == 0) : coercedEquals(t, removeMe);
+            if (!areEqual) answer.add(t);
         }
-        return ansSet;
+        return answer;
     }
 
     /**
      * Create a SortedSet composed of the elements of the first SortedSet minus the
      * elements of the given Collection.
      *
-     * @param self     a SortedSet object
-     * @param removeMe the items to remove from the SortedSet
-     * @return the resulting SortedSet
+     * @param self     a SortedSet
+     * @param removeMe the elements to exclude
+     * @return a new SortedSet
      * @since 2.4.0
      */
     public static <T> SortedSet<T> minus(SortedSet<T> self, Collection<?> removeMe) {
@@ -10767,9 +10767,9 @@ public static <T> SortedSet<T> minus(SortedSet<T> self, Collection<?> removeMe)
      * Create a SortedSet composed of the elements of the first SortedSet minus the
      * elements of the given Iterable.
      *
-     * @param self     a SortedSet object
-     * @param removeMe the items to remove from the SortedSet
-     * @return the resulting SortedSet
+     * @param self     a SortedSet
+     * @param removeMe the elements to exclude
+     * @return a new SortedSet
      * @since 2.4.0
      */
     public static <T> SortedSet<T> minus(SortedSet<T> self, Iterable<?> removeMe) {
@@ -10779,23 +10779,27 @@ public static <T> SortedSet<T> minus(SortedSet<T> self, Iterable<?> removeMe) {
     /**
      * Create a SortedSet composed of the elements of the first SortedSet minus the given element.
      *
-     * @param self     a SortedSet object
-     * @param removeMe the element to remove from the SortedSet
-     * @return the resulting SortedSet
+     * @param self     a SortedSet
+     * @param removeMe the element to exclude
+     * @return a new SortedSet
      * @since 2.4.0
      */
     public static <T> SortedSet<T> minus(SortedSet<T> self, Object removeMe) {
         return (SortedSet<T>) minus((Set<T>) self, removeMe);
     }
 
     /**
-     * Create a List composed of the elements of the first list minus
+     * Create a List composed of the elements of the given List minus
      * every occurrence of elements of the given Collection.
-     * <pre class="groovyTestCase">assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]</pre>
+     * <pre class="groovyTestCase">
+     * def one = [1, "a", true, true, false, 5.3, null], two = [null, true, 5.3]
+     * def sub = one.asUnmodifiable() - two.asUnmodifiable()
+     * assert sub == [1, "a", false]
+     * </pre>
      *
      * @param self     a List
-     * @param removeMe a Collection of elements to remove
-     * @return a List with the given elements removed
+     * @param removeMe the elements to exclude
+     * @return a new List
      * @since 1.0
      */
     public static <T> List<T> minus(List<T> self, Collection<?> removeMe) {
@@ -10808,8 +10812,8 @@ public static <T> List<T> minus(List<T> self, Collection<?> removeMe) {
      * <pre class="groovyTestCase">assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]</pre>
      *
      * @param self     a Collection
-     * @param removeMe a Collection of elements to remove
-     * @return a Collection with the given elements removed
+     * @param removeMe the elements to exclude
+     * @return a new Collection
      * @since 2.4.0
      */
     public static <T> Collection<T> minus(Collection<T> self, Collection<?> removeMe) {
@@ -10822,8 +10826,8 @@ public static <T> Collection<T> minus(Collection<T> self, Collection<?> removeMe
      * <pre class="groovyTestCase">assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]</pre>
      *
      * @param self     a List
-     * @param removeMe an Iterable of elements to remove
-     * @return a new List with the given elements removed
+     * @param removeMe the elements to exclude
+     * @return a new List
      * @since 1.8.7
      */
     public static <T> List<T> minus(List<T> self, Iterable<?> removeMe) {
@@ -10838,8 +10842,8 @@ public static <T> List<T> minus(List<T> self, Iterable<?> removeMe) {
      * </pre>
      *
      * @param self     an Iterable
-     * @param removeMe an Iterable of elements to remove
-     * @return a new Collection with the given elements removed
+     * @param removeMe the elements to exclude
+     * @return a new Collection
      * @since 2.4.0
      */
     public static <T> Collection<T> minus(Iterable<T> self, Iterable<?> removeMe) {
@@ -10853,10 +10857,10 @@ public static <T> Collection<T> minus(Iterable<T> self, Iterable<?> removeMe) {
      * assert ['a', 'B', 'c', 'D', 'E'].minus(['b', 'C', 'D']) { it.toLowerCase() } == ['a', 'E']
      * </pre>
      *
-     * @param self     an Iterable
-     * @param removeMe an Iterable of elements to remove
-     * @param condition a Closure used to determine unique items
-     * @return a new Collection with the given elements removed
+     * @param self      an Iterable
+     * @param removeMe  the elements to exclude
+     * @param condition a Closure used to determine uniqueness
+     * @return a new Collection
      * @since 4.0.0
      */
     public static <T> Collection<T> minus(Iterable<T> self, Iterable<?> removeMe, @ClosureParams(value=FromString.class, options={"T","T,T"}) Closure condition) {
@@ -10870,67 +10874,66 @@ public static <T> Collection<T> minus(Iterable<T> self, Iterable<?> removeMe, @C
      * Create a new Collection composed of the elements of the first Iterable minus
      * every matching occurrence as determined by the condition comparator of elements of the given Iterable.
      * <pre class="groovyTestCase">
-     * assert ['a', 'B', 'c', 'D', 'E'].minus(['b', 'C', 'D'], {@code (i, j) -> i.toLowerCase() <=> j.toLowerCase()}) == ['a', 'E']
+     * List&lt;String> one = ['a', 'B', 'c', 'D', 'E'], two = ['b', 'C', 'D']
+     * def sub = one.minus(two, Comparator.comparing(String::toLowerCase))
+     * assert sub == ['a', 'E']
      * </pre>
      *
-     * @param self     an Iterable
-     * @param removeMe an Iterable of elements to remove
+     * @param self       an Iterable
+     * @param removeMe   the elements to exclude
      * @param comparator a Comparator
-     * @return a new Collection with the given elements removed
+     * @return a new Collection
      * @since 4.0.0
      */
-    @SuppressWarnings("unchecked")
     public static <T> Collection<T> minus(Iterable<T> self, Iterable<?> removeMe, Comparator<? super T> comparator) {
-        Collection<T> ansCollection = createSimilarCollection(self);
-        if (!self.iterator().hasNext())
-            return ansCollection;
-        T head = self.iterator().next();
-
-        // We can't use the same tactic as for intersection
-        // since AbstractCollection only does a remove on the first
-        // element it encounters.
-        boolean nlgnSort = sameType(new Iterable[]{self, removeMe});
-
-        if (nlgnSort && (head instanceof Comparable)) {
-            //n*LOG(n) version
-            Set<T> removeMe2 = new TreeSet<>(comparator);
-            for(Object o: removeMe) {
-                removeMe2.add((T) o);
-            }
-            for (T o : self) {
-                if (!removeMe2.contains(o))
-                    ansCollection.add(o);
-            }
-        } else {
-            //n*n version
-            Collection<T> tmpAnswer = asCollection(self);
-            for (Iterator<T> iter = self.iterator(); iter.hasNext();) {
-                T element = iter.next();
-                boolean elementRemoved = false;
-                for (Iterator<?> iterator = removeMe.iterator(); iterator.hasNext() && !elementRemoved;) {
-                    Object elt = iterator.next();
-                    if (DefaultTypeTransformation.compareEqual(element, elt)) {
-                        iter.remove();
-                        elementRemoved = true;
-                    }
+        Collection<T> answer = createSimilarCollection(self);
+        Iterator<T> iterator = self.iterator();
+        if (iterator.hasNext()) {
+            T next = iterator.next();
+            boolean more = iterator.hasNext();
+            Predicate exclude; // the elements of self are discarded if this returns true
+
+            // We can't use the same tactic as for intersection, since AbstractCollection
+            // only does a remove on the first element it encounters.
+            if (next instanceof Comparable && sameType(new Iterable[]{self, removeMe})) {
+                // O(log(n)) version
+                Set removeMe2 = new TreeSet<>(comparator);
+                for (Object o : removeMe) {
+                    removeMe2.add(o);
                 }
+                exclude = removeMe2::contains;
+            } else {
+                // O(n) version
+                exclude = (o1) -> {
+                    for (Object o2 : removeMe) {
+                        if (DefaultTypeTransformation.compareEqual(o1, o2)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
             }
 
-            //remove duplicates
-            //can't use treeset since the base classes are different
-            ansCollection.addAll(tmpAnswer);
+            while (true) {
+                if (!exclude.test(next))
+                    answer.add(next); // include duplicates unless answer dedups
+                if (!more) break; else {
+                    next = iterator.next();
+                    more = iterator.hasNext();
+                }
+            }
         }
-        return ansCollection;
+        return answer;
     }
 
     /**
      * Create a new List composed of the elements of the first List minus every occurrence of the
      * given element to remove.
      * <pre class="groovyTestCase">assert ["a", 5, 5, true] - 5 == ["a", true]</pre>
      *
-     * @param self     a List object
-     * @param removeMe an element to remove from the List
-     * @return the resulting List with the given element removed
+     * @param self     a List
+     * @param removeMe the element to exclude
+     * @return a new List
      * @since 1.0
      */
     public static <T> List<T> minus(List<T> self, Object removeMe) {
@@ -10942,41 +10945,43 @@ public static <T> List<T> minus(List<T> self, Object removeMe) {
      * given element to remove.
      * <pre class="groovyTestCase">assert ["a", 5, 5, true] - 5 == ["a", true]</pre>
      *
-     * @param self     an Iterable object
-     * @param removeMe an element to remove from the Iterable
-     * @return the resulting Collection with the given element removed
+     * @param self     an Iterable
+     * @param removeMe an element to exclude
+     * @return a new Collection
      * @since 2.4.0
      */
     public static <T> Collection<T> minus(Iterable<T> self, Object removeMe) {
-        Collection<T> ansList = createSimilarCollection(self);
+        Collection<T> answer = createSimilarCollection(self);
         for (T t : self) {
-            if (!coercedEquals(t, removeMe)) ansList.add(t);
+            if (!coercedEquals(t, removeMe)) {
+                answer.add(t);
+            }
         }
-        return ansList;
+        return answer;
     }
 
     /**
      * Create a Map composed of the entries of the first map minus the
      * entries of the given map.
      *
-     * @param self     a map object
-     * @param removeMe the entries to remove from the map
-     * @return the resulting map
+     * @param self     a Map
+     * @param removeMe the entries to exclude
+     * @return a new Map
      * @since 1.7.4
      */
     public static <K,V> Map<K,V> minus(Map<K,V> self, Map removeMe) {
-        final Map<K,V> ansMap = createSimilarMap(self);
-        ansMap.putAll(self);
+        Map<K,V> answer = createSimilarMap(self);
+        answer.putAll(self);
         if (removeMe != null && !removeMe.isEmpty()) {
-            for (Map.Entry<K, V> e1 : self.entrySet()) {
-                for (Object e2 : removeMe.entrySet()) {
+            for (var e1 : self.entrySet()) {
+                for (var e2 : removeMe.entrySet()) {
                     if (DefaultTypeTransformation.compareEqual(e1, e2)) {
-                        ansMap.remove(e1.getKey());
+                        answer.remove(e1.getKey());
                     }
                 }
             }
         }
-        return ansMap;
+        return answer;
     }
 
     /**