StreamRules

SUGGESTION

Simplification

View source code on GitHub

Suppression

Disable all rules by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$).* as compiler argument.

Table of contents

1. Joining
2. EmptyStream
3. StreamOfNullable
4. StreamOfArray
5. ConcatOneStream
6. ConcatTwoStreams
7. FilterOuterStreamAfterFlatMap
8. MapOuterStreamAfterFlatMap
9. FlatMapOuterStreamAfterFlatMap
10. StreamFilterSorted
11. StreamFilterSortedWithComparator
12. StreamMapFirst
13. StreamIsEmpty
14. StreamIsNotEmpty
15. StreamMin
16. StreamMinNaturalOrder
17. StreamMax
18. StreamMaxNaturalOrder
19. StreamNoneMatch
20. StreamNoneMatch2
21. StreamAnyMatch
22. StreamAllMatch
23. StreamAllMatch2
24. StreamMapToIntSum
25. StreamMapToDoubleSum
26. StreamMapToLongSum
27. StreamMapToIntSummaryStatistics
28. StreamMapToDoubleSummaryStatistics
29. StreamMapToLongSummaryStatistics
30. StreamCount
31. StreamReduce
32. StreamReduceWithIdentity
33. StreamFilterCollect
34. StreamMapCollect
35. StreamFlatMapCollect
36. StreamsConcat
37. StreamTakeWhile
38. StreamIterate
39. StreamOf1
40. StreamOf2
41. StreamOf3
42. StreamOf4
43. StreamOf5

Joining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("Joining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$Joining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 String testJoining() {
-    return Stream.of("foo").collect(joining(""));
+    return Stream.of("foo").collect(joining());
   }

EmptyStream

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("EmptyStream") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$EmptyStream).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<String> testEmptyStream() {
-    return Stream.of();
+    return Stream.empty();
   }

StreamOfNullable

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOfNullable") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOfNullable).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Stream<String>> testStreamOfNullable() {
-    return ImmutableSet.of(
-        Stream.of("a").filter(Objects::nonNull), Optional.ofNullable("b").stream());
+    return ImmutableSet.of(Stream.ofNullable("a"), Stream.ofNullable("b"));
   }

StreamOfArray

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOfArray") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOfArray).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<String> testStreamOfArray() {
-    return Stream.of(new String[] {"foo", "bar"});
+    return Arrays.stream(new String[] {"foo", "bar"});
   }

ConcatOneStream

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ConcatOneStream") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$ConcatOneStream).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testConcatOneStream() {
-    return Streams.concat(Stream.of(1));
+    return Stream.of(1);
   }

ConcatTwoStreams

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ConcatTwoStreams") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$ConcatTwoStreams).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testConcatTwoStreams() {
-    return Streams.concat(Stream.of(1), Stream.of(2));
+    return Stream.concat(Stream.of(1), Stream.of(2));
   }

FilterOuterStreamAfterFlatMap

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FilterOuterStreamAfterFlatMap") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$FilterOuterStreamAfterFlatMap).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testFilterOuterStreamAfterFlatMap() {
-    return Stream.of("foo").flatMap(v -> Stream.of(v.length()).filter(len -> len > 0));
+    return Stream.of("foo").flatMap(v -> Stream.of(v.length())).filter(len -> len > 0);
   }

MapOuterStreamAfterFlatMap

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MapOuterStreamAfterFlatMap") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$MapOuterStreamAfterFlatMap).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testMapOuterStreamAfterFlatMap() {
-    return Stream.of("foo").flatMap(v -> Stream.of(v.length()).map(len -> len * 0));
+    return Stream.of("foo").flatMap(v -> Stream.of(v.length())).map(len -> len * 0);
   }

FlatMapOuterStreamAfterFlatMap

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FlatMapOuterStreamAfterFlatMap") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$FlatMapOuterStreamAfterFlatMap).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testFlatMapOuterStreamAfterFlatMap() {
-    return Stream.of("foo").flatMap(v -> Stream.of(v.length()).flatMap(Stream::of));
+    return Stream.of("foo").flatMap(v -> Stream.of(v.length())).flatMap(Stream::of);
   }

StreamFilterSorted

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamFilterSorted") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamFilterSorted).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamFilterSorted() {
-    return Stream.of(1, 4, 3, 2).sorted().filter(i -> i % 2 == 0);
+    return Stream.of(1, 4, 3, 2).filter(i -> i % 2 == 0).sorted();
   }

StreamFilterSortedWithComparator

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamFilterSortedWithComparator") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamFilterSortedWithComparator).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamFilterSortedWithComparator() {
-    return Stream.of(1, 4, 3, 2).sorted(reverseOrder()).filter(i -> i % 2 == 0);
+    return Stream.of(1, 4, 3, 2).filter(i -> i % 2 == 0).sorted(reverseOrder());
   }

StreamMapFirst

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapFirst") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapFirst).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Optional<Integer>> testStreamMapFirst() {
     return ImmutableSet.of(
-        Stream.of("foo").map(s -> s.length()).findFirst(),
-        Stream.of("bar").map(String::length).findFirst());
+        Stream.of("foo").findFirst().map(s -> s.length()),
+        Stream.of("bar").findFirst().map(String::length));
   }

StreamIsEmpty

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamIsEmpty") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamIsEmpty).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamIsEmpty() {
     return ImmutableSet.of(
-        Stream.of(1).count() == 0,
-        Stream.of(2).count() <= 0,
-        Stream.of(3).count() < 1,
-        Stream.of(4).findFirst().isEmpty(),
-        Stream.of(5).collect(toImmutableSet()).isEmpty());
+        Stream.of(1).findAny().isEmpty(),
+        Stream.of(2).findAny().isEmpty(),
+        Stream.of(3).findAny().isEmpty(),
+        Stream.of(4).findAny().isEmpty(),
+        Stream.of(5).findAny().isEmpty());
   }

StreamIsNotEmpty

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamIsNotEmpty") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamIsNotEmpty).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamIsNotEmpty() {
     return ImmutableSet.of(
-        Stream.of(1).count() != 0,
-        Stream.of(2).count() > 0,
-        Stream.of(3).count() >= 1,
-        Stream.of(4).findFirst().isPresent());
+        Stream.of(1).findAny().isPresent(),
+        Stream.of(2).findAny().isPresent(),
+        Stream.of(3).findAny().isPresent(),
+        Stream.of(4).findAny().isPresent());
   }

StreamMin

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMin") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMin).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Optional<String>> testStreamMin() {
     return ImmutableSet.of(
-        Stream.of("foo").max(comparingInt(String::length).reversed()),
-        Stream.of("bar").sorted(comparingInt(String::length)).findFirst(),
-        Stream.of("baz").collect(minBy(comparingInt(String::length))));
+        Stream.of("foo").min(comparingInt(String::length)),
+        Stream.of("bar").min(comparingInt(String::length)),
+        Stream.of("baz").min(comparingInt(String::length)));
   }

StreamMinNaturalOrder

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMinNaturalOrder") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMinNaturalOrder).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Optional<String>> testStreamMinNaturalOrder() {
     return ImmutableSet.of(
-        Stream.of("foo").max(reverseOrder()), Stream.of("bar").sorted().findFirst());
+        Stream.of("foo").min(naturalOrder()), Stream.of("bar").min(naturalOrder()));
   }

StreamMax

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMax") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMax).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Optional<String>> testStreamMax() {
     return ImmutableSet.of(
-        Stream.of("foo").min(comparingInt(String::length).reversed()),
-        Streams.findLast(Stream.of("bar").sorted(comparingInt(String::length))),
-        Stream.of("baz").collect(maxBy(comparingInt(String::length))));
+        Stream.of("foo").max(comparingInt(String::length)),
+        Stream.of("bar").max(comparingInt(String::length)),
+        Stream.of("baz").max(comparingInt(String::length)));
   }

StreamMaxNaturalOrder

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMaxNaturalOrder") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMaxNaturalOrder).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Optional<String>> testStreamMaxNaturalOrder() {
     return ImmutableSet.of(
-        Stream.of("foo").min(reverseOrder()), Streams.findLast(Stream.of("bar").sorted()));
+        Stream.of("foo").max(naturalOrder()), Stream.of("bar").max(naturalOrder()));
   }

StreamNoneMatch

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamNoneMatch") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamNoneMatch).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamNoneMatch() {
     Predicate<String> pred = String::isBlank;
     // Not using Boolean::valueOf due to
     // https://github.com/google/error-prone/pull/4157.
     Function<String, Boolean> toBooleanFunction = s -> false;
     return ImmutableSet.of(
-        !Stream.of("foo").anyMatch(s -> s.length() > 1),
-        Stream.of("bar").allMatch(not(String::isBlank)),
-        Stream.of("baz").allMatch(pred.negate()),
-        Stream.of("qux").filter(String::isEmpty).findAny().isEmpty(),
-        Stream.of("quux").map(s -> s.isBlank()).noneMatch(Boolean::booleanValue),
-        Stream.of("quuz").map(Boolean::valueOf).noneMatch(r -> r),
+        Stream.of("foo").noneMatch(s -> s.length() > 1),
+        Stream.of("bar").noneMatch(String::isBlank),
+        Stream.of("baz").noneMatch(pred),
+        Stream.of("qux").noneMatch(String::isEmpty),
+        Stream.of("quux").noneMatch(s -> s.isBlank()),
+        Stream.of("quuz").noneMatch(Boolean::valueOf),
         Stream.of("corge").map(toBooleanFunction).noneMatch(Boolean::booleanValue));
   }

StreamNoneMatch2

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamNoneMatch2") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamNoneMatch2).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamNoneMatch2() {
     return ImmutableSet.of(
-        Stream.of("foo").allMatch(s -> !s.isBlank()), Stream.of(Boolean.TRUE).allMatch(b -> !b));
+        Stream.of("foo").noneMatch(s -> s.isBlank()), Stream.of(Boolean.TRUE).noneMatch(b -> b));
   }

StreamAnyMatch

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamAnyMatch") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamAnyMatch).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamAnyMatch() {
     // Not using Boolean::valueOf due to
     // https://github.com/google/error-prone/pull/4157.
     Function<String, Boolean> toBooleanFunction = s -> false;
     return ImmutableSet.of(
-        !Stream.of("foo").noneMatch(s -> s.length() > 1),
-        Stream.of("bar").filter(String::isEmpty).findAny().isPresent(),
-        Stream.of("baz").map(s -> s.isBlank()).anyMatch(Boolean::booleanValue),
-        Stream.of("qux").map(Boolean::valueOf).anyMatch(r -> r),
+        Stream.of("foo").anyMatch(s -> s.length() > 1),
+        Stream.of("bar").anyMatch(String::isEmpty),
+        Stream.of("baz").anyMatch(s -> s.isBlank()),
+        Stream.of("qux").anyMatch(Boolean::valueOf),
         Stream.of("quux").map(toBooleanFunction).anyMatch(Boolean::booleanValue));
   }

StreamAllMatch

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamAllMatch") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamAllMatch).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testStreamAllMatch() {
     Predicate<String> pred = String::isBlank;
     // Not using Boolean::valueOf due to
     // https://github.com/google/error-prone/pull/4157.
     Function<String, Boolean> toBooleanFunction = s -> false;
     return ImmutableSet.of(
-        Stream.of("foo").noneMatch(not(String::isBlank)),
-        Stream.of("bar").noneMatch(pred.negate()),
-        Stream.of("baz").map(s -> s.isBlank()).allMatch(Boolean::booleanValue),
-        Stream.of("qux").map(Boolean::valueOf).allMatch(r -> r),
+        Stream.of("foo").allMatch(String::isBlank),
+        Stream.of("bar").allMatch(pred),
+        Stream.of("baz").allMatch(s -> s.isBlank()),
+        Stream.of("qux").allMatch(Boolean::valueOf),
         Stream.of("quux").map(toBooleanFunction).anyMatch(Boolean::booleanValue));
   }

StreamAllMatch2

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamAllMatch2") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamAllMatch2).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 boolean testStreamAllMatch2() {
-    return Stream.of("foo").noneMatch(s -> !s.isBlank());
+    return Stream.of("foo").allMatch(s -> s.isBlank());
   }

StreamMapToIntSum

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToIntSum") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToIntSum).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Integer> testStreamMapToIntSum() {
     Function<String, Integer> parseIntFunction = Integer::parseInt;
     return ImmutableSet.of(
-        Stream.of("1").collect(summingInt(Integer::parseInt)),
-        Stream.of(2).map(i -> i * 2).reduce(0, Integer::sum),
-        Stream.of("3").map(Integer::parseInt).reduce(0, Integer::sum),
+        Stream.of("1").mapToInt(Integer::parseInt).sum(),
+        Stream.of(2).mapToInt(i -> i * 2).sum(),
+        Stream.of("3").mapToInt(Integer::parseInt).sum(),
         Stream.of("4").map(parseIntFunction).reduce(0, Integer::sum));
   }

StreamMapToDoubleSum

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToDoubleSum") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToDoubleSum).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Double> testStreamMapToDoubleSum() {
     Function<String, Double> parseDoubleFunction = Double::parseDouble;
     return ImmutableSet.of(
-        Stream.of("1").collect(summingDouble(Double::parseDouble)),
-        Stream.of(2).map(i -> i * 2.0).reduce(0.0, Double::sum),
-        Stream.of("3").map(Double::parseDouble).reduce(0.0, Double::sum),
+        Stream.of("1").mapToDouble(Double::parseDouble).sum(),
+        Stream.of(2).mapToDouble(i -> i * 2.0).sum(),
+        Stream.of("3").mapToDouble(Double::parseDouble).sum(),
         Stream.of("4").map(parseDoubleFunction).reduce(0.0, Double::sum));
   }

StreamMapToLongSum

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToLongSum") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToLongSum).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Long> testStreamMapToLongSum() {
     Function<String, Long> parseLongFunction = Long::parseLong;
     return ImmutableSet.of(
-        Stream.of("1").collect(summingLong(Long::parseLong)),
-        Stream.of(2).map(i -> i * 2L).reduce(0L, Long::sum),
-        Stream.of("3").map(Long::parseLong).reduce(0L, Long::sum),
+        Stream.of("1").mapToLong(Long::parseLong).sum(),
+        Stream.of(2).mapToLong(i -> i * 2L).sum(),
+        Stream.of("3").mapToLong(Long::parseLong).sum(),
         Stream.of("4").map(parseLongFunction).reduce(0L, Long::sum));
   }

StreamMapToIntSummaryStatistics

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToIntSummaryStatistics") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToIntSummaryStatistics).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 IntSummaryStatistics testStreamMapToIntSummaryStatistics() {
-    return Stream.of("1").collect(summarizingInt(Integer::parseInt));
+    return Stream.of("1").mapToInt(Integer::parseInt).summaryStatistics();
   }

StreamMapToDoubleSummaryStatistics

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToDoubleSummaryStatistics") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToDoubleSummaryStatistics).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 DoubleSummaryStatistics testStreamMapToDoubleSummaryStatistics() {
-    return Stream.of("1").collect(summarizingDouble(Double::parseDouble));
+    return Stream.of("1").mapToDouble(Double::parseDouble).summaryStatistics();
   }

StreamMapToLongSummaryStatistics

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapToLongSummaryStatistics") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapToLongSummaryStatistics).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 LongSummaryStatistics testStreamMapToLongSummaryStatistics() {
-    return Stream.of("1").collect(summarizingLong(Long::parseLong));
+    return Stream.of("1").mapToLong(Long::parseLong).summaryStatistics();
   }

StreamCount

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamCount") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamCount).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Long testStreamCount() {
-    return Stream.of(1).collect(counting());
+    return Stream.of(1).count();
   }

StreamReduce

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamReduce") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamReduce).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Optional<Integer> testStreamReduce() {
-    return Stream.of(1).collect(reducing(Integer::sum));
+    return Stream.of(1).reduce(Integer::sum);
   }

StreamReduceWithIdentity

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamReduceWithIdentity") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamReduceWithIdentity).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Integer testStreamReduceWithIdentity() {
-    return Stream.of(1).collect(reducing(0, Integer::sum));
+    return Stream.of(1).reduce(0, Integer::sum);
   }

StreamFilterCollect

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamFilterCollect") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamFilterCollect).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<String> testStreamFilterCollect() {
-    return Stream.of("1").collect(filtering(String::isEmpty, toImmutableSet()));
+    return Stream.of("1").filter(String::isEmpty).collect(toImmutableSet());
   }

StreamMapCollect

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamMapCollect") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamMapCollect).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Integer> testStreamMapCollect() {
-    return Stream.of("1").collect(mapping(Integer::parseInt, toImmutableSet()));
+    return Stream.of("1").map(Integer::parseInt).collect(toImmutableSet());
   }

StreamFlatMapCollect

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamFlatMapCollect") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamFlatMapCollect).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Integer> testStreamFlatMapCollect() {
-    return Stream.of(1).collect(flatMapping(n -> Stream.of(n, n), toImmutableSet()));
+    return Stream.of(1).flatMap(n -> Stream.of(n, n)).collect(toImmutableSet());
   }

StreamsConcat

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamsConcat") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamsConcat).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Stream<Integer>> testStreamsConcat() {
     return ImmutableSet.of(
-        Stream.of(Stream.of(1), Stream.of(2)).flatMap(identity()),
-        Stream.of(Stream.of(3), Stream.of(4)).flatMap(v -> v));
+        Streams.concat(Stream.of(1), Stream.of(2)), Streams.concat(Stream.of(3), Stream.of(4)));
   }

StreamTakeWhile

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamTakeWhile") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamTakeWhile).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamTakeWhile() {
-    return Stream.of(1, 2, 3).takeWhile(i -> i < 2).filter(i -> i < 2);
+    return Stream.of(1, 2, 3).takeWhile(i -> i < 2);
   }

StreamIterate

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamIterate") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamIterate).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamIterate() {
-    return Stream.iterate(0, i -> i + 1).takeWhile(i -> i < 10);
+    return Stream.iterate(0, i -> i < 10, i -> i + 1);
   }

StreamOf1

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOf1") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOf1).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamOf1() {
-    return ImmutableList.of(1).stream();
+    return Stream.of(1);
   }

StreamOf2

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOf2") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOf2).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamOf2() {
-    return ImmutableList.of(1, 2).stream();
+    return Stream.of(1, 2);
   }

StreamOf3

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOf3") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOf3).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamOf3() {
-    return ImmutableList.of(1, 2, 3).stream();
+    return Stream.of(1, 2, 3);
   }

StreamOf4

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOf4") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOf4).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamOf4() {
-    return ImmutableList.of(1, 2, 3, 4).stream();
+    return Stream.of(1, 2, 3, 4);
   }

StreamOf5

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("StreamOf5") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!StreamRules\$StreamOf5).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Stream<Integer> testStreamOf5() {
-    return ImmutableList.of(1, 2, 3, 4, 5).stream();
+    return Stream.of(1, 2, 3, 4, 5);
   }