Java填充从文件读取的字符串

好的，我有一个读取整数的文件，从一个看起来像这样的文件。

123456-1324563

该文件将这些数字作为字符串读取，我试图找出如何创建一个方法，将数字

0

附加到正在读取的数字的哪一侧小于另一侧

例如，如果运算符左侧的数字少于右侧的数字，则会将0添加到字符串中，使两个数字变为偶数并返回新字符串。因此，我需要将类似

123456789-123456

的字符串转换为

123456789-000123456

。但它需要确定哪一侧较短，并在其前面填充0，但仍然返回整个字符串

编辑：

这是我使用的此方法的最新版本，当传入

+

运算符时，我将获得

ArrayIndexOutOfBoundsException

。但它与

-

操作符完美配合

public String pad(String line, String operator){
    String str[] = line.split(Pattern.quote(operator));

    StringBuilder left = new StringBuilder(str[0]);
    StringBuilder right = new StringBuilder(str[1]);
    left = left.reverse();
    right = right.reverse();
    int len1 = left.length();
    int len2 = right.length();
    if(len1>len2){
        while(len1!=len2){
            right.append("0");
            len1--;
        }
    }else{
        while(len1!=len2){
            left.append("0");
            len2--;
        }
    }
    return left.reverse().toString()+operator+right.reverse().toString();
}

---

使用Java8，更简洁紧凑的版本

public  String pad_num(String line, String operator){
    String str[] = line.split(Pattern.quote(operator));
    char []buff = new char[Math.abs(str[0].length()-str[1].length())];
    Arrays.fill(buff, '0');
    if(str[0].length()>str[1].length()){            
        return String.join(operator, str[0], new StringBuilder(String.valueOf(buff)).append(str[1]));
    }else{
        return String.join(operator, new StringBuilder(String.valueOf(buff)).append(str[0]), str[1]);
    }
}

如果您没有java8，请使用此方法的实现

public  String pad_num(String line, String operator){
    String str[] = line.split(Pattern.quote(operator)); 
    StringBuilder left = new StringBuilder(str[0]);
    StringBuilder right = new StringBuilder(str[1]);
    left = left.reverse();
    right = right.reverse();
    int len1 = left.length();
    int len2 = right.length();
    if(len1>len2){
        while(len1!=len2){
            right.append("0");
            len1--;
        }
    }else{
        while(len1!=len2){
            left.append("0");
            len2--;
        }
    }
    return left.reverse().toString()+operator+right.reverse().toString();

}

并将这些方法称为

String result = pad_num("123456+1324563", "+");
String result = pad_num("123456-1324563", "-");

编辑：

ArrayIndexOutOfBoundsException

的原因是使用不匹配的参数调用方法，如

pad_num("123456-1324563", "+");   // - in line and + in operator

或

一个简单的解决方案：

public static String pad_num(String line){
    String[] groups = line.split("-");
    String left = groups[0],
            right = groups[1];

    if(left.length() < right.length()) {
        do {
            left = '0'+left;
        } while (left.length() < right.length());
    } else if(right.length() < left.length()) {
        do {
            right = '0'+right;
        } while (right.length() < left.length());
    }

    return left+'-'+right;
}

您可以这样做：

public String pad_num(String line){
        String[] lines = line.split("-");
        String s1=lines[0];
        String s2=lines[1];
        StringBuilder sb = new StringBuilder();
        if(s1.length() == s2.length()){
            return line;
        }else if(s1.length() > s2.length()){
            sb.append(s1);
            sb.append("-");
            for(int i=0;i<s1.length()-s2.length();i++){
                //add zeros before s2
                sb.append("0");
            }
            sb.append(s2);
        }else{
            for(int i=0;i<s2.length()-s1.length();i++){
                //add zeros before s1
                sb.append("0");
            }
            sb.append(s1);
            sb.append("-");
            sb.append(s2);
        }
    return sb.toString();
}

公共字符串pad_num（字符串行）{
字符串[]行=行。拆分（“”）；
字符串s1=行[0]；
字符串s2=行[1]；
StringBuilder sb=新的StringBuilder（）；
如果（s1.length（）==s2.length（））{
回流线；
}else if（s1.length（）>s2.length（））{
sb.追加（s1）；
某人加上（“—”）；
对于（int i=0；i给定的解决方案有效。只是使用ApacheStringUtils的备用解决方案。

public static String pad_num(String line){
    String paddedStr = null;
    String[] numbers = StringUtils.split(line, "-");
    if(numbers == null || (numbers[0].length() == numbers[1].length())) {
        return line;
    }

    if(numbers[0].length() > numbers[1].length()) {
        paddedStr = numbers[0] + "-" + StringUtils.leftPad(numbers[1], numbers[0].length(), "0");
    } else {
        paddedStr = StringUtils.leftPad(numbers[0], numbers[1].length(), "0") + "-" + numbers[1];
    }
    return paddedStr;
}

在“现实生活”（假设这不是家庭作业）中，您应该使用库来实现此目的。例如，使用，该方法简化为：

import static com.google.common.base.Strings.padStart;
/* ... */
public String pad(String line, String delim, char padding) {

    String[] tokens = line.split(delim);
    int[] lengths = new int[] {tokens[0].length(), tokens[1].length()};

    return lengths[0] > lengths[1] 
            ? tokens[0] + delim + padStart(tokens[1], lengths[0], padding)

                : lengths[0] < lengths[1]
                    ? padStart(tokens[0], lengths[1], padding) + delim + tokens[1]

                             : line;
}

屈服

0123456-1324563
1324563-0123456
123456789-000123456
123456-123456
正如其他人已经告诉您的那样，为此（/）使用lib

如果您坚持要求，另一个如何手动执行此操作的示例：

String pad(String s) {
    String[] parts = s.split("-");
    int n = parts[0].length() - parts[1].length();
    return n < 0
            ? String.format("%s%s-%s", zeros(Math.abs(n)), parts[0], parts[1])
            : String.format("%s-%s%s", parts[0], zeros(Math.abs(n)), parts[1]);
}

对于给定的示例，您能告诉所需的输出吗？对不起，关于这个问题，确定，因此函数后的给定输出将使上面的字符串如下所示：0123456-1324563。@用户5448221，请像编辑一样编辑您的问题，而不是更改问题的全部含义，那么现有的答案可能会变得毫无意义。或者，如果您有其他问题然后再次询问。如果您以
pad（“123456789-123456”、“+”）的形式调用，它会给出
索引越界异常
，
，
，但正确的调用应该是
pad（“123456789+123456”、“+”；
）。您可以在第行和运算符传递“+”中传递带有
-
的字符串。如果运算符恰好是+符号而不是-，我将如何处理拆分。您需要预加
0
而不是附加它（参见他的示例）。更改
右侧。将（“0”）
附加到
右侧。插入（0，“0”）
。当我传入运算符时，如果它是加号，我现在会遇到问题：java.util.regex.PatternSyntaxException：在索引0++@RonC附近悬空元字符“+”，这很好，我反转了StringBuilder，因此append将以更高的性能工作。嗯，我想以字符的形式传入运算符。字符串conca使用
String
的tenation不太可取，因为每次它都会生成新的字符串。StringBuilder就是用来处理连接的。@Zaman这是一个简单的解决方案。如果性能很重要，那么使用
StringBuilder
就更好了。我只是尝试使用它来添加非常大的数字，通过将它们分解为smaller parts.Nice and compact！但是，使用此代码，右侧的标记用尾随而不是前导零填充。您需要将return语句更改为类似
return numZeros<0？padding+s:s.substring（0，s.indexOf（“-”）+“-”+padding+s.substring（s.indexOf（“-”）+1）
哦，在那种情况下，我误解了问题。谢谢你的澄清：）现在改为左撇子！
import static com.google.common.base.Strings.padStart;
/* ... */
public String pad(String line, String delim, char padding) {

    String[] tokens = line.split(delim);
    int[] lengths = new int[] {tokens[0].length(), tokens[1].length()};

    return lengths[0] > lengths[1] 
            ? tokens[0] + delim + padStart(tokens[1], lengths[0], padding)

                : lengths[0] < lengths[1]
                    ? padStart(tokens[0], lengths[1], padding) + delim + tokens[1]

                             : line;
}

System.out.println(pad("123456-1324563", "-", '0'));
System.out.println(pad("1324563-123456", "-", '0'));
System.out.println(pad("123456789-123456", "-", '0'));
System.out.println(pad("123456-123456", "-", '0'));

0123456-1324563
1324563-0123456
123456789-000123456
123456-123456
String pad(String s) {
    String[] parts = s.split("-");
    int n = parts[0].length() - parts[1].length();
    return n < 0
            ? String.format("%s%s-%s", zeros(Math.abs(n)), parts[0], parts[1])
            : String.format("%s-%s%s", parts[0], zeros(Math.abs(n)), parts[1]);
}

String zeros(int numZeros) {
    char[] chars = new char[numZeros];
    Arrays.fill(chars, '0');
    return new String(chars);
}