用括号解析负数[重复]

Question

如何在java中将字符串“(123,456)”转换为-123456（负数）？

例如：

(123,456) = -123456

123,456 = 123456

我使用了 NumberFormat 类，但它只转换正数，不能处理负数。

NumberFormat numberFormat = NumberFormat.getInstance();
try {
       System.out.println(" number formatted to " + numberFormat.parse("123,456"));
       System.out.println(" number formatted to " + numberFormat.parse("(123,456)"));
    } catch (ParseException e) {
           System.out.println("I couldn't parse your string!");
    }

输出：

数字格式为 123456

我无法解析你的字符串！

Answer 1

没有自定义解析逻辑的简单技巧：

new DecimalFormat("#,##0;(#,##0)", new DecimalFormatSymbols(Locale.US)).parse("(123,456)")

DecimalFormatSymbols 参数可以省略以使用当前语言环境进行解析

Answer 2

你可以试试：

    try {
        boolean hasParens = false;
        String s = "123,456";
        s = s.replaceAll(",","")

        if(s.contains("(")) {
            s = s.replaceAll("[()]","");
            hasParens = true;
        }

        int number = Integer.parseInt(s);

        if(hasParens) {
            number = -number;
        }
    } catch(...) {
    }

也许有更好的解决方案

Answer 3

API 不同，但值得一试

    DecimalFormat myFormatter = new DecimalFormat("#,##0.00;(#,##0.00)");
    myFormatter.setParseBigDecimal(true);
    BigDecimal result = (BigDecimal) myFormatter.parse("(1000,001)");
    System.out.println(result);         
    System.out.println(myFormatter.parse("1000,001"));

输出：

-1000001 和 1000001

Answer 4

我有其他解决方案：

    String s = "123,456";
    Boolean parenthesis = s.contains("(");

    ScriptEngineManager mgr = new ScriptEngineManager();
    ScriptEngine engine = mgr.getEngineByName("JavaScript");

    Object eval = mgr.eval(s);

    if(eval instanceof Double){
        int result = (int) ((Double)eval) * 1000;
        result *= (parenthesis ? -1 : 1);
   }

这是一个非典型的解决方案，即使有重复的帖子，我认为这个答案是值得的:)

Answer 5

这应该可行：

public static void main(String[] args) {
    String negative = "(123,456)";
    String positive = "123,456";

    System.out.println("negative: " + parse(negative));
    System.out.println("positive: " + parse(positive));
}

private static Integer parse(String parsed) {
    if (parsed.contains("(") || parsed.contains(")")) {
        parsed = parsed.replaceAll("[(),]", "");
        return Integer.valueOf(parsed) * -1;
    } else {
        parsed = parsed.replaceAll("[,]", "");
        return Integer.valueOf(parsed);
    }
}

输出将是：

否定：-123456
正面：123456

Answer 6

这里，我正在尝试将字符串更改为整数，然后再将整数更改为字符串。

双斜杠 ('\\') 用于转义特殊字符，如果出现多次，它们很有用。

这是完整的代码：测试并执行。

    package com.siri;

    import java.text.NumberFormat;
    import java.text.ParseException;

    /* Java program to demonstrate how to implement static and non-static
       classes in a java program. */
    class NumberFormat
    {        
       // How to create instance of static and non static nested class?
       public static void main(String args[])
       {        
          NumberFormat numberFormat = NumberFormat.getInstance();
          try 
          {
             System.out.println(" number formatted to " + 
                                numberFormat.parse("123,456"));

             String numberToBeChanged="(123,456)";
             if(numberToBeChanged.contains("(") || 
                numberToBeChanged.contains(")"))
             {
                numberToBeChanged=numberToBeChanged.replaceAll("\\(", 
                "").replaceAll("\\)", "").replaceAll(",", "");

                int numberToBeChangedInt = Integer.parseInt(numberToBeChanged);
                numberToBeChangedInt *= -1;
                numberToBeChanged = Integer.toString(numberToBeChangedInt);
             }

             System.out.println(" number formatted to " + 
                                numberFormat.parse(numberToBeChanged));

             } 
             catch (ParseException e) 
             {
                System.out.println("I couldn't parse your string!");
             }
        }
    }

现在您可以看到指定的预期结果。

Answer 7

private int getIntValue(String numberToParse) {
    if (numberToParse.contains("(")) {
        numberToParse = numberToParse.replaceAll("[(),]", "");
        return Integer.valueOf(numberToParse) * -1;
    } else {
        numberToParse = numberToParse.replaceAll("[,]", "");
        return Integer.valueOf(numberToParse);
    }
}

Answer 8

你可以这样试试：

private static Pattern PATTERN = Pattern.compile("(\\()?(\\d+.*)(\\))?");

public static void main(String[] args) throws ParseException {
    System.out.println(parseLong("123,456"));
    System.out.println(parseLong("(123,456)"));
}

private static long parseLong(String string) throws ParseException {
    Matcher matcher = PATTERN.matcher(string);
    if (matcher.matches()) {
        long value = NumberFormat.getInstance(Locale.US).parse(matcher.group(2)).longValue();
        return matcher.group(1) != matcher.group(3) ? value = -value : value;
    }
    throw new IllegalArgumentException("Invalid number format " + string);
}

输出：

 123456
-123456

Answer 9

如果您确定只显示具有给定格式的字符串，那么为什么不在解析之前简单地将前导“（”替换为减号，将最后的“）”替换为空：

DecimalFormat numberFormat = DecimalFormat.getInstance();

String number = "(123,456)";
System.out.println(" number formatted to " + 
                     numberFormat.parse(number.replaceAll("(","-").replace All(")","")));

Answer 10

你可以实现你所需要的：

    try {
        String var = "(123,456)";
        Integer i = -Integer.parseInt(var.replaceAll("\\(", "")
                .replaceAll(",", "").replaceAll("\\)", ""));
        System.out.println("Integer: " + i);
    } catch (NumberFormatException e) {
        System.out.println("Invalid number: " + e.getMessage());
    }

Answer 11

尝试以下方法：

private int getInt(String s) {
    return s.contains("(") ? 
        -1 * Integer.parseInt(s.replaceAll("[(),]","")) : 
            Integer.parseInt(s.replaceAll("[,]",""));
}  

这将检查字符串是否包含“(”。如果是，它将删除所有'('和')'字符，将字符串转换为整数并使值变为负数。否则，它会删除'， ' 字符并解析整数，因此是正数。