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. StreamFindAnyIsEmpty
  14. StreamFindAnyIsPresent
  15. StreamMapFilter
  16. StreamMin
  17. StreamMinNaturalOrder
  18. StreamMax
  19. StreamMaxNaturalOrder
  20. StreamNoneMatch
  21. StreamNoneMatch2
  22. StreamAnyMatch
  23. StreamAllMatch
  24. StreamAllMatch2
  25. StreamMapToIntSum
  26. StreamMapToDoubleSum
  27. StreamMapToLongSum
  28. StreamMapToIntSummaryStatistics
  29. StreamMapToDoubleSummaryStatistics
  30. StreamMapToLongSummaryStatistics
  31. StreamCount
  32. StreamReduce
  33. StreamReduceWithIdentity
  34. StreamFilterCollect
  35. StreamMapCollect
  36. StreamFlatMapCollect
  37. StreamsConcat
  38. StreamTakeWhile
  39. StreamIterate
  40. StreamOf1
  41. StreamOf2
  42. StreamOf3
  43. StreamOf4
  44. 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));
 }

StreamFindAnyIsEmpty

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 ImmutableSet<Boolean> testStreamFindAnyIsEmpty() {
   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(6).collect(collectingAndThen(toImmutableList(), List::isEmpty)),
-      Stream.of(7).collect(collectingAndThen(toImmutableList(), ImmutableList::isEmpty)),
-      Stream.of(8).collect(collectingAndThen(toImmutableMap(k -> k, v -> v), Map::isEmpty)),
-      Stream.of(9)
-          .collect(collectingAndThen(toImmutableMap(k -> k, v -> v), ImmutableMap::isEmpty)),
-      Stream.of(10).count() != 0,
-      Stream.of(11).count() > 0,
-      Stream.of(12).count() >= 1);
+      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(),
+      Stream.of(6).findAny().isEmpty(),
+      Stream.of(7).findAny().isEmpty(),
+      Stream.of(8).findAny().isEmpty(),
+      Stream.of(9).findAny().isEmpty(),
+      !Stream.of(10).findAny().isEmpty(),
+      !Stream.of(11).findAny().isEmpty(),
+      !Stream.of(12).findAny().isEmpty());
 }

StreamFindAnyIsPresent

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 boolean testStreamFindAnyIsPresent() {
-  return Stream.of(1).findFirst().isPresent();
+  return Stream.of(1).findAny().isPresent();
 }

StreamMapFilter

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 Stream<Integer> testStreamMapFilter() {
-  return Stream.of("foo")
-      .filter(ImmutableMap.of(1, 2)::containsKey)
-      .map(ImmutableMap.of(1, 2)::get);
+  return Stream.of("foo").map(ImmutableMap.of(1, 2)::get).filter(Objects::nonNull);
 }

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;
   Function<String, Boolean> toBooleanFunction = Boolean::valueOf;
   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() {
   Function<String, Boolean> toBooleanFunction = Boolean::valueOf;
   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;
   Function<String, Boolean> toBooleanFunction = Boolean::valueOf;
   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)),
       Stream.of(Stream.of(5), Stream.of(6)).flatMap(v -> Stream.empty()));
 }

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);
 }

Copyright © 2017-2024 Picnic Technologies BV