Преобразуйте значение String в BigDecimal и отсортируйте их в порядке убывания, а затем распечатайте

Question

вот мой код, но он не принимает строку, как в переменной BigDecimal

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Scanner;

public class BigDesimal {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] s = new String[n];
        for(int i=0; i<n; ++i) {
            s[i] = in.next();
        }
        in.close();

        BigDecimal max, min;
        for(int i=0; i<n-1; i++) {
            for(int j=i+1; j<n; j++) {
                max = (new BigDecimal(s[i])).max(new BigDecimal(s[j]));
                min = (new BigDecimal(s[i])).min(new BigDecimal(s[j]));
                s[i] = max.toString();
                s[j] = min.toString();
                 
                
            }
        }
         

        System.out.println(Arrays.toString(s));

    }

}

Я запускаю эту программу для следующего ввода: * 9

-100, 50, 0, 56.6, 90, 0.12, .12, 02.34, 000.000 *

И вывод: [90, 56.6, 50, 2.34, 0.12, 0.12, 0 , 0, -100]

Answer 1

Попробуйте что-нибудь вроде этого (не проверено):

        List<String> sortedNumberStrings = Arrays.stream(numberStrings)
                .map(NumberString::new)
                .sorted(Comparator.reverseOrder())
                .map(NumberString::getStringValue)
                .collect(Collectors.toList());

        System.out.println(sortedNumberStrings);



private static class NumberString implements Comparable<NumberString> {

        private final String stringValue;
        private final BigDecimal bigDecimalValue;

        NumberString(String stringValue) {

            this.stringValue = stringValue;
            this.bigDecimalValue = new BigDecimal(stringValue);
        }

        public String getStringValue() {
            return stringValue;
        }

        public BigDecimal getBigDecimalValue() {
            return bigDecimalValue;
        }

        private static final Comparator<NumberString> NATURAL_ORDER_COMPARATOR =
                Comparator.comparing(NumberString::getBigDecimalValue) // sort by value
                        .thenComparing(NumberString::getStringValue); // sort lexically

        @Override
        public int compareTo(NumberString other) {
            return NATURAL_ORDER_COMPARATOR.compare(this, other);
        }

        @Override
        public int hashCode() {
            return Objects.hash(stringValue, bigDecimalValue);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof NumberString)) {
                return false;
            }
            NumberString that = (NumberString) o;
            return Objects.equals(stringValue, that.stringValue) &&
                    Objects.equals(bigDecimalValue, that.bigDecimalValue);
        }

        @Override
        public String toString() {
            return stringValue;
        }
    }

Answer 2

Вы можете изменить внутреннее тело l oop на это:

String si = s[i], sj = s[j];
if (new BigDecimal(si).compareTo(new BigDecimal(sj)) < 0) {
    s[i] = sj;
    s[j] = si;
}

Вам не нужно сохранять результат преобразованных больших десятичных дробей обратно в массив, но используйте их только для сравнения.

На ввод:

9, -100, 50, 0, 56.6, 90, 0.12, .12, 02.34, 000.000

Возвращаюсь:

90, 56.6, 50, 9, 02.34, .12, 0.12, 0, 000.000, -100

DEMO

А если не t работать с очень большими числами, нормальных double должно хватить:

if(Double.parseDouble(si) < Double.parseDouble(sj))