Fixes memory leak of grouped iterator

javaslang/src/main/java/javaslang/collection/Iterator.java

@@ -11,6 +11,7 @@
 import javaslang.Tuple3;
 import javaslang.collection.IteratorModule.ConcatIterator;
 import javaslang.collection.IteratorModule.DistinctIterator;
+import javaslang.collection.IteratorModule.GroupedIterator;
 import javaslang.control.Option;
 
 import java.math.BigDecimal;
@@ -20,6 +21,7 @@
 import static java.lang.Double.NEGATIVE_INFINITY;
 import static java.lang.Double.POSITIVE_INFINITY;
 import static java.math.RoundingMode.HALF_UP;
+import static javaslang.API.*;
 import static javaslang.collection.IteratorModule.BigDecimalHelper.areEqual;
 import static javaslang.collection.IteratorModule.BigDecimalHelper.asDecimal;
 import static javaslang.collection.IteratorModule.EmptyIterator;
@@ -1535,9 +1537,9 @@ default <C> Map<C, Iterator<T>> groupBy(Function<? super T, ? extends C> classif
 
     @Override
     default Iterator<Seq<T>> grouped(int size) {
-        return sliding(size, size);
+        return new GroupedIterator<>(this, size, size);
     }
-
+    
     @Override
     default boolean hasDefiniteSize() {
         return false;
@@ -1827,37 +1829,9 @@ default Iterator<Seq<T>> sliding(int size) {
 
     @Override
     default Iterator<Seq<T>> sliding(int size, int step) {
-        if (size <= 0 || step <= 0) {
-            throw new IllegalArgumentException("size: " + size + " or step: " + step + " not positive");
-        }
-        if (!hasNext()) {
-            return empty();
-        } else {
-            final Stream<T> source = Stream.ofAll(this);
-            return new AbstractIterator<Seq<T>>() {
-                private Stream<T> that = source;
-                private IndexedSeq<T> next = null;
-
-                @Override
-                public boolean hasNext() {
-                    while (next == null && !that.isEmpty()) {
-                        final Tuple2<Stream<T>, Stream<T>> split = that.splitAt(size);
-                        next = split._1.toVector();
-                        that = split._2.isEmpty() ? Stream.empty() : that.drop(step);
-                    }
-                    return next != null;
-                }
-
-                @Override
-                public IndexedSeq<T> getNext() {
-                    final IndexedSeq<T> result = next;
-                    next = null;
-                    return result;
-                }
-            };
-        }
+        return new GroupedIterator<>(this, size, step);
     }
-
+    
     @Override
     default Tuple2<Iterator<T>, Iterator<T>> span(Predicate<? super T> predicate) {
         Objects.requireNonNull(predicate, "predicate is null");
@@ -2089,6 +2063,40 @@ public String toString() {
         }
     }
 
+    final class GroupedIterator<T> implements Iterator<Seq<T>> {
+
+        private final Iterator<T> that;
+        private final int step;
+        private final int gap;
+
+        private List<T> buffer;
+
+        GroupedIterator(Iterator<T> that, int size, int step) {
+            if (size < 1 || step < 1) {
+                throw new IllegalArgumentException("size (" + size + ") and step (" + step + ") must both be positive");
+            }
+            this.that = that;
+            this.step = step;
+            this.gap = Math.max(step - size, 0);
+            this.buffer = List.ofAll(that.take(size));
+        }
+
+        @Override
+        public boolean hasNext() {
+            return !buffer.isEmpty();
+        }
+
+        @Override
+        public Seq<T> next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            final Seq<T> result = buffer;
+            buffer = that.hasNext() ? that.drop(gap).take(step).toList().prependAll(buffer.drop(step)) : buffer.take(0);
+            return result;
+        }
+    }
+
     final class BigDecimalHelper {
 
         @GwtIncompatible("Math::nextDown is not implemented")

javaslang/src/main/java/javaslang/collection/List.java

@@ -720,6 +720,12 @@ default <U> List<T> distinctBy(Function<? super T, ? extends U> keyExtractor) {
 
     @Override
     default List<T> drop(int n) {
+        if (n <= 0) {
+            return this;
+        }
+        if (n >= size()) {
+            return empty();
+        }
         List<T> list = this;
         for (long i = n; i > 0 && !list.isEmpty(); i--) {
             list = list.tail();
@@ -1390,12 +1396,12 @@ default Option<List<T>> tailOption() {
 
     @Override
     default List<T> take(int n) {
-        if (n >= length()) {
-            return this;
-        }
         if (n <= 0) {
             return empty();
         }
+        if (n >= length()) {
+            return this;
+        }
         List<T> result = Nil.instance();
         List<T> list = this;
         for (int i = 0; i < n; i++, list = list.tail()) {
@@ -1406,12 +1412,12 @@ default List<T> take(int n) {
 
     @Override
     default List<T> takeRight(int n) {
-        if (n >= length()) {
-            return this;
-        }
         if (n <= 0) {
             return empty();
         }
+        if (n >= length()) {
+            return this;
+        }
         return reverse().take(n).reverse();
     }