extract simplify forEach inspection: IDEA-CR-24052

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterBlockForEachToForEach.java

@@ -0,0 +1,10 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+      other.stream().filter(s -> s.length() > 2).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterBlockForEachToForEachComments.java

@@ -0,0 +1,12 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+      // c1
+//c2
+      other.stream().filter(s -> s.length() > 2).forEach(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterCollectionForEachBlock.java

@@ -0,0 +1,10 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test(List<String> strs) {
+      List<String> other = strs.stream().filter(s -> s.length() > 2).collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlock.java

@@ -0,0 +1,12 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> strs;
+    List<String> other = new ArrayList<>();
+      strs = other.stream().collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlockFilter.java

@@ -0,0 +1,12 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> strs;
+    List<String> other = new ArrayList<>();
+      strs = other.stream().filter(s -> s.length() > 2).collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlockFilterSortToArray.java

@@ -0,0 +1,10 @@
+// "Replace with toArray" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+      List<String> other = new ArrayList<>();
+      String[] arr = other.stream().filter(s -> s.length() > 2).sorted(String.CASE_INSENSITIVE_ORDER).toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlockFilterSortToList.java

@@ -0,0 +1,12 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> strs;
+    List<String> other = new ArrayList<>();
+      strs = other.stream().filter(s -> s.length() > 2).sorted(String::compareTo).collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlockForEachOrdered.java

@@ -0,0 +1,10 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+      other.stream().filter(s -> s.length() > 2).forEachOrdered(System.out::println);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachBlockInlineInitializer.java

@@ -0,0 +1,10 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test(List<String> other) {
+      List<String> strs = other.stream().collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachExpressionLambda.java

@@ -0,0 +1,12 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> strs;
+    List<String> other = new ArrayList<>();
+      strs = other.stream().collect(Collectors.toList());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachExpressionLambdaCount.java

@@ -0,0 +1,10 @@
+// "Replace with count()" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+      int count = (int) strs.stream().count();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachExpressionLambdaJoining.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+      String sb = strs.stream().collect(Collectors.joining());
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachExpressionLambdaToArray.java

@@ -0,0 +1,9 @@
+// "Replace with toArray" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test(List<String> strs) {
+      String[] arr = strs.toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/afterForEachExpressionLambdaToMap.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+      HashMap<Integer, String> map = other.stream().collect(Collectors.toMap(String::length, s -> s, (a, b) -> a, HashMap::new));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeBlockForEachToForEach.java

@@ -0,0 +1,12 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {
+      if(s.length() > 2) System.out.println(s);
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeBlockForEachToForEachComments.java

@@ -0,0 +1,12 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> { // c1
+      if(s.length() > 2) System.out.println(s); //c2
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeCollectionForEachBlock.java

@@ -0,0 +1,14 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test(List<String> strs) {
+    List<String> other = new ArrayList<>();
+    strs.stream().forEach<caret>(s -> {
+      if(s.length() > 2) {
+        other.add(s);
+      }
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlock.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {strs.add(s)});
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlockFilter.java

@@ -0,0 +1,13 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {
+      if(s.length() > 2) strs.add(s);
+    });
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlockFilterSortToArray.java

@@ -0,0 +1,17 @@
+// "Replace with toArray" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {
+      if(s.length() > 2) {
+        strs.add(s);
+      }
+    });
+    String[] arr = strs.toArray();
+    Arrays.sort(arr, String.CASE_INSENSITIVE_ORDER);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlockFilterSortToList.java

@@ -0,0 +1,16 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {
+      if(s.length() > 2) {
+        strs.add(s);
+      }
+    });
+    strs.sort(String::compareTo);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlockForEachOrdered.java

@@ -0,0 +1,10 @@
+// "Extract intermediate operations" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+    other.stream().forEachOrdered<caret>(s -> {if(s.length() > 2) System.out.println(s);});
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachBlockInlineInitializer.java

@@ -0,0 +1,10 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test(List<String> other) {
+    List<String> strs = new ArrayList<>();
+    other.stream().forEach<caret>(s -> {strs.add(s)});
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachExpressionLambda.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    List<String> other = new ArrayList<>();
+    other.stream().forEach<caret>(s -> strs.add(s));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachExpressionLambdaCount.java

@@ -0,0 +1,11 @@
+// "Replace with count()" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    int count = 0;
+    strs.stream().forEach<caret>(x -> count++)
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachExpressionLambdaJoining.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> strs = new ArrayList<>();
+    StringBuilder sb = new StringBuilder();
+    strs.stream().forEach<caret>(x -> sb.append(x));
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachExpressionLambdaToArray.java

@@ -0,0 +1,11 @@
+// "Replace with toArray" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test(List<String> strs) {
+    List<String> tmp = new ArrayList<>();
+    strs.stream().forEach<caret>(x -> tmp.add(x));
+    String[] arr = tmp.toArray();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/simplifyForEach/beforeForEachExpressionLambdaToMap.java

@@ -0,0 +1,11 @@
+// "Replace with collect" "true"
+
+import java.util.*;
+
+public class Main {
+  private void test() {
+    List<String> other = new ArrayList<>();
+    HashMap<Integer, String> map = new HashMap<Integer, String>();
+    other.stream().forEach<caret>(s -> map.putIfAbsent(s.length(), s));
+  }
+}