Question

如何转换字符串＆＃34;（123,456）＆＃34;到java中的-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

不一样的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 3

你可以尝试：

    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 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

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

DecimalFormat numberFormat = DecimalFormat.getInstance();

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

Answer 9

你可以这样试试：

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 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("[,]",""));
}

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

用括号解析负数

11 个答案: