Question

作为初学者的简单问题会带来大问题。

我想缩短（格式化）字符串以仅显示1个小数或2。不幸的是，它不是一个双精度数的字符串。

String getNumber = "6.000m";

我知道有一个printf（）函数，但是据我所知，它是按照正确的顺序打印多个字符串的。

如何使输出仅包含小数点后一位或如果它有更多的非零数字？

6.000 m --> 6.0
4.900 m --> 4.9
4.750 m --> 4.75

Answer 1

我认为它的末尾总是“ m”，前面有一些可选的空格。因此，我首先使用正则表达式将其删除。 DecimalFormat是您的朋友来做其余的事情：

import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Ff {
    static Pattern numberPart=Pattern.compile("([0-9.]*)\\b*m");
    static DecimalFormat df=new DecimalFormat("0.0#####");

    public static String format(String input)
    {
        Matcher m=numberPart.matcher(input);
        if(m.matches())
        {
            return df.format(Double.parseDouble(m.group(1)));
        }
        return null;
    }
    public static void main(String args[]) {
        System.out.println(format("6.000m"));
        System.out.println(format("4.900m"));
        System.out.println(format("4.750m"));
    }
}

，输出为：

6.0
4.9
4.75

Answer 2

您不应该使用正则表达式，因为它很难维护。

例如：

    (?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01- 
    \x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?: 
    (?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0- 
    5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]| 
    [1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\ 
    [\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

这是一些使用正则表达式验证电子邮件的代码的一部分。正则表达式在必要时可用于计算机，因为正则表达式可快速运行。如今，您不再需要它们了，而维护是关键，这就是为什么我使用整洁的代码和tdd而不是直接搜索解决方案。

使用测试用例后：

0.000 m-> 0.0
1.000 m-> 1.0
9.000 m-> 9.0
1.100 m-> 1.1
1.900 m-> 1.9
1.110 m-> 1.11
1.010 m-> 1.01
1.111 m-> 1.111
1.101 m-> 1.101
1.101m-> 1.101

我得出了这个结论：

shortenGivenNumber(String wholeNumber);将是您用来缩短电话号码的方法。还有其他方法可以使主要方法更具可读性。

public class NumberShortener {

    public String shortenGivenNumber(String wholeNumber) {
        int endOfShortNumber = findEndOfNumber(wholeNumber);

        String shortenedNumber = cutOutNumber(wholeNumber, endOfShortNumber);

        return shortenedNumber;
    }

    private int findEndOfNumber(String numberWithZeroesAndM) {
        int lastZero = findIndexOfZeroAfterNumber(numberWithZeroesAndM);

        int endOfNumber = lastZero;

        endOfNumber = handleNo0AtEndCase(numberWithZeroesAndM, lastZero, endOfNumber);

        return endOfNumber;
    }

    private int findIndexOfZeroAfterNumber(String wholeNumber) {
        int lastZero; 

        int searchIndex = 3;
        boolean numberAfterZero;
        do {
            numberAfterZero = false;

            lastZero = findNextIndexOfZero(wholeNumber, searchIndex);
            numberAfterZero = isANumberAfterThisZero(wholeNumber, lastZero);

            searchIndex++;
        }while(numberAfterZero == true && valueExistsAtEnd(lastZero));

        return lastZero;
    }

    private int findNextIndexOfZero(String wholeNumber, int searchIndex) {
        return wholeNumber.indexOf("0", searchIndex);
    }

    private boolean isANumberAfterThisZero(String wholeNumber, int lastZero) {
        boolean numberAfterZero = false;

        for(int i = 1; i < 10; i++){
            char characterAfterZero = getCharacterAfterZero(wholeNumber, lastZero);
            char iAsChar = convertIntToChar(i);

            if(isTheCharacterThisNumber(characterAfterZero, iAsChar)){
                numberAfterZero = true;
            }
        }
        return numberAfterZero;
    }


    private boolean valueExistsAtEnd(int lastZero) {
        return lastZero != -1;
    }

    private int handleNo0AtEndCase(String wholeNumber, int lastZero, int endOfNumber) {
        if(thisSignIsntAtEnd(lastZero)){
            int indexOfSpace = getIndexOfSpace(wholeNumber);
            endOfNumber = indexOfSpace;
            endOfNumber = handleNoSpaceAtEndCase(wholeNumber, endOfNumber, indexOfSpace);
        }
        return endOfNumber;
    }

    private int getIndexOfSpace(String wholeNumber) {
        return wholeNumber.indexOf(" ");
    }

    private int handleNoSpaceAtEndCase(String wholeNumber, int endOfNumber, int space) {
        if(thisSignIsntAtEnd(space)) {
            int indexOfM = getIndexOfM(wholeNumber);
            endOfNumber = indexOfM;
        }
        return endOfNumber;
    }

    private int getIndexOfM(String wholeNumber) {
        return wholeNumber.indexOf("m");
    }

    private char getCharacterAfterZero(String wholeNumber, int indexOfZero) {
        int indexAfterZero = indexOfZero+1;
        return wholeNumber.charAt(indexAfterZero);
    }


    private char convertIntToChar(int i) {
        return (char) (i+48);
    }

    private String cutOutNumber(String wholeNumber, int endOfNumber) {
        return wholeNumber.substring(0, endOfNumber);
    }

    private boolean isTheCharacterThisNumber(char characterAfterZero, char iAsChar) {
        return characterAfterZero == iAsChar;
    }
}

它总是复制前三个字符（x.x）。前一个0（在x.x之后），后面没有任何数字，将用作最后一个索引，该索引指示最终数字子字符串的结尾。如果数字大于0，则使用空格（1.123 m）。如果没有空格，它将使用m（1.123m）。

如何正确缩短（格式化）字符串输出？

2 个答案: