Extract numbers from Strings, add them and convert back to string

Question

I have couple of similar strings. I want to extract the numbers from them, add the numbers and convert it back to the same string format.

And the logic should be generic, i.e., it should work for any given strings.

Example:

String s1 = "1/9";
String s2 = "12/4";

The total of the above two Strings should be "13/13" (String again)

I know how to extract numbers from any given String. I referred: How to extract numbers from a string and get an array of ints?

But I don't know how to put them up back again to the same String format.

Can any one please help me over this?

Note: the string format can be anything, I have just taken an example for explanation.

Answer 1

Take a look at this:

public class StringTest {

    public static void main(String[] args) {
        String divider = "/";

        String s1 = "1/9";
        String s2 = "12/4";

        String[] fragments1 = s1.split(divider);
        String[] fragments2 = s2.split(divider);

        int first = Integer.parseInt(fragments1[0]);
        first += Integer.parseInt(fragments2[0]);

        int second = Integer.parseInt(fragments1[1]);
        second += Integer.parseInt(fragments2[1]);

        String output = first + divider + second;
        System.out.println(output);
    }
}

The code prints:

13/13

Answer 2

Using a regex (and Markus' code)

public class StringTest {

    public static void main(String[] args) {
        String s1 = "1/9";
        String s2 = "12&4";

        String[] fragments1 = s1.split("[^\\d]");

        String[] fragments2 = s2.split("[^\\d]");

        int first = Integer.parseInt(fragments1[0]);
        first += Integer.parseInt(fragments2[0]);

        int second = Integer.parseInt(fragments1[1]);
        second += Integer.parseInt(fragments2[1]);

        String output = first + divider + second;
        System.out.println(output);
    }
}

You should be able to get from here to joining back from an array. If you're getting super fancy, you'll need to use regular expression capture groups and store the captured delimiters somewhere.

Answer 3

First, split your strings into matches and non-matches:

  public static class Token {
    public final String text;
    public final boolean isMatch;

    public Token(String text, boolean isMatch) {
      this.text = text;
      this.isMatch = isMatch;
    }

    @Override
    public String toString() {
      return text + ":" + isMatch;
    }
  }

  public static List<Token> tokenize(String src, Pattern pattern) {
    List<Token> tokens = new ArrayList<>();
    Matcher matcher = pattern.matcher(src);
    int last = 0;
    while (matcher.find()) {
      if (matcher.start() != last) {
        tokens.add(new Token(src.substring(last, matcher.start()), false));
      }
      tokens.add(new Token(src.substring(matcher.start(), matcher.end()), true));
      last = matcher.end();
    }
    if (last < src.length()) {
      tokens.add(new Token(src.substring(last), false));
    }
    return tokens;
  }

Once this is done, you can create lists you can iterate over and process.

For example, this code:

Pattern digits = Pattern.compile("\\d+");
System.out.println(tokenize("1/2", digits));

...outputs:

[1:true, /:false, 2:true]

Answer 4

Damn quick and dirty not relying on knowing which separator is used. You have to make sure, m1.group(2) and m2.group(2) are equal (which represents the separator).

public static void main(String[] args) {
    String s1 = "1/9";
    String s2 = "12/4";
    Matcher m1 = Pattern.compile("(\\d+)(.*)(\\d+)").matcher(s1);
    Matcher m2 = Pattern.compile("(\\d+)(.*)(\\d+)").matcher(s2);
    m1.matches(); m2.matches();
    int sum1 = parseInt(m1.group(1)) + parseInt(m2.group(1));
    int sum2 = parseInt(m2.group(3)) + parseInt(m2.group(3));
    System.out.printf("%s%s%s\n", sum1, m1.group(2), sum2);
}

Answer 5

Consider function:

public String format(int first, int second, String separator){
    return first + separator + second;
}

then:

System.out.println(format(6, 13, "/")); // prints "6/13"

Answer 6

Thanks @remus. Reading your logic I was able to build the following code. This code solves the problem for any given strings having same format.

public class Test { public static void main(String[] args) {

    ArrayList<Integer> numberList1 = new ArrayList<Integer>();
    ArrayList<Integer> numberList2 = new ArrayList<Integer>();
    ArrayList<Integer> outputList = new ArrayList<Integer>();

    String str1 = "abc 11:4 xyz 10:9";
    String str2 = "abc 9:2  xyz 100:11";

    String output = "";

    // Extracting numbers from the two similar string
    Pattern p1 = Pattern.compile("-?\\d+");

    Matcher m = p1.matcher(str1);
    while (m.find()) {
        numberList1.add(Integer.valueOf(m.group()));
    }

    m = p1.matcher(str2);
    while (m.find()) {
        numberList2.add(Integer.valueOf(m.group()));
    }

    // Numbers extracted. Printing them
    System.out.println("List1: " + numberList1);
    System.out.println("List2: " + numberList2);

    // Adding the respective indexed numbers from both the lists
    for (int i = 0; i < numberList1.size(); i++) {
        outputList.add(numberList1.get(i) + numberList2.get(i));
    }

    // Printing the summed list
    System.out.println("Output List: " + outputList);

    // Splitting string to segregate numbers from text and getting the format
    String[] template = str1.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");

    // building the string back using the summed list and format
    int counter = 0;
    for (String tmp : template) {
        if (Test.isInteger(tmp)) {
            output += outputList.get(counter);
            counter++;
        } else {
            output += tmp;
        }
    }

    // Printing the output
    System.out.println(output);
}

public static boolean isInteger(String s) {
    try {
        Integer.parseInt(s);
    } catch (NumberFormatException e) {
        return false;
    }
    return true;
}

}

output:

List1: [11, 4, 10, 9]
List2: [9, 2, 100, 11]
Output List: [20, 6, 110, 20]
abc 20:6 xyz 110:20