BigDecimal doesn't represent a rendering. In other words, whether to use a comma or a dot as separator is not part of the properties a BigDecimal object has.

Hence, you do not want to call .replaceAll. (And separately, you'd want .replace(".", ",") - replace replaces all, and replaceAll also replaces all and interprets the first arg as a regex, and is therefore needlessly confusing here). Just pass it with the dot.

To render a BigDecimal, don't just sysout it, that will always show a dot and there is nothing you can do about that. toString() is almost never the appropriate tool for the job of rendering data to a user - it's a debugging aid, nothing more. Use e.g. String.format("%f"), specifying the appropriate locale. Or use NumberFormat. The javadoc of BigDecimal explicitly spells this out.

There are various other issues with your code:

• "cast" is the technical name for the syntactic construct: (Type) expr; - and this construct does 3 utterly different things, hence using it to describe a task, i.e. use it in a method name, is a very bad idea. In particular, only one of the 3 things it does converts anything, and you clearly use it here in the 'convert something' meaning. This is misleading; only if it's all primitives does the cast operator convert, and BigDecimal isn't primitive. Call it convertTo or whatever you please, not "cast".
• BigDecimal is an extremely complicated tool for the job and usually not the right tool if you want to represent financial data. Instead, represent the atomary unit in a long and call the appropriate rendering method whenever you need to show it to a user. For example, for euros, the atomary unit is the eurocent. If something costs €1,50, you'd store "150", in a long. Before you think: But, wait, I want to divide, and then I'd lose half a cent! - yes, well, you can't exactly send your bank a request to transfer half a cent, either. Also, try to divide 4 cents by 3 with a BigDecimal and see what happens. Dividing financial amounts is tricky no matter what you use, BD isn't a catch-all solution to this problem.

Check out setParseBigDecimal in DecimalFormat. With this setter, parse will return a BigDecimal for you.

This should be enough to get the results.

String.format("%,.2f", amount.setScale(2, RoundingMode.DOWN)); 

because you tried to put a "," in a number.

you can use this code to parse a number with comma:

NumberFormat.getNumberInstance(Locale.FRANCE).parse("265,858")

you should also use float or double if there is no particular reason you use decimal.

Try this

// Create a DecimalFormat that fits your requirements
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setGroupingSeparator(',');
symbols.setDecimalSeparator('.');
String pattern = "#,##0.0#";
DecimalFormat decimalFormat = new DecimalFormat(pattern, symbols);
decimalFormat.setParseBigDecimal(true);

// parse the string
BigDecimal bigDecimal = (BigDecimal) decimalFormat.parse("10,692,467,440,017.120");
System.out.println(bigDecimal);

If you are building an application with I18N support you should use DecimalFormatSymbols(Locale)

Also keep in mind that decimalFormat.parse can throw a ParseException so you need to handle it (with try/catch) or throw it and let another part of your program handle it

You don't need to remove the first zeros, it will be ignored when you convert it to BigDecimal, you just need to put the dot before the two last digits :

String line = "30000000000000010300000000000000000000009876543210";
if (line.length() >= 22) {
    BigDecimal amount = new BigDecimal(
            line.substring(2, 24).replaceFirst("^(.*)(..)1.$2")
    );
    System.out.println(amount);
}

Output

30000000000000010300000000000000000000009876543210 -> 1030000.00

Just change the decimalFormat pattern to ###.00 Because in your format pattern, there is no information related to decimal values(after decimal point), hence decimal values are not displayed in the formatted output.

symbols.setDecimalSeparator(',');
DecimalFormat df = new DecimalFormat("###.00", symbols);

Outputs:

System.out.println(df.format(new BigDecimal(589555.23))); //589555,23

Yes, the BigDecimal class does not take any Locale into account in its constructor that takes a String, as can be read in the Javadoc of this constructor:

the fraction consists of a decimal point followed by zero or more decimal digits.

If you want to parse according to a different Locale, one that uses the comma as decimals separator, you need to use java.text.DecimalFormat with a specific Locale.

Example:

DecimalFormat fmt = new DecimalFormat("0.0", new DecimalFormatSymbols(Locale.GERMAN));
fmt.setParseBigDecimal(true);
BigDecimal n = (BigDecimal) fmt.parse("10934,375");

Note: you need to get an instance of DecimalFormat (a subclass of NumberFormat) to be able to call the method setParseBigDecimal. Otherwise it returns a Double instead, which is a binary floating point number, and binary floating point numbers cannot accurately represent many decimal fractions. So that would cause a loss of accuracy in many cases.

The BigDecimal(double) constructor can have unpredictable behaviors. It is preferable to use BigDecimal(String) or BigDecimal.valueOf(double).

Use with AISystem.out.println(new BigDecimal(135.69)); //135.68999999999999772626324556767940521240234375
System.out.println(new BigDecimal("135.69")); // 135.69
System.out.println(new BigDecimal("13۵.۶9")); // 135.69
System.out.println(BigDecimal.valueOf(135.69)); // 135.69

The documentation for BigDecimal(double) explains in detail:

1. The results of this constructor can be somewhat unpredictable. One might assume that writing new BigDecimal(0.1) in Java creates a BigDecimal which is exactly equal to 0.1 (an unscaled value of 1, with a scale of 1), but it is actually equal to 0.1000000000000000055511151231257827021181583404541015625. This is because 0.1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the value that is being passed in to the constructor is not exactly equal to 0.1, appearances notwithstanding.
2. The String constructor, on the other hand, is perfectly predictable: writing new BigDecimal("0.1") creates a BigDecimal which is exactly equal to 0.1, as one would expect. Therefore, it is generally recommended that the String constructor be used in preference to this one.
3. When a double must be used as a source for a BigDecimal, note that this constructor provides an exact conversion; it does not give the same result as converting the double to a String using the Double.toString(double) method and then using the BigDecimal(String) constructor. To get that result, use the static valueOf(double) method.