lambda函数 map和filter改为兼容多参数方式调用，解耦，删除废弃代码

src/main/java/org/ssssssss/expression/ExpressionEngine.java

@@ -23,7 +23,7 @@ public class ExpressionEngine {
 		list.add("yyy");
 		list.add("");
 		params.put("list", list);
-		Object result = engine.execute("${list.sort((a,b)->a.compareTo(b))}", params);
+		Object result = engine.execute("${list.filter((e,i)->i==1)}", params);
 		System.out.println(result);
 
 	}

src/main/java/org/ssssssss/expression/parsing/ArrayLikeLambdaExecutor.java

@@ -38,22 +38,6 @@ public class ArrayLikeLambdaExecutor {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    private static Object eachParse(Object arrayLike, Object argument, SPConsumer spConsumer) {
-        List<Object> results = null;
-        List<Object> args = (List<Object>) argument;
-        results = new ArrayList<>(args.size());
-        for (int j = 0; j < args.size(); j++) {
-            SourceAndParsed<Object, Object> result = (SourceAndParsed<Object, Object>) ((Supplier) args.get(j)).get();
-            spConsumer.accept(results, result);
-        }
-        Object result = toOriginType(arrayLike, results);
-        if (result != null) {
-            return result;
-        }
-        throw new RuntimeException("未实现");
-    }
-
     private static Object toOriginType(Object arrayLike, List<Object> results) {
         if (arrayLike instanceof Collection) {
             return results;
@@ -126,20 +110,47 @@ public class ArrayLikeLambdaExecutor {
 
     @SuppressWarnings("unchecked")
     public static Object map(Object arrayLike, Object... arguments) {
-        return eachParse(arrayLike, arguments[0], (list, sp) -> list.add(sp.getParsed()));
+        MultipleArgumentsLambda mal = (MultipleArgumentsLambda) arguments[0];
+        Function<Object[], Object> handler = mal.getHandler();
+        List<Object> coll = arrayLikeToList(arrayLike);
+        List<Object> results = new ArrayList<>(coll.size());
+        List<Object> args = new ArrayList<>(2);
+        for (int i = 0; i < coll.size(); i++) {
+            Object obj = coll.get(i);
+            args.clear();
+            args.add(obj);
+            if (mal.getArgs().size() > 1) {
+                args.add(i);
+            }
+            results.add(handler.apply(args.toArray()));
+        }
+        return toOriginType(arrayLike, results);
     }
 
     @SuppressWarnings("unchecked")
     public static Object filter(Object arrayLike, Object... arguments) {
-        return eachParse(arrayLike, arguments[0], (list, sp) -> {
-            if (sp.getParsed() instanceof Boolean) {
-                if ((Boolean)sp.getParsed()) {
-                    list.add(sp.getSource());
+        MultipleArgumentsLambda mal = (MultipleArgumentsLambda) arguments[0];
+        Function<Object[], Object> handler = mal.getHandler();
+        List<Object> coll = arrayLikeToList(arrayLike);
+        List<Object> results = new ArrayList<>(coll.size());
+        List<Object> args = new ArrayList<>(2);
+        for (int i = 0; i < coll.size(); i++) {
+            Object obj = coll.get(i);
+            args.clear();
+            args.add(obj);
+            if (mal.getArgs().size() > 1) {
+                args.add(i);
+            }
+            Object result = handler.apply(args.toArray());
+            if (result instanceof Boolean) {
+                if ((Boolean) result) {
+                    results.add(obj);
                 }
             } else {
                 throw new RuntimeException("lambda函数filter的结果非布尔类型");
             }
-        });
+        }
+        return toOriginType(arrayLike, results);
     }
 
 
@@ -172,33 +183,4 @@ public class ArrayLikeLambdaExecutor {
         }
     }
 
-    public interface SPConsumer {
-        void accept(List<Object> list, SourceAndParsed<Object, Object> sp);
-    }
-
-    public static class SourceAndParsed<S, P> {
-        private S source;
-        private P parsed;
-
-        public SourceAndParsed(S source, P parsed) {
-            this.source = source;
-            this.parsed = parsed;
-        }
-
-        public P getParsed() {
-            return parsed;
-        }
-
-        public void setParsed(P parsed) {
-            this.parsed = parsed;
-        }
-
-        public S getSource() {
-            return source;
-        }
-
-        public void setSource(S source) {
-            this.source = source;
-        }
-    }
 }

src/main/java/org/ssssssss/expression/parsing/Ast.java

@@ -1049,45 +1049,22 @@ public abstract class Ast {
                 }
                 if (arrLikeObj instanceof Collection) {
                     Collection<?> coll = (Collection<?>) arrLikeObj;
-                    if (elements.size() > 1) {
-                        AtomicInteger ai = new AtomicInteger();
-                        return new ArrayLikeLambdaExecutor.MultipleArgumentsLambda(elements, new Function<Object[], Object>() {
-                            @Override
-                            public Object apply(Object[] arguments) {
-                                try {
-                                    context.push();
-                                    for (int i = 0; i < elements.size() && i < arguments.length; i++) {
-                                        Expression expression = elements.get(i);
-                                        context.setOnCurrentScope(expression.getSpan().getText(), arguments[i]);
-                                    }
-                                    return function.evaluate(template, context);
-                                } catch (IOException e) {
-                                    e.printStackTrace();
-                                    throw new RuntimeException(e);
-                                } finally {
-                                    context.pop();
-                                }
-                            }
-                        });
-                    }
                     AtomicInteger ai = new AtomicInteger();
-                    return coll.stream().map(o -> ((Supplier) () -> {
+                    return new ArrayLikeLambdaExecutor.MultipleArgumentsLambda(elements, lambdaArgumentsValues -> {
                         try {
                             context.push();
-                            List<Expression> elements = getElements();
-                            for (Expression element : elements) {
-                                context.setOnCurrentScope(element.getSpan().getText(), o);
+                            for (int i = 0; i < elements.size() && i < lambdaArgumentsValues.length; i++) {
+                                Expression expression = elements.get(i);
+                                context.setOnCurrentScope(expression.getSpan().getText(), lambdaArgumentsValues[i]);
                             }
-                            context.setOnCurrentScope("_i", ai.getAndIncrement());
-                            Object res = function.evaluate(template, context);
-                            return new ArrayLikeLambdaExecutor.SourceAndParsed<>(o, res);
+                            return function.evaluate(template, context);
                         } catch (IOException e) {
                             e.printStackTrace();
                             throw new RuntimeException(e);
                         } finally {
                             context.pop();
                         }
-                    })).collect(Collectors.toList());
+                    });
                 }
             }
             return null;