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

作为一个初学做大问题的人，简单的问题

我想缩短（格式化）一个字符串，使其仅显示1位小数或2位小数。不幸的是，这是一根弦，而不是一根双精度弦

String getNumber = "6.000m";

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

如何使输出只有一个十进制数，或者如果它有更多不是0的数字

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

我假设它的结尾总是“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

---

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

例如：

    (?:[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])+)\])

这是一些用正则表达式验证电子邮件的代码的一部分。当计算机运行缓慢时，正则表达式是必要的，因为正则表达式很快。现在你不再需要它们了，维护是关键

使用测试用例后：

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

我得出这样的结论：

shortEngiveNumber（字符串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;
    }
}

public class NumberShortener{
公共字符串shortEngiveNumber（字符串wholeNumber）{
int endOfShortNumber=findEndOfNumber（wholeNumber）；
字符串shortenedNumber=截止编号（wholeNumber，endOfShortNumber）；
返回shortenedNumber；
}
private int findEndOfNumber（带零和m的字符串编号）{
int lastZero=findIndexOfZeroAfterNumber（带零和M的数字）；
int endOfNumber=lastZero；
endOfNumber=handleNo0AtEndCase（带零和m的数字，最后一个零，endOfNumber）；
返回endOfNumber；
}
private int findIndexOfZeroAfterNumber（字符串wholeNumber）{
int lastZero；
int searchIndex=3；
布尔数为零；
做{
numberrafterzero=假；
lastZero=FindDemofZero（整数，搜索索引）；
numberrafterzero=isanumberthiszero（整数，最后一个零）；
searchIndex++；
}while（numberAfterZero==true&&valueExistsAtEnd（lastZero））；
返回最后零；
}
私有int findndexofzero（字符串wholeNumber，int searchIndex）{
返回全数.indexOf（“0”，搜索索引）；
}
私有布尔值IsAnumbertThisZero（字符串wholeNumber，int lastZero）{
布尔数numberzero=false；
对于（int i=1；i<10；i++）{
characterAfterZero=getCharacterAfterZero（整数，最后零）；
char iAsChar=convertIntToChar（i）；
if（IsCharacterThisNumber（characterAfterZero，iAsChar））{
numberrafterzero=真；
}
}
返回数字为零；
}
私有布尔值existsatend（int lastZero）{
返回lastZero！=-1；
}
私有int-handleNo0AtEndCase（字符串wholeNumber、int-lastZero、int-endOfNumber）{
如果（这表示状态（最后为零））{
int indexOfSpace=getIndexOfSpace（整数）；
endOfNumber=indexOfSpace；
endOfNumber=handlenospacatendcase（wholeNumber，endOfNumber，indexOfSpace）；
}
返回endOfNumber；
}
private int getIndexOfSpace（字符串wholeNumber）{
返回全数。indexOf（“”）；
}
私有int-handleNoSpaceEndCase（字符串wholeNumber、int-endOfNumber、int-space）{
如果（这表示状态和（空格））{
int indexOfM=getIndexOfM（整数）；
endOfNumber=indexOfM；
}
返回endOfNumber；
}
private int getIndexOfM（字符串wholeNumber）{
返回全数索引（“m”）；
}
私有字符getCharacterAfterZero（字符串wholeNumber，int indexOfZero）{
int indexAfterZero=indexOfZero+1；
返回wholeNumber.charAt（零后的索引）；
}
私有字符转换器INTTOCHAR（int i）{
返回（字符）（i+48）；
}
私有字符串截断编号（字符串wholeNumber，int endOfNumber）{
返回wholeNumber.substring（0，endOfNumber）；
}
私有布尔值IsCharacterThisNumber（characterAfterZero，char iAsChar）{
返回characterAfterZero==iAsChar；
}
}

它总是复制前3个字符（x.x）。第一个0（在x.x之后），后面没有任何数字，将用作最后一个索引，指示最终数字子字符串的结束。如果在结束前数字超过0，则将使用空格（1.123 m）。如果没有空格，它将使用m（1.123m）。
现有函数不能完全满足您的要求。您需要解析字符串，取出数字，然后以所需格式打印出来。您的字符串是否始终采用“m”格式？是的，始终采用“m”格式注意：最好将数组括号放在类型后面，而不是变量名后面，即
字符串[]args
而不是
字符串args[]
。我不认为你的代码比使用正则表达式的10行代码更容易维护。事实上确实如此。更多的代码和方法也不错。例如，如果你想用“-”而不是空格，你可以很容易地找到“-”