diff --git a/src/main/java/com/annimon/stream/Stream.java b/src/main/java/com/annimon/stream/Stream.java
index 3c4f96d4..b0ed6bd4 100644
--- a/src/main/java/com/annimon/stream/Stream.java
+++ b/src/main/java/com/annimon/stream/Stream.java
@@ -659,7 +659,59 @@ public int compare(T o1, T o2) {
     public <K> Stream<Map.Entry<K, List<T>>> groupBy(final Function<? super T, ? extends K> classifier) {
         return Stream.of( collect(Collectors.groupingBy(classifier)) );
     }
+	
+    /**
+     * Partitions {@code Stream} into {@code List}s according to the given classifier function. In contrast
+     * to {@link #groupBy(Function)}, this method assumes that the elements of the stream are sorted.
+     * Because of this assumption, it does not need to first collect all elements and then partition them.
+     * Instead, it can emit a {@code List} of elements when it reaches the first element that does not
+     * belong to the same chunk as the previous elements.
+     * <p>
+     * <p>This is an intermediate operation.
+     *
+     * @param <K> the type of the keys, which are the result of the classifier function
+     * @param classifier the classifier function
+     * @return the new stream
+     */
+    public <K> Stream<List<T>> chunkBy(final Function<? super T, ? extends K> classifier) {
+        return new Stream<List<T>>(new LsaIterator<List<T>>() {
+            private T next;
+            private boolean peekedNext;
+
+            @Override
+            public boolean hasNext() {
+                return peekedNext || iterator.hasNext();
+            }
+
+            @Override
+            public List<T> next() {
+                K key = classifier.apply(peek());
 
+                List<T> list = new ArrayList<T>();
+                do {
+                    list.add(takeNext());
+                }
+                while (iterator.hasNext() && key.equals(classifier.apply(peek())));
+
+                return list;
+            }
+
+            private T takeNext() {
+                T element = peek();
+                peekedNext = false;
+                return element;
+            }
+
+            private T peek() {
+                if (!peekedNext) {
+                    next = iterator.next();
+                    peekedNext = true;
+                }
+                return next;
+            }
+        });
+    }
+    
     /**
      * Perform provided action to each elements.
      *
diff --git a/src/test/java/com/annimon/stream/StreamTest.java b/src/test/java/com/annimon/stream/StreamTest.java
index 9d48f884..ddcdc9f3 100644
--- a/src/test/java/com/annimon/stream/StreamTest.java
+++ b/src/test/java/com/annimon/stream/StreamTest.java
@@ -489,6 +489,20 @@ public void accept(Map.Entry<Boolean, List<Integer>> entry) {
         assertEquals("[2, 3, 2, 3, 2, 3]", pc2.toString());
     }
 
+    @Test
+    public void testChunkBy() {
+        final PrintConsumer<List<Integer>> consumer = new PrintConsumer<List<Integer>>();
+
+        Stream.of(1, 1, 2, 2, 2, 3, 1).chunkBy(new Function<Integer, Integer>() {
+            @Override
+            public Integer apply(Integer value) {
+                return value;
+            }
+        }).forEach(consumer);
+
+        assertEquals("[1, 1][2, 2, 2][3][1]", consumer.toString());
+    }
+	
     @Test
     public void testPeek() {
         final PrintConsumer<Integer> consumer = new PrintConsumer<Integer>();