반응형
자바에는 eval() 함수가 있나요?
다음과 같은 문자열이 있습니다.
String str = "4*5";
에는 제가 를 받아봐야겠네요.20트링스
있다eval()함수가 이 작업을 수행합니다.바에서 어떻 ??? ??? ???
클래스를 사용하여 Javascript 문자열로 평가할 수 있습니다.
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
Object result = engine.eval("4*5");
더 좋은 방법이 있을지도 모르지만, 이 방법은 효과가 있어요.
원하는 작업을 수행하는 표준 Java 클래스나 메서드는 없습니다.옵션은 다음과 같습니다.
일부 타사 식 평가 라이브러리를 선택하여 사용합니다.예를 들어, JEL이나 여기에 나열된 6개의 라이브러리 중 하나입니다.
.
evalmethod, Java 컴 method method method method method method method method method method method method method method method method method method method method method 。표현식 평가자로 Java에서 호출할 수 있는 스크립트 언어를 사용합니다.Javascript, BeanShell 등을 사용할1 수 있습니다.JSR 223 준거 스크립트 언어 실장은 스크립트 API를 통해 호출할 수 있습니다.
표현식 평가자를 처음부터 직접 작성합니다.
첫 번째 접근법이 아마도 가장 간단할 것이다.두 번째 접근법과 세 번째 접근법은 신뢰할 수 없는 사용자로부터 평가되는 식을 얻을 경우 잠재적인 보안 위험이 있습니다.(코드 주입을 생각해 보세요.)
1 - Java SE의 Javascript는 이동 대상입니다.Java 6부터는 Mozilla의 Rhino Javascript 구현 버전이 Java SE와 함께 번들되었습니다.Java 8에서는 Nashorn으로 대체되었습니다.Java 11에서 Nashorn은 폐지되었고 마침내 코어 코드베이스에서 삭제되었다.2021년 현재 Rhino와 Nashorn은 모두 별도의 (Oracle이 아닌) 제품으로 유지되고 있으며 Oracle의 GraalVM은 자체 Javascript를 구현하고 있습니다.
.StringJava 코드의 fragment가 필요하거나 필요하기 때문입니다.즉, 이 방법을 묻는 것은 XY의 문제입니다.실제로 다른 문제를 안고 있습니다.이 문제는 다른 방법으로 해결할 수 있습니다.
자신에게, 요?String당신이 평가하고자 하는 것은 무엇입니까?프로그램의 다른 부분이 생성했습니까, 아니면 사용자가 입력한 것입니까?
프로그램의 다른 부분에서 생성했습니다.프로그램의 한 부분은 실행할 조작의 종류를 결정하고, 다른 부분은 선택한 조작을 실행하는 것을 원하지 않습니다.를 생성하여 평가하는 대신
String특정 상황에 따라 Strategy, Command 또는 Builder 설계 패턴을 사용합니다.사용자 입력입니다.사용자는 명령어를 포함한 모든 것을 입력할 수 있습니다.이 명령어를 실행하면 프로그램이 잘못 동작하거나 크래시하거나 기밀이어야 할 정보가 노출되거나 영속적인 정보(데이터베이스의 내용 등)가 손상되거나 기타 악질적인 것이 될 수 있습니다.이를 방지하는 유일한 방법은 이 명령어를 해석하는 것입니다.
String★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★은 가 한 작업 중 부분을 차지합니다.eval기능을 사용할 수 있기 때문에, 아무것도 보존할 수고를 끼쳤습니다.으로, 그 자의적인 것을Java체크가 정지 문제이기 때문에 악의가 있는 것은 아닙니다.사용자 입력이지만 평가할 수 있는 텍스트의 구문과 의미는 크게 제한됩니다.어떤 범용 설비도 선택한 제한된 구문 및 의미에 대해 범용 파서와 평가자를 쉽게 구현할 수 없습니다.필요한 것은 선택한 구문과 의미론에 대해 파서와 평가자를 구현하는 것입니다.작업이 간단한 경우 간단한 재귀-하강 또는 유한 상태 머신 파서를 손으로 작성할 수 있습니다.작업이 어려운 경우 컴파일러(ANTLR 등)를 사용하여 일부 작업을 수행할 수 있습니다.
데스크톱 계산기를 구현하기만 하면 됩니다.숙제라니, 응?를 사용하여 입력식의 평가를 구현할 수 있는 경우
eval별로 숙제가 되지 않겠죠, 그렇죠?당신의 프로그램은 세 줄 정도 될 거예요.당신의 강사는 아마도 당신이 간단한 산술 파서/평가자를 위한 코드를 쓰기를 기대하고 있을 것이다.shunting-yard라는 잘 알려진 알고리즘이 있습니다. 이 알고리즘은 유용하다고 생각하실 수 있습니다.
Java 9 에서는, 에 액세스 할 수 있기 때문에, 다음과 같이 기술할 수 있습니다.
import jdk.jshell.JShell;
import java.lang.StringBuilder;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Eval {
public static void main(String[] args) throws IOException {
try(JShell js = JShell.create(); BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
js.onSnippetEvent(snip -> {
if (snip.status() == jdk.jshell.Snippet.Status.VALID) {
System.out.println("➜ " + snip.value());
}
});
System.out.print("> ");
for (String line = br.readLine(); line != null; line = br.readLine()) {
js.eval(js.sourceCodeAnalysis().analyzeCompletion(line).source());
System.out.print("> ");
}
}
}
}
샘플 실행:
> 1 + 2 / 4 * 3
➜ 1
> 32 * 121
➜ 3872
> 4 * 5
➜ 20
> 121 * 51
➜ 6171
>
약간은 op이지만, 현재 Java가 제공하는 것은 이것입니다.
Exp4j를 사용하라고 조언해 드릴 말씀이 있습니다.다음 코드 예에서 알 수 있듯이 쉽게 이해할 수 있습니다.
Expression e = new ExpressionBuilder("3 * sin(y) - 2 / (x - 2)")
.variables("x", "y")
.build()
.setVariable("x", 2.3)
.setVariable("y", 3.14);
double result = e.evaluate();
아니요, Java(또는 컴파일된 언어)에서는 일반 "평가"를 사용할 수 없습니다.Java 컴파일러와 Java 프로그램 내에서 실행할 JVM을 작성할 의사가 없는 한.
예, 위와 같은 숫자 대수식을 평가하기 위한 라이브러리를 사용할 수 있습니다. 자세한 내용은 이 스레드를 참조하십시오.
이전 답변과 같이 Java에는 이를 위한 표준 API가 없습니다.
경로 및 groovy.util에 groovy jar 파일을 추가할 수 있습니다.Eval.me (4*5")를 사용하면 작업이 완료됩니다.
문제를 해결하는 재미있는 방법은 스스로 eval() 함수를 코딩하는 것입니다.널 위해 한 거야!
FunctionSolver 라이브러리를 사용하려면 코드 안에 FunctionSolver.solveByX(function, value)를 입력합니다.함수 속성은 해결할 함수를 나타내는 문자열입니다.값 속성은 함수의 독립 변수 값(x여야 함)입니다.
여러 개의 독립 변수를 포함하는 함수를 해결하려면 FunctionSolver.solve(함수, 값)를 사용할 수 있습니다.여기서 값 속성은 모든 독립 속성(String, Double)과 각각의 값(Double)을 포함하는 HashMap(String, Double)입니다.
또 다른 정보:FunctionSolver의 단순한 버전을 코드화했기 때문에 이중값을 반환하고 FunctionSolver.usableMathMethods()를 필드로 사용하는 Math 메서드만 지원합니다.(이 메서드는 bs, sin, cos, tan, atan2, sqrt, log, pow, exp, max sign, min sign, min, min.asin, atan, cbrt, ceil, cosh, expm1, 플로어, 저울, log1p, nextDown, nextUp, random, rint, sinh, tanh, toDegrees, toRadians, ulp).또한 이 라이브러리는 * / + - ^ 연산자를 지원합니다(Java가 보통 ^ 연산자를 지원하지 않더라도).
마지막으로 이 라이브러리를 만드는 동안 반사 기능을 사용하여 수학 메서드를 호출해야 했습니다.정말 멋진 것 같아, 관심있으면 이것만 봐!
이상입니다. 다음은 코드(및 라이브러리)입니다.
package core;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
public abstract class FunctionSolver {
public static double solveNumericExpression (String expression) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
return solve(expression, new HashMap<>());
}
public static double solveByX (String function, double value) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
HashMap<String, Double> values = new HashMap<>();
values.put("x", value);
return solveComplexFunction(function, function, values);
}
public static double solve (String function, HashMap<String,Double> values) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
return solveComplexFunction(function, function, values);
}
private static double solveComplexFunction (String function, String motherFunction, HashMap<String, Double> values) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
int position = 0;
while(position < function.length()) {
if (alphabetic.contains(""+function.charAt(position))) {
if (position == 0 || !alphabetic.contains(""+function.charAt(position-1))) {
int endIndex = -1;
for (int j = position ; j < function.length()-1 ; j++) {
if (alphabetic.contains(""+function.charAt(j))
&& !alphabetic.contains(""+function.charAt(j+1))) {
endIndex = j;
break;
}
}
if (endIndex == -1 & alphabetic.contains(""+function.charAt(function.length()-1))) {
endIndex = function.length()-1;
}
if (endIndex != -1) {
String alphabeticElement = function.substring(position, endIndex+1);
if (Arrays.asList(usableMathMethods()).contains(alphabeticElement)) {
//Start analyzing a Math function
int closeParenthesisIndex = -1;
int openedParenthesisquantity = 0;
int commaIndex = -1;
for (int j = endIndex+1 ; j < function.length() ; j++) {
if (function.substring(j,j+1).equals("(")) {
openedParenthesisquantity++;
}else if (function.substring(j,j+1).equals(")")) {
openedParenthesisquantity--;
if (openedParenthesisquantity == 0) {
closeParenthesisIndex = j;
break;
}
}else if (function.substring(j,j+1).equals(",") & openedParenthesisquantity == 0) {
if (commaIndex == -1) {
commaIndex = j;
}else{
throw new IllegalArgumentException("The argument of math function (which is "+alphabeticElement+") has too many commas");
}
}
}
if (closeParenthesisIndex == -1) {
throw new IllegalArgumentException("The argument of a Math function (which is "+alphabeticElement+") hasn't got the closing bracket )");
}
String functionArgument = function.substring(endIndex+2,closeParenthesisIndex);
if (commaIndex != -1) {
double firstParameter = solveComplexFunction(functionArgument.substring(0,commaIndex),motherFunction,values);
double secondParameter = solveComplexFunction(functionArgument.substring(commaIndex+1),motherFunction,values);
Method mathMethod = Math.class.getDeclaredMethod(alphabeticElement, new Class<?>[] {double.class, double.class});
mathMethod.setAccessible(true);
String newKey = getNewKey(values);
values.put(newKey, (Double) mathMethod.invoke(null, firstParameter, secondParameter));
function = function.substring(0, position)+newKey
+((closeParenthesisIndex == function.length()-1)?(""):(function.substring(closeParenthesisIndex+1)));
}else {
double firstParameter = solveComplexFunction(functionArgument, motherFunction, values);
Method mathMethod = Math.class.getDeclaredMethod(alphabeticElement, new Class<?>[] {double.class});
mathMethod.setAccessible(true);
String newKey = getNewKey(values);
values.put(newKey, (Double) mathMethod.invoke(null, firstParameter));
function = function.substring(0, position)+newKey
+((closeParenthesisIndex == function.length()-1)?(""):(function.substring(closeParenthesisIndex+1)));
}
}else if (!values.containsKey(alphabeticElement)) {
throw new IllegalArgumentException("Found a group of letters ("+alphabeticElement+") which is neither a variable nor a Math function: ");
}
}
}
}
position++;
}
return solveBracketsFunction(function,motherFunction,values);
}
private static double solveBracketsFunction (String function,String motherFunction,HashMap<String, Double> values) throws IllegalArgumentException{
function = function.replace(" ", "");
String openingBrackets = "([{";
String closingBrackets = ")]}";
int parenthesisIndex = 0;
do {
int position = 0;
int openParenthesisBlockIndex = -1;
String currentOpeningBracket = openingBrackets.charAt(parenthesisIndex)+"";
String currentClosingBracket = closingBrackets.charAt(parenthesisIndex)+"";
if (contOccouranceIn(currentOpeningBracket,function) != contOccouranceIn(currentClosingBracket,function)) {
throw new IllegalArgumentException("Error: brackets are misused in the function "+function);
}
while (position < function.length()) {
if (function.substring(position,position+1).equals(currentOpeningBracket)) {
if (position != 0 && !operators.contains(function.substring(position-1,position))) {
throw new IllegalArgumentException("Error in function: there must be an operator following a "+currentClosingBracket+" breacket");
}
openParenthesisBlockIndex = position;
}else if (function.substring(position,position+1).equals(currentClosingBracket)) {
if (position != function.length()-1 && !operators.contains(function.substring(position+1,position+2))) {
throw new IllegalArgumentException("Error in function: there must be an operator before a "+currentClosingBracket+" breacket");
}
String newKey = getNewKey(values);
values.put(newKey, solveBracketsFunction(function.substring(openParenthesisBlockIndex+1,position),motherFunction, values));
function = function.substring(0,openParenthesisBlockIndex)+newKey
+((position == function.length()-1)?(""):(function.substring(position+1)));
position = -1;
}
position++;
}
parenthesisIndex++;
}while (parenthesisIndex < openingBrackets.length());
return solveBasicFunction(function,motherFunction, values);
}
private static double solveBasicFunction (String function, String motherFunction, HashMap<String, Double> values) throws IllegalArgumentException{
if (!firstContainsOnlySecond(function, alphanumeric+operators)) {
throw new IllegalArgumentException("The function "+function+" is not a basic function");
}
if (function.contains("**") |
function.contains("//") |
function.contains("--") |
function.contains("+*") |
function.contains("+/") |
function.contains("-*") |
function.contains("-/")) {
/*
* ( -+ , +- , *- , *+ , /- , /+ )> Those values are admitted
*/
throw new IllegalArgumentException("Operators are misused in the function");
}
function = function.replace(" ", "");
int position;
int operatorIndex = 0;
String currentOperator;
do {
currentOperator = operators.substring(operatorIndex,operatorIndex+1);
if (currentOperator.equals("*")) {
currentOperator+="/";
operatorIndex++;
}else if (currentOperator.equals("+")) {
currentOperator+="-";
operatorIndex++;
}
operatorIndex++;
position = 0;
while (position < function.length()) {
if ((position == 0 && !(""+function.charAt(position)).equals("-") && !(""+function.charAt(position)).equals("+") && operators.contains(""+function.charAt(position))) ||
(position == function.length()-1 && operators.contains(""+function.charAt(position)))){
throw new IllegalArgumentException("Operators are misused in the function");
}
if (currentOperator.contains(function.substring(position, position+1)) & position != 0) {
int firstTermBeginIndex = position;
while (firstTermBeginIndex > 0) {
if ((alphanumeric.contains(""+function.charAt(firstTermBeginIndex))) & (operators.contains(""+function.charAt(firstTermBeginIndex-1)))){
break;
}
firstTermBeginIndex--;
}
if (firstTermBeginIndex != 0 && (function.charAt(firstTermBeginIndex-1) == '-' | function.charAt(firstTermBeginIndex-1) == '+')) {
if (firstTermBeginIndex == 1) {
firstTermBeginIndex--;
}else if (operators.contains(""+(function.charAt(firstTermBeginIndex-2)))){
firstTermBeginIndex--;
}
}
String firstTerm = function.substring(firstTermBeginIndex,position);
int secondTermLastIndex = position;
while (secondTermLastIndex < function.length()-1) {
if ((alphanumeric.contains(""+function.charAt(secondTermLastIndex))) & (operators.contains(""+function.charAt(secondTermLastIndex+1)))) {
break;
}
secondTermLastIndex++;
}
String secondTerm = function.substring(position+1,secondTermLastIndex+1);
double result;
switch (function.substring(position,position+1)) {
case "*": result = solveSingleValue(firstTerm,values)*solveSingleValue(secondTerm,values); break;
case "/": result = solveSingleValue(firstTerm,values)/solveSingleValue(secondTerm,values); break;
case "+": result = solveSingleValue(firstTerm,values)+solveSingleValue(secondTerm,values); break;
case "-": result = solveSingleValue(firstTerm,values)-solveSingleValue(secondTerm,values); break;
case "^": result = Math.pow(solveSingleValue(firstTerm,values),solveSingleValue(secondTerm,values)); break;
default: throw new IllegalArgumentException("Unknown operator: "+currentOperator);
}
String newAttribute = getNewKey(values);
values.put(newAttribute, result);
function = function.substring(0,firstTermBeginIndex)+newAttribute+function.substring(secondTermLastIndex+1,function.length());
deleteValueIfPossible(firstTerm, values, motherFunction);
deleteValueIfPossible(secondTerm, values, motherFunction);
position = -1;
}
position++;
}
}while (operatorIndex < operators.length());
return solveSingleValue(function, values);
}
private static double solveSingleValue (String singleValue, HashMap<String, Double> values) throws IllegalArgumentException{
if (isDouble(singleValue)) {
return Double.parseDouble(singleValue);
}else if (firstContainsOnlySecond(singleValue, alphabetic)){
return getValueFromVariable(singleValue, values);
}else if (firstContainsOnlySecond(singleValue, alphanumeric+"-+")) {
String[] composition = splitByLettersAndNumbers(singleValue);
if (composition.length != 2) {
throw new IllegalArgumentException("Wrong expression: "+singleValue);
}else {
if (composition[0].equals("-")) {
composition[0] = "-1";
}else if (composition[1].equals("-")) {
composition[1] = "-1";
}else if (composition[0].equals("+")) {
composition[0] = "+1";
}else if (composition[1].equals("+")) {
composition[1] = "+1";
}
if (isDouble(composition[0])) {
return Double.parseDouble(composition[0])*getValueFromVariable(composition[1], values);
}else if (isDouble(composition[1])){
return Double.parseDouble(composition[1])*getValueFromVariable(composition[0], values);
}else {
throw new IllegalArgumentException("Wrong expression: "+singleValue);
}
}
}else {
throw new IllegalArgumentException("Wrong expression: "+singleValue);
}
}
private static double getValueFromVariable (String variable, HashMap<String, Double> values) throws IllegalArgumentException{
Double val = values.get(variable);
if (val == null) {
throw new IllegalArgumentException("Unknown variable: "+variable);
}else {
return val;
}
}
/*
* FunctionSolver help tools:
*
*/
private static final String alphabetic = "abcdefghilmnopqrstuvzwykxy";
private static final String numeric = "0123456789.";
private static final String alphanumeric = alphabetic+numeric;
private static final String operators = "^*/+-"; //--> Operators order in important!
private static boolean firstContainsOnlySecond(String firstString, String secondString) {
for (int j = 0 ; j < firstString.length() ; j++) {
if (!secondString.contains(firstString.substring(j, j+1))) {
return false;
}
}
return true;
}
private static String getNewKey (HashMap<String, Double> hashMap) {
String alpha = "abcdefghilmnopqrstuvzyjkx";
for (int j = 0 ; j < alpha.length() ; j++) {
String k = alpha.substring(j,j+1);
if (!hashMap.containsKey(k) & !Arrays.asList(usableMathMethods()).contains(k)) {
return k;
}
}
for (int j = 0 ; j < alpha.length() ; j++) {
for (int i = 0 ; i < alpha.length() ; i++) {
String k = alpha.substring(j,j+1)+alpha.substring(i,i+1);
if (!hashMap.containsKey(k) & !Arrays.asList(usableMathMethods()).contains(k)) {
return k;
}
}
}
throw new NullPointerException();
}
public static String[] usableMathMethods () {
/*
* Only methods that:
* return a double type
* present one or two parameters (which are double type)
*/
Method[] mathMethods = Math.class.getDeclaredMethods();
ArrayList<String> usableMethodsNames = new ArrayList<>();
for (Method method : mathMethods) {
boolean usable = true;
int argumentsCounter = 0;
Class<?>[] methodParametersTypes = method.getParameterTypes();
for (Class<?> parameter : methodParametersTypes) {
if (!parameter.getSimpleName().equalsIgnoreCase("double")) {
usable = false;
break;
}else {
argumentsCounter++;
}
}
if (!method.getReturnType().getSimpleName().toLowerCase().equals("double")) {
usable = false;
}
if (usable & argumentsCounter<=2) {
usableMethodsNames.add(method.getName());
}
}
return usableMethodsNames.toArray(new String[usableMethodsNames.size()]);
}
private static boolean isDouble (String number) {
try {
Double.parseDouble(number);
return true;
}catch (Exception ex) {
return false;
}
}
private static String[] splitByLettersAndNumbers (String val) {
if (!firstContainsOnlySecond(val, alphanumeric+"+-")) {
throw new IllegalArgumentException("Wrong passed value: <<"+val+">>");
}
ArrayList<String> response = new ArrayList<>();
String searchingFor;
int lastIndex = 0;
if (firstContainsOnlySecond(""+val.charAt(0), numeric+"+-")) {
searchingFor = alphabetic;
}else {
searchingFor = numeric+"+-";
}
for (int j = 0 ; j < val.length() ; j++) {
if (searchingFor.contains(val.charAt(j)+"")) {
response.add(val.substring(lastIndex, j));
lastIndex = j;
if (searchingFor.equals(numeric+"+-")) {
searchingFor = alphabetic;
}else {
searchingFor = numeric+"+-";
}
}
}
response.add(val.substring(lastIndex,val.length()));
return response.toArray(new String[response.size()]);
}
private static void deleteValueIfPossible (String val, HashMap<String, Double> values, String function) {
if (values.get(val) != null & function != null) {
if (!function.contains(val)) {
values.remove(val);
}
}
}
private static int contOccouranceIn (String howManyOfThatString, String inThatString) {
return inThatString.length() - inThatString.replace(howManyOfThatString, "").length();
}
}
당신 자신의 도서관을 쓰는 것은 당신이 할 수 있는 것만큼 어렵지 않다.다음은 션팅 야드 알고리즘과 단계별 알고리즘 설명 링크입니다.단, 먼저 토큰 입력을 해석해야 합니다.
이 밖에도 2가지 질문이 있습니다.문자열을 산술식으로 변환하시겠습니까?자바에서 수학식을 해석하기 위한 좋은 라이브러리는 무엇입니까?
, 이 에 제 eval()「 」, 「 」, 「 」는 「 」입니다.
package evaluation;
import java.math.BigInteger;
import java.util.EmptyStackException;
import java.util.Scanner;
import java.util.Stack;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class EvalPlus {
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
System.out.println("This Evaluation is based on BODMAS rule\n");
evaluate();
}
private static void evaluate() {
StringBuilder finalStr = new StringBuilder();
System.out.println("Enter an expression to evaluate:");
String expr = scanner.nextLine();
if(isProperExpression(expr)) {
expr = replaceBefore(expr);
char[] temp = expr.toCharArray();
String operators = "(+-*/%)";
for(int i = 0; i < temp.length; i++) {
if((i == 0 && temp[i] != '*') || (i == temp.length-1 && temp[i] != '*' && temp[i] != '!')) {
finalStr.append(temp[i]);
} else if((i > 0 && i < temp.length -1) || (i==temp.length-1 && temp[i] == '!')) {
if(temp[i] == '!') {
StringBuilder str = new StringBuilder();
for(int k = i-1; k >= 0; k--) {
if(Character.isDigit(temp[k])) {
str.insert(0, temp[k] );
} else {
break;
}
}
Long prev = Long.valueOf(str.toString());
BigInteger val = new BigInteger("1");
for(Long j = prev; j > 1; j--) {
val = val.multiply(BigInteger.valueOf(j));
}
finalStr.setLength(finalStr.length() - str.length());
finalStr.append("(" + val + ")");
if(temp.length > i+1) {
char next = temp[i+1];
if(operators.indexOf(next) == -1) {
finalStr.append("*");
}
}
} else {
finalStr.append(temp[i]);
}
}
}
expr = finalStr.toString();
if(expr != null && !expr.isEmpty()) {
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine engine = mgr.getEngineByName("JavaScript");
try {
System.out.println("Result: " + engine.eval(expr));
evaluate();
} catch (ScriptException e) {
System.out.println(e.getMessage());
}
} else {
System.out.println("Please give an expression");
evaluate();
}
} else {
System.out.println("Not a valid expression");
evaluate();
}
}
private static String replaceBefore(String expr) {
expr = expr.replace("(", "*(");
expr = expr.replace("+*", "+").replace("-*", "-").replace("**", "*").replace("/*", "/").replace("%*", "%");
return expr;
}
private static boolean isProperExpression(String expr) {
expr = expr.replaceAll("[^()]", "");
char[] arr = expr.toCharArray();
Stack<Character> stack = new Stack<Character>();
int i =0;
while(i < arr.length) {
try {
if(arr[i] == '(') {
stack.push(arr[i]);
} else {
stack.pop();
}
} catch (EmptyStackException e) {
stack.push(arr[i]);
}
i++;
}
return stack.isEmpty();
}
}
여기에서 언제든지 업데이트된 Gest를 찾아주세요.또, 문제가 있는 경우는 코멘트해 주세요.감사해요.
여기 완벽하게 유능한 답이 몇 개 있다.단, 간단한 스크립트가 아닌 경우에는 코드를 캐시 또는 디버깅 목적으로 유지하거나 동적 자기 갱신 코드를 갖는 것이 바람직할 수 있습니다.
이를 위해 명령줄을 통해 Java와 상호 작용하는 것이 더 단순하거나 더 강력할 수 있습니다.임시 디렉토리를 만들고 스크립트 및 자산을 출력하고 jar를 만듭니다.마지막으로 새 코드를 Import합니다.
범위를eval()대부분의 언어에서 사용할 수 있지만, 항아리의 일부 함수에서 결과를 반환함으로써 확실히 평가를 구현할 수 있습니다.
하지만 이 방법은 서드파티 툴 없이 Java가 할 수 있는 모든 것을 캡슐화했기 때문에 절박한 경우에 대비하여 언급하고 싶습니다.이 방법을 사용하면 HTML 템플릿을 객체로 변환하여 저장할 수 있으므로 런타임에 템플릿을 해석할 필요가 없습니다.
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
class Calculate {
public static void main(String[] args) {
String strng = "8*-2*3*-1*10/2+6-2";
String[] oparator = {"+","-","*","/"};
List<String> op1 = new ArrayList<>();
String[] x = strng.split("");
int sayac=0;
for (String i : x) {
sayac ++;
for (String c : oparator) {
if (i.equals(c)) {
try {
int j = Integer.parseInt(strng.substring(0, sayac - 1));
op1.add(strng.substring(0, sayac - 1));
op1.add(c);
strng = strng.substring(sayac);
sayac = 0;
}catch (Exception e)
{
continue;
}
}
}
}
op1.add(strng);
ListIterator<String> it = op1.listIterator();
List<List> newlist = new ArrayList<>() ;
while (it.hasNext()) {
List<String> p= new ArrayList<>();
p.add(String.valueOf(it.nextIndex()));
p.add(it.next());
newlist.add(p);
}
int sayac2=0;
String oparatorvalue = "*";
calculate(sayac2,newlist,oparatorvalue);
String oparatorvalue2 = "/";
calculate(sayac2,newlist,oparatorvalue2);
String oparatorvalue3 = "+";
calculate(sayac2,newlist,oparatorvalue3);
String oparatorvalue4 = "-";
calculate(sayac2,newlist,oparatorvalue4);
System.out.println("Result:"+newlist.get(0).get(1));
}
private static void calculate(int sayac2, List<List> newlist, String oparatorvalue) {
while (sayac2<4){
try{
for (List j : newlist) {
if (j.get(1) == oparatorvalue) {
Integer opindex = newlist.indexOf(j);
Object sayi1 = newlist.get(opindex - 1).get(1);
Object sayi2 = newlist.get(opindex + 1).get(1);
int sonuc=0;
if (oparatorvalue.equals("*")){
sonuc = Integer.parseInt(sayi1.toString()) * Integer.parseInt(sayi2.toString());
}
if (oparatorvalue.equals("/")){
sonuc = Integer.parseInt(sayi1.toString()) / Integer.parseInt(sayi2.toString());
}
if (oparatorvalue.equals("+")){
sonuc = Integer.parseInt(sayi1.toString()) + Integer.parseInt(sayi2.toString());
}
if (oparatorvalue.equals("-")){
sonuc = Integer.parseInt(sayi1.toString()) - Integer.parseInt(sayi2.toString());
}
newlist.remove(opindex - 1);
newlist.remove(opindex - 1);
newlist.remove(opindex - 1);
List<String> sonuclist = new ArrayList<>();
sonuclist.add(String.valueOf(opindex - 1));
sonuclist.add(String.valueOf(sonuc));
newlist.add(opindex - 1, sonuclist);
}}}
catch (Exception e){
continue;
}
sayac2++;}
}
}
다음으로 문제를 해결했습니다.
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine engine = mgr.getEngineByName("JavaScript");
String str = "4*5";
System.out.println(engine.eval(str));
언급URL : https://stackoverflow.com/questions/2605032/is-there-an-eval-function-in-java
반응형
'source' 카테고리의 다른 글
| Python에서 유형을 확인하는 표준 방법은 무엇입니까? (0) | 2022.11.08 |
|---|---|
| 사용자 정의 예외 유형 (0) | 2022.11.08 |
| Java reflection을 사용하여 메서드 파라미터명을 얻을 수 있습니까? (0) | 2022.11.08 |
| JSON 개체 크기 가져오기 (0) | 2022.11.08 |
| C의 bool 데이터 형식에 대한 scanf 형식 지정자 (0) | 2022.11.08 |