Java实现输入4个数字返回一条结果为24的式子

该代码不论加减乘除模运算的优先级，统一从左到右计算。
举个例子：1 + 2 × 8 / 1 = 24；×和/的优先级比 + 的高，忽略优先级自左至右计算过程为：1 + 2 = 3，3×8 = 24，24 / 1 = 24；

import java.util.*;

public class test {
    public static void main(String[] as) {
        Scanner in = new Scanner(System.in);
		System.out.println("请输入四个数字：");
        int a = in.nextInt(); 
        int b = in.nextInt();
        int c = in.nextInt();
        int d = in.nextInt();
        System.out.println(a + "," + b + "," + c + "," + d);
        System.out.println("====================================");

        StringBuilder build = new StringBuilder();
        StringBuilder resBuild = new StringBuilder();
        int[] number = new int[]{a, b, c, d};
        String[] str = new String[]{};
        String[] numbers = result(number);
        String[] symbols = result("+-*/%");
        System.out.println(Arrays.toString(symbols));
        System.out.println(Arrays.toString(numbers));


        int count = 0;
        for (String s : numbers) {
            for (String symbol : symbols) {
                build.append(s);
                build.append(symbol);
                resBuild.append(build.toString()).append(':');
                build.delete(0, build.length());
            }
        }
        str = resBuild.toString().split(":");
        System.out.println(str.length);
        System.out.println("====================================");
        for(int i = 0; i < str.length; ++i){
            StringBuilder sr = new StringBuilder();
            for(int j = 0; j < str[i].length(); ++j){
                if(str[i].charAt(j) != '[' && str[i].charAt(j) != ' '){
                    if(str[i].charAt(j) == ']'){
                        str[i] = str[i].replace(']', ',');
                        sr.append(str[i].charAt(j));
                    }else {
                        sr.append(str[i].charAt(j));
                    }
                }
            }
            str[i] = sr.toString();
        }
        System.out.println(Arrays.toString(str));
        System.out.println("====================================");
        for (String s : str) {
            if (value(s) == 24.0) {
                build.append(s);
                break;
            }
        }
        System.out.println("===============================");
        System.out.println("===============================");
        System.out.println();
        System.out.println();
        if(build.length() > 6) System.out.println("      " + obj(build.toString()) + " = 24");
        else System.out.println("不存在值为24的算式组合！");
        System.out.println();
        System.out.println();
        System.out.println("===============================");
        System.out.println("===============================");
    }

    // 格式化打印算式
    private static String obj(String str) {
        String[] res = str.split(",");

        return res[0] + res[4].charAt(0) + res[1] + res[4].charAt(1) + res[2] + res[4].charAt(2) + res[3];
    }

    // 判断值是否为24
    private static float value(String s) {
        String[] str = s.split(",");
        String symbol = str[str.length-1];
        float sum = 0;
        if(str[0].length() > 1) sum = (str[0].charAt(0) - '0')*10 + (str[0].charAt(1) - '0');
        else sum = (str[0].charAt(0) - '0');
        float[] val = new float[str.length - 1];
        for(int i = 0; i < str.length-1; ++i){
            if(str[i].length() > 1){
                val[i] = (str[i].charAt(1) - '0') + ((str[i].charAt(0) - '0') * 10);
            } else {
                val[i] = str[i].charAt(0) - '0';
            }
        }
        for(int i = 0; i < symbol.length(); ++i){
            if(symbol.charAt(i) == '+'){
                sum += val[i + 1];
            }else if(symbol.charAt(i) == '-'){
                sum -= val[i + 1];
            }else if(symbol.charAt(i) == '*'){
                sum *= val[i + 1];
            }else if(symbol.charAt(i) == '/'){
                sum /= val[i + 1];
            }else if(symbol.charAt(i) == '%'){
                sum %= val[i + 1];
            }
        }

        return sum;
    }

    // 返回一条式子
    private static String[] result(int[] nums) {
        Deque<Integer> deque = new ArrayDeque<>();
        List<List<Integer>> tempList = new ArrayList<>();
        boolean[] flag = new boolean[nums.length];
        allSort(deque, tempList, flag, nums, 0);

        String[] str = new String[tempList.size()];
        for(int i = 0; i < tempList.size(); ++i){
            str[i] = tempList.get(i).toString();
        }

        return str;
    }

    // 数组全排列
    private static void allSort(Deque<Integer> deque, List<List<Integer>> tempList, boolean[] flag, int[] nums, int star) {
        if(deque.size() == nums.length) {
            tempList.add(new ArrayList<>(deque));
            return ;
        }
        for(int i = 0; i < nums.length; ++i){
            if(!flag[i]){
                deque.offer(nums[i]);
                flag[i] = true;
                allSort(deque, tempList, flag, nums, i + 1);
                flag[i] = false;
                deque.removeLast();
            }
        }
    }
    private static String[] result(String str) {
        int size = str.length();
        char[] ar = str.toCharArray();
        StringBuilder build = new StringBuilder();
        String[] ress = new String[125];
        int pos = 0;
        for (int i = 0; i < size; ++i) {
            build.append(ar[i]);
            for (int j = 0; j < size; ++j) {
                build.append(ar[j]);
                for (int k = 0; k < size; ++k) {
                    build.append(ar[k]);
                    ress[pos++] = build.toString();
                    build.delete(2, build.length());
                }
                build.delete(1, build.length());
            }
            build.delete(0, build.length());
        }
        return ress;
    }
}